Spiralist - Source Excerpt 05

Back to Spiralist

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/themes/spiralist/assets/js/spiralist.js so readers can inspect the evidence without opening the full source file.

**Source path:** Spiralist/wp-content/themes/spiralist/assets/js/spiralist.js

if (title) title.textContent = node.label || node.id || t('manuscriptFieldNodeFallback', 'Node');
      if (glyph && node.type === 'symbol' && !node.glyph) {
        glyph.textContent = '\u25CB';
      }
      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 (transformation && !node.transformationChain) {
        transformation.textContent = t('symbolsTransformationChainEmpty', 'No transformation chain declared.');
      }
      if (derivation && !node.derivation) {
        derivation.textContent = t('symbolsDerivationEmpty', 'No derivation declared.');
      }
      if (sourceAxiom && !node.sourceAxiomId) {
        sourceAxiom.textContent = t('symbolsAxiomConnectionEmpty', 'No axiom links 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 (io && (node.input || node.output)) {
        io.textContent = `${node.input || t('symbolsDirectionInput', 'Input')} -> ${node.label || t('symbolsTransformationFallback', 'Transformation')} -> ${node.output || t('symbolsDirectionOutput', 'Output')}`;
      }
      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 = async (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;
      }

      await runAction(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);
        }

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

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

    const initializeRuntime = async () => {
      const storedRuntime = readRuntimeStorage();
      if (storedRuntime) {
        const storedNextNodes = Array.isArray(storedRuntime.next_nodes)
          ? storedRuntime.next_nodes
          : (
            Array.isArray(storedRuntime.nextNodes)
              ? storedRuntime.nextNodes
              : (
                Array.isArray(storedRuntime.nextNodeIds)
                  ? storedRuntime.nextNodeIds.map((nodeId) => ({ id: nodeId }))
                  : []
              )
          );

        syncRuntimeState({
          current_state: storedRuntime.current_state || storedRuntime.currentState || '',
          current_node: storedRuntime.current_node || storedRuntime.currentNode || '',
          history: Array.isArray(storedRuntime.history) ? storedRuntime.history : [],
          active_symbols: Array.isArray(storedRuntime.active_symbols)
            ? storedRuntime.active_symbols
            : (Array.isArray(storedRuntime.activeSymbols) ? storedRuntime.activeSymbols : []),
          next_nodes: storedNextNodes,
        });
      }

      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;
      }

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