Book Shell - Source Excerpt 05

Back to Book Shell

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/plugins/ns12-manuscript/assets/js/book-shell.js so readers can inspect the evidence without opening the full source file.

**Source path:** Spiralist/wp-content/plugins/ns12-manuscript/assets/js/book-shell.js

if (summary) summary.textContent = node.meaning || t('manuscriptFieldSummaryEmpty', 'No summary available for this node.');
      if (id) id.textContent = node.canonicalId || node.id || '';
      if (layer) layer.textContent = formatNodeType(getNodeMode(node));
      if (meaning) meaning.textContent = node.meaning || t('manuscriptFieldMeaningEmpty', 'No meaning declared.');
      if (definition) definition.textContent = node.definition || t('manuscriptFieldDefinitionEmpty', 'No definition declared.');
      if (transformation) transformation.textContent = node.transformationChain || t('symbolsTransformationChainEmpty', 'No transformation chain declared.');
      if (derivation) derivation.textContent = node.derivation || t('symbolsDerivationEmpty', 'No derivation declared.');
      if (sourceAxiom) sourceAxiom.textContent = node.sourceAxiomId || t('manuscriptFieldSourceAxiomEmpty', 'No source axiom declared.');
      if (io) {
        io.textContent = node.input || node.output
          ? `${node.input || t('symbolsDirectionInput', 'Input')} -> ${node.label || t('symbolsTransformationFallback', 'Transformation')} -> ${node.output || t('symbolsDirectionOutput', 'Output')}`
          : t('manuscriptFieldIoNotTransformation', 'This node is not a transformation surface.');
      }
      if (json) {
        json.textContent = JSON.stringify(
          {
            id: node.id,
            type: node.type,
            mode: getNodeMode(node),
            canonicalId: node.canonicalId,
            aliases: node.aliases || [],
            meaning: node.meaning,
            definition: node.definition,
            transformationChain: node.transformationChain,
            derivation: node.derivation,
            derivesFrom: node.derivesFrom || [],
            related: node.related || [],
            input: node.input || null,
            output: node.output || null,
            canonicalValidation: node.canonicalValidation || null,
          },
          null,
          2
        );
      }

      setRelatedNodes(node);
      setCrosswalkLinks(node);
      loadPromptReferences(
        prompts,
        buildPromptFilters(node),
        t('manuscriptFieldPromptsEmpty', 'No related prompts for this node yet.')
      );
    };

    const executeSelectedNode = (nodeId) => {
      const node = nodesById.get(nodeId);
      if (!node) {
        return;
      }

      if (!executeUrl || !node.executionEnabled) {
        setStatusState(
          statusTarget,
          `${buildStatusMessage()} ${t('manuscriptFieldExecutionUnavailable', 'Inspection remains available, but this node is not part of the executable runtime graph.')}`,
          'ready'
        );
        return;
      }

      runBackgroundAction(async () => {
        const response = await fetch(executeUrl, {
          method: 'POST',
          headers: {
            ...runtimeHeaders,
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            node_id: node.id,
            current_state: runtimeState.currentState || node.inputState || node.input || '',
          }),
        });
        const payloadState = await response.json();

        if (!response.ok) {
          const responseErrors = Array.isArray(payloadState?.data?.errors)
            ? payloadState.data.errors
            : Array.isArray(payloadState?.errors)
              ? payloadState.errors
              : [];
          const detail = responseErrors.length ? responseErrors.join(' ') : '';
          throw new Error(detail || payloadState.message || formatText('manuscriptFieldExecutionFailedStatus', 'Execution failed with {status}.', { status: response.status }));
        }

        if (payloadState.new_state || payloadState.newState) {
          runtimeState.currentState = payloadState.new_state || payloadState.newState;
        }

        if (Array.isArray(payloadState.history)) {
          runtimeState.history = payloadState.history;
        }

        if (Array.isArray(payloadState.active_symbols) || Array.isArray(payloadState.activeSymbols)) {
          runtimeState.activeSymbols = Array.isArray(payloadState.active_symbols)
            ? payloadState.active_symbols
            : payloadState.activeSymbols;
        }

        if (Array.isArray(payloadState.next_nodes) || Array.isArray(payloadState.nextNodes)) {
          const nextNodes = Array.isArray(payloadState.next_nodes)
            ? payloadState.next_nodes
            : payloadState.nextNodes;

          runtimeState.nextNodeIds = nextNodes
            .map((entry) => (entry && typeof entry === 'object' ? (entry.node_id || entry.id || '') : ''))
            .filter(Boolean);
        }

        if (payloadState.instance && typeof payloadState.instance === 'object') {
          syncRuntimeState(payloadState.instance);
        }

        runtimeState.currentNode = node.id || '';
        writeRuntimeStorage();
        markNodeState(selectedNodeId);
        renderRelations(selectedNodeId);
        updateFieldStatus('ready');
      }, {
        context: 'field-node-execution',
        onError: (error) => {
          setStatusState(
            statusTarget,
            `${buildStatusMessage()} ${error && error.message ? error.message : t('manuscriptFieldExecutionFailed', 'Execution failed.')}`,
            'error'
          );
        },
      });
    };

    const initializeRuntime = async () => {
      const storedRuntime = readRuntimeStorage();
      if (storedRuntime) {
        syncRuntimeState({
          current_state: storedRuntime.currentState || '',
          current_node: storedRuntime.currentNode || '',
          history: Array.isArray(storedRuntime.history) ? storedRuntime.history : [],
          active_symbols: Array.isArray(storedRuntime.activeSymbols) ? storedRuntime.activeSymbols : [],
          next_nodes: Array.isArray(storedRuntime.nextNodeIds)
            ? storedRuntime.nextNodeIds.map((nodeId) => ({ id: nodeId }))
            : [],
        });
      }

      if (payload.runtime && typeof payload.runtime === 'object' && !runtimeState.currentState) {
        syncRuntimeState({
          current_state: payload.runtime.defaultState || '',
          next_nodes: Array.isArray(payload.runtime.nextNodes) ? payload.runtime.nextNodes : [],
        });
      }

      if (!instanceUrl) {
        return;
      }

      await runBackgroundAction(async () => {
        const response = await fetch(instanceUrl, { headers: runtimeHeaders });
        if (!response.ok) {
          throw new Error(`Instance load failed with ${response.status}`);
        }