@turing-machine-js/machine 3.0.0 → 3.0.1

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.0.1] - 2026-04-30
+
+### Fixed
+
+- **`graphFormats.ts` — polynomial-time regex (CodeQL `js/polynomial-redos`).** `alphabetsRegex` was `/^%%\s*alphabets:\s*(.+)$/`, where the `\s*` and `(.+)` both match whitespace, letting the engine try N+1 split points on inputs like `"%%alphabets:"` followed by many trailing spaces. Anchored the first captured char as `\S` to remove the ambiguity.
+
+### Added
+
+- **`MachineState` re-export** from `index.ts`. The type was always `export type MachineState = ...` in `classes/TuringMachine.ts`, but the package barrel didn't surface it. Consumers (notably `@post-machine-js/machine`'s `PostMachine` overrides of `run` / `runStepByStep`) can now `import { type MachineState } from '@turing-machine-js/machine'` directly, dropping any local `Generator<infer T>` workaround.
+
+### Changed (internal)
+
+- Removed the unreachable `if (hasCycles) return` guard at the top of `summarizeGraph`'s `visit()` cycle-detection. The recursive call pattern (outer for-loop checks before calling, inner loop checks after each recursive call) ensures `visit()` is never invoked when `hasCycles` is already true. Static analysis confirmed the guard was dead code.
+- Tightened test coverage on `State.ts` and the v3 utilities — overall coverage rose from 95.64% / 88.39% / 95.5% (statements/branches/lines) to 98.39% / 94.01% / 98.34%. New tests cover invalid-input paths in the `State` constructor (string-keyed definitions, non-`State`/`Reference` `nextState`, empty-array commands), the `getSymbol` fallback to `ifOtherSymbol`, the `toGraph` skip of unbound `Reference` transitions, the `fromGraph` cyclic-override-halt error, and the previously-unexercised branches in `splitUnescaped`, `parsePatternString`, `parseMovementLabel`, and `fromMermaid`'s ensureNode update / error paths.
+
 ## [3.0.0] - 2026-04-30
 
 ### Added

package/dist/index.cjs

@@ -1048,7 +1048,9 @@ const initialNodeRegex = /^s(\d+)\(\("([^"]*)"\)\)$/;
 const regularNodeRegex = /^s(\d+)\["([^"]*)"\]$/;
 const transitionRegex = /^s(\d+)\s+--\s+"(.*)"\s+-->\s+s(\d+)$/;
 const onHaltRegex = /^s(\d+)\s+-\.\s+onHalt\s+\.->\s+s(\d+)$/;
-const alphabetsRegex = /^%%\s*alphabets:\s*(.+)$/;
+// First capture char anchored as \S to avoid polynomial backtracking between
+// the preceding \s* and a permissive (.+); see CodeQL js/polynomial-redos.
+const alphabetsRegex = /^%%\s*alphabets:\s*(\S.*)$/;
 function fromMermaid(text) {
     const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
     let alphabets = [];
@@ -1180,9 +1182,10 @@ function summarizeGraph(graph) {
     }
     let hasCycles = false;
     const visit = (id) => {
-        if (hasCycles) {
-            return;
-        }
+        // No `if (hasCycles) return` guard at function entry: the recursive call
+        // pattern (outer for-loop checks before calling, inner loop checks after
+        // each recursive call) ensures visit() is never invoked when hasCycles
+        // is already true. Static analysis confirmed the guard was unreachable.
         if (color.get(id) === GREY) {
             hasCycles = true;
             return;
@@ -1279,12 +1282,16 @@ function runOnce(runnable, input, stepsLimit) {
     const machine = new TuringMachine({ tapeBlock });
     const snapshots = [];
     let stepCount = 0;
-    // Inside the for-of body, the tape reflects the state BEFORE the current
-    // step's command (i.e. AFTER the previous step's command — or initial for
-    // step 1). After the loop, the tape has had every command applied.
-    for (const _ of machine.runStepByStep({ initialState: runnable.state, stepsLimit })) {
+    // Iterate the generator manually (the yielded MachineState isn't needed —
+    // we only care about the side effects on the tape). At each yield the tape
+    // reflects the state BEFORE the current step's command; after the loop
+    // exits the tape has had every command applied.
+    const generator = machine.runStepByStep({ initialState: runnable.state, stepsLimit });
+    let result = generator.next();
+    while (!result.done) {
         snapshots.push(tape.symbols.join(''));
         stepCount += 1;
+        result = generator.next();
     }
     snapshots.push(tape.symbols.join(''));
     return {

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { default as State, haltState, ifOtherSymbol } from './classes/State';
 export { default as Tape } from './classes/Tape';
 export { default as TapeBlock } from './classes/TapeBlock';
 export { default as TapeCommand, movements, symbolCommands } from './classes/TapeCommand';
-export { default as TuringMachine } from './classes/TuringMachine';
+export { default as TuringMachine, type MachineState } from './classes/TuringMachine';
 export { type Graph, type GraphNode, type GraphTransition, type GraphCommand } from './utilities/graph';
 export { toMermaid, fromMermaid } from './utilities/graphFormats';
 export { summarize, summarizeGraph, type GraphSummary } from './utilities/introspection';

package/dist/index.mjs

@@ -1046,7 +1046,9 @@ const initialNodeRegex = /^s(\d+)\(\("([^"]*)"\)\)$/;
 const regularNodeRegex = /^s(\d+)\["([^"]*)"\]$/;
 const transitionRegex = /^s(\d+)\s+--\s+"(.*)"\s+-->\s+s(\d+)$/;
 const onHaltRegex = /^s(\d+)\s+-\.\s+onHalt\s+\.->\s+s(\d+)$/;
-const alphabetsRegex = /^%%\s*alphabets:\s*(.+)$/;
+// First capture char anchored as \S to avoid polynomial backtracking between
+// the preceding \s* and a permissive (.+); see CodeQL js/polynomial-redos.
+const alphabetsRegex = /^%%\s*alphabets:\s*(\S.*)$/;
 function fromMermaid(text) {
     const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
     let alphabets = [];
@@ -1178,9 +1180,10 @@ function summarizeGraph(graph) {
     }
     let hasCycles = false;
     const visit = (id) => {
-        if (hasCycles) {
-            return;
-        }
+        // No `if (hasCycles) return` guard at function entry: the recursive call
+        // pattern (outer for-loop checks before calling, inner loop checks after
+        // each recursive call) ensures visit() is never invoked when hasCycles
+        // is already true. Static analysis confirmed the guard was unreachable.
         if (color.get(id) === GREY) {
             hasCycles = true;
             return;
@@ -1277,12 +1280,16 @@ function runOnce(runnable, input, stepsLimit) {
     const machine = new TuringMachine({ tapeBlock });
     const snapshots = [];
     let stepCount = 0;
-    // Inside the for-of body, the tape reflects the state BEFORE the current
-    // step's command (i.e. AFTER the previous step's command — or initial for
-    // step 1). After the loop, the tape has had every command applied.
-    for (const _ of machine.runStepByStep({ initialState: runnable.state, stepsLimit })) {
+    // Iterate the generator manually (the yielded MachineState isn't needed —
+    // we only care about the side effects on the tape). At each yield the tape
+    // reflects the state BEFORE the current step's command; after the loop
+    // exits the tape has had every command applied.
+    const generator = machine.runStepByStep({ initialState: runnable.state, stepsLimit });
+    let result = generator.next();
+    while (!result.done) {
         snapshots.push(tape.symbols.join(''));
         stepCount += 1;
+        result = generator.next();
     }
     snapshots.push(tape.symbols.join(''));
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turing-machine-js/machine",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "A convenient Turing machine",
   "engines": {
     "npm": ">=7.0.0"
@@ -34,5 +34,5 @@
       "default": "./dist/index.mjs"
     }
   },
-  "gitHead": "98decf323129d528febafac1bec581a9ee3800ff"
+  "gitHead": "0a8d7ff87a3a73ea7ee1844f7f4602cbb23d20fe"
 }

package/dist/classes/Alphabet.js

@@ -1,50 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Alphabet_symbols;
-import { uniquePredicate } from '../utilities/functions';
-class Alphabet {
-    constructor(symbols) {
-        _Alphabet_symbols.set(this, void 0);
-        if (symbols instanceof Alphabet) {
-            symbols = symbols.symbols;
-        }
-        const uniqueSymbols = symbols.filter(uniquePredicate);
-        if (uniqueSymbols.length < 2) {
-            throw new Error('Invalid symbols length');
-        }
-        const isSymbolsValid = uniqueSymbols.every((symbol) => symbol.length === 1);
-        if (!isSymbolsValid) {
-            throw new Error('symbols contains invalid symbol');
-        }
-        __classPrivateFieldSet(this, _Alphabet_symbols, Array.from(uniqueSymbols), "f");
-    }
-    get symbols() {
-        return Array.from(__classPrivateFieldGet(this, _Alphabet_symbols, "f"));
-    }
-    get blankSymbol() {
-        return __classPrivateFieldGet(this, _Alphabet_symbols, "f")[0];
-    }
-    has(symbol) {
-        return __classPrivateFieldGet(this, _Alphabet_symbols, "f").indexOf(symbol) >= 0;
-    }
-    get(index) {
-        if (index < 0 || index >= __classPrivateFieldGet(this, _Alphabet_symbols, "f").length) {
-            throw new Error('Invalid index');
-        }
-        return __classPrivateFieldGet(this, _Alphabet_symbols, "f")[index];
-    }
-    index(symbol) {
-        return __classPrivateFieldGet(this, _Alphabet_symbols, "f").indexOf(symbol);
-    }
-}
-_Alphabet_symbols = new WeakMap();
-export default Alphabet;

package/dist/classes/Command.js

@@ -1,38 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Command_tapesCommands;
-import TapeCommand from './TapeCommand';
-class Command {
-    constructor(tapesCommands) {
-        _Command_tapesCommands.set(this, void 0);
-        if (tapesCommands.length === 0) {
-            throw new Error('invalid parameter');
-        }
-        try {
-            __classPrivateFieldSet(this, _Command_tapesCommands, tapesCommands.map((tapeCommand) => {
-                if (tapeCommand instanceof TapeCommand) {
-                    return tapeCommand;
-                }
-                return new TapeCommand(tapeCommand);
-            }), "f");
-        }
-        catch (error) {
-            void error;
-            throw new Error('invalid tapeCommand');
-        }
-    }
-    get tapesCommands() {
-        return [...__classPrivateFieldGet(this, _Command_tapesCommands, "f")];
-    }
-}
-_Command_tapesCommands = new WeakMap();
-export default Command;

package/dist/classes/Lock.js

@@ -1,34 +0,0 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Lock_lockSymbol;
-class Lock {
-    constructor() {
-        _Lock_lockSymbol.set(this, null);
-    }
-    lock(symbol) {
-        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") === null) {
-            __classPrivateFieldSet(this, _Lock_lockSymbol, symbol, "f");
-        }
-    }
-    unlock(symbol) {
-        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") === symbol) {
-            __classPrivateFieldSet(this, _Lock_lockSymbol, null, "f");
-        }
-    }
-    check(symbol) {
-        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") && __classPrivateFieldGet(this, _Lock_lockSymbol, "f") !== symbol) {
-            throw new Error('Lock check failed');
-        }
-    }
-}
-_Lock_lockSymbol = new WeakMap();
-export default Lock;

package/dist/classes/Reference.js

@@ -1,31 +0,0 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Reference_referenceBinding;
-class Reference {
-    constructor() {
-        _Reference_referenceBinding.set(this, null);
-    }
-    get ref() {
-        if (!__classPrivateFieldGet(this, _Reference_referenceBinding, "f")) {
-            throw new Error('unbounded reference');
-        }
-        return __classPrivateFieldGet(this, _Reference_referenceBinding, "f");
-    }
-    bind(state) {
-        if (__classPrivateFieldGet(this, _Reference_referenceBinding, "f") == null) {
-            __classPrivateFieldSet(this, _Reference_referenceBinding, state, "f");
-        }
-        return __classPrivateFieldGet(this, _Reference_referenceBinding, "f");
-    }
-}
-_Reference_referenceBinding = new WeakMap();
-export default Reference;

package/dist/classes/State.js

@@ -1,283 +0,0 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _State_id, _State_name, _State_overrodeHaltState, _State_symbolToDataMap;
-import Alphabet from './Alphabet';
-import Command from './Command';
-import Reference from './Reference';
-import TapeBlock from './TapeBlock';
-import TapeCommand from './TapeCommand';
-import { id } from '../utilities/functions';
-import { decodeMovement, decodePatternDescription, decodeWriteSymbol, parseMovementLabel, parsePatternString, parseWriteSymbolLabel, } from '../utilities/graph';
-export const ifOtherSymbol = Symbol('other symbol');
-class State {
-    constructor(stateDefinition = null, name) {
-        _State_id.set(this, id(this));
-        _State_name.set(this, void 0);
-        _State_overrodeHaltState.set(this, null);
-        _State_symbolToDataMap.set(this, new Map());
-        if (stateDefinition) {
-            const keys = Object.getOwnPropertyNames(stateDefinition);
-            if (keys.length) {
-                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet(this, _State_id, "f")}`);
-            }
-            const symbols = Object.getOwnPropertySymbols(stateDefinition);
-            if (symbols.length === 0) {
-                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet(this, _State_id, "f")}`);
-            }
-            symbols.forEach((symbol) => {
-                const { nextState } = stateDefinition[symbol];
-                const nextStateLocal = nextState ?? this;
-                if (!(nextStateLocal instanceof State) && !(nextStateLocal instanceof Reference)) {
-                    throw new Error('invalid nextState');
-                }
-                let { command } = stateDefinition[symbol];
-                if (command == null) {
-                    command = new Command([
-                        new TapeCommand({}),
-                    ]);
-                }
-                if (!(command instanceof Command) && !Array.isArray(command)) {
-                    command = [command];
-                }
-                let commandLocal = command;
-                if (Array.isArray(command)) {
-                    try {
-                        commandLocal = new Command(command);
-                    }
-                    catch (error) {
-                        void error;
-                    }
-                }
-                if (!(commandLocal instanceof Command)) {
-                    throw new Error('invalid command');
-                }
-                __classPrivateFieldGet(this, _State_symbolToDataMap, "f").set(symbol, {
-                    command: commandLocal,
-                    nextState: nextStateLocal,
-                });
-            });
-        }
-        __classPrivateFieldSet(this, _State_name, name ?? `id:${__classPrivateFieldGet(this, _State_id, "f")}`, "f");
-    }
-    get id() {
-        return __classPrivateFieldGet(this, _State_id, "f");
-    }
-    get name() {
-        return __classPrivateFieldGet(this, _State_name, "f");
-    }
-    get isHalt() {
-        return __classPrivateFieldGet(this, _State_id, "f") === 0;
-    }
-    get overrodeHaltState() {
-        return __classPrivateFieldGet(this, _State_overrodeHaltState, "f");
-    }
-    get ref() {
-        return this;
-    }
-    getSymbol(tapeBlock) {
-        const symbol = [...__classPrivateFieldGet(this, _State_symbolToDataMap, "f").keys()].find((currentSymbol) => tapeBlock.isMatched({
-            symbol: currentSymbol,
-        }));
-        if (symbol) {
-            return symbol;
-        }
-        return ifOtherSymbol;
-    }
-    getCommand(symbol) {
-        if (__classPrivateFieldGet(this, _State_symbolToDataMap, "f").has(symbol)) {
-            return __classPrivateFieldGet(this, _State_symbolToDataMap, "f").get(symbol).command;
-        }
-        throw new Error(`No command for symbol at state named ${__classPrivateFieldGet(this, _State_name, "f")}`);
-    }
-    getNextState(symbol) {
-        if (__classPrivateFieldGet(this, _State_symbolToDataMap, "f").has(symbol)) {
-            return __classPrivateFieldGet(this, _State_symbolToDataMap, "f").get(symbol).nextState;
-        }
-        throw new Error(`No nextState for symbol at state named ${__classPrivateFieldGet(this, _State_id, "f")}`);
-    }
-    withOverrodeHaltState(overrodeHaltState) {
-        const state = new State(null, `${this.name}>${overrodeHaltState.name}`);
-        __classPrivateFieldSet(state, _State_symbolToDataMap, __classPrivateFieldGet(this, _State_symbolToDataMap, "f"), "f");
-        __classPrivateFieldSet(state, _State_overrodeHaltState, overrodeHaltState, "f");
-        return state;
-    }
-    // Single-state introspection — no traversal, no tapeBlock required.
-    // Returns id, name, halt-status, override-halt target, and the list of
-    // transitions out of this state with decoded write/movement labels.
-    // Symbol patterns are returned as the raw description string from the
-    // interned JS Symbol (decode via decodePatternDescription if needed).
-    static inspect(state) {
-        const transitions = [];
-        for (const [sym, { command, nextState }] of __classPrivateFieldGet(state, _State_symbolToDataMap, "f")) {
-            let target = null;
-            try {
-                target = nextState instanceof State ? nextState : nextState.ref;
-            }
-            catch {
-                target = null; // unbound Reference
-            }
-            transitions.push({
-                rawPatternDescription: sym.description,
-                command: command.tapesCommands.map((tc) => ({
-                    symbol: decodeWriteSymbol(tc.symbol),
-                    movement: decodeMovement(tc.movement.description),
-                })),
-                nextState: target ? { id: target.id, name: target.name } : null,
-            });
-        }
-        return {
-            id: __classPrivateFieldGet(state, _State_id, "f"),
-            name: __classPrivateFieldGet(state, _State_name, "f"),
-            isHalt: state.isHalt,
-            overrodeHaltState: __classPrivateFieldGet(state, _State_overrodeHaltState, "f")
-                ? { id: __classPrivateFieldGet(state, _State_overrodeHaltState, "f").id, name: __classPrivateFieldGet(state, _State_overrodeHaltState, "f").name }
-                : null,
-            transitions,
-        };
-    }
-    static toGraph(initialState, tapeBlock) {
-        const nodes = {};
-        const queue = [initialState];
-        const alphabets = tapeBlock.alphabets.map((alphabet) => alphabet.symbols);
-        while (queue.length > 0) {
-            const current = queue.shift();
-            if (__classPrivateFieldGet(current, _State_id, "f") in nodes) {
-                continue;
-            }
-            const node = {
-                id: __classPrivateFieldGet(current, _State_id, "f"),
-                name: __classPrivateFieldGet(current, _State_name, "f"),
-                isHalt: current.isHalt,
-                transitions: [],
-                overrodeHaltStateId: __classPrivateFieldGet(current, _State_overrodeHaltState, "f")?.id ?? null,
-            };
-            nodes[__classPrivateFieldGet(current, _State_id, "f")] = node;
-            if (__classPrivateFieldGet(current, _State_overrodeHaltState, "f")) {
-                queue.push(__classPrivateFieldGet(current, _State_overrodeHaltState, "f"));
-            }
-            for (const [sym, { command, nextState }] of __classPrivateFieldGet(current, _State_symbolToDataMap, "f")) {
-                let target;
-                try {
-                    target = nextState instanceof State ? nextState : nextState.ref;
-                }
-                catch {
-                    continue;
-                }
-                node.transitions.push({
-                    pattern: decodePatternDescription(sym.description, alphabets),
-                    command: command.tapesCommands.map((tc) => ({
-                        symbol: decodeWriteSymbol(tc.symbol),
-                        movement: decodeMovement(tc.movement.description),
-                    })),
-                    nextStateId: target.id,
-                });
-                queue.push(target);
-            }
-        }
-        return { initialId: __classPrivateFieldGet(initialState, _State_id, "f"), alphabets, nodes };
-    }
-    // Inverse of toGraph: rebuilds a State graph (and a fresh TapeBlock with the
-    // graph's alphabets) from a serialized Graph. Round-trips with toGraph in
-    // the sense that running the rebuilt machine on the same input gives the
-    // same output, but the rebuilt State instances have *new* internal IDs.
-    static fromGraph(graph) {
-        const alphabetObjs = graph.alphabets.map((syms) => new Alphabet(syms));
-        const tapeBlock = TapeBlock.fromAlphabets(alphabetObjs);
-        const ids = Object.keys(graph.nodes).map(Number);
-        // Pass 1: pre-create a Reference for each non-halt node so transitions can
-        // forward-declare their targets.
-        const refs = {};
-        for (const nodeId of ids) {
-            if (!graph.nodes[nodeId].isHalt) {
-                refs[nodeId] = new Reference();
-            }
-        }
-        // Convert a parsed pattern back to the symbol key the State expects.
-        const patternToKey = (parsed) => {
-            if (parsed === null) {
-                return ifOtherSymbol;
-            }
-            const flat = [];
-            for (const row of parsed) {
-                for (const cell of row) {
-                    flat.push(cell === null ? ifOtherSymbol : cell);
-                }
-            }
-            return tapeBlock.symbol(flat);
-        };
-        // Pass 2: build a "bare" State for each non-halt node (no override yet).
-        // nextState entries point at refs so cycles work; haltState is used directly.
-        const bareStates = {};
-        for (const nodeId of ids) {
-            const node = graph.nodes[nodeId];
-            if (node.isHalt) {
-                continue;
-            }
-            const stateDefinition = {};
-            for (const t of node.transitions) {
-                const key = patternToKey(parsePatternString(t.pattern, graph.alphabets));
-                const target = graph.nodes[t.nextStateId];
-                const nextState = target.isHalt ? haltState : refs[t.nextStateId];
-                stateDefinition[key] = {
-                    command: t.command.map((c) => ({
-                        symbol: parseWriteSymbolLabel(c.symbol),
-                        movement: parseMovementLabel(c.movement),
-                    })),
-                    nextState,
-                };
-            }
-            bareStates[nodeId] = new State(stateDefinition, node.name);
-        }
-        // Pass 3: apply overrideHaltStates transitively.
-        const finalStates = {};
-        const inProgress = new Set();
-        const getFinal = (nodeId) => {
-            if (finalStates[nodeId]) {
-                return finalStates[nodeId];
-            }
-            const node = graph.nodes[nodeId];
-            if (node.isHalt) {
-                finalStates[nodeId] = haltState;
-                return haltState;
-            }
-            if (inProgress.has(nodeId)) {
-                throw new Error(`override-halt cycle at state #${nodeId}`);
-            }
-            inProgress.add(nodeId);
-            let state = bareStates[nodeId];
-            if (node.overrodeHaltStateId !== null) {
-                state = bareStates[nodeId].withOverrodeHaltState(getFinal(node.overrodeHaltStateId));
-            }
-            inProgress.delete(nodeId);
-            finalStates[nodeId] = state;
-            return state;
-        };
-        for (const nodeId of ids) {
-            getFinal(nodeId);
-        }
-        // Pass 4: bind each ref to the FINAL (possibly wrapped) state so transitions
-        // resolve to the version that has its override-halt set.
-        for (const nodeId of ids) {
-            if (!graph.nodes[nodeId].isHalt) {
-                refs[nodeId].bind(finalStates[nodeId]);
-            }
-        }
-        return {
-            start: finalStates[graph.initialId],
-            tapeBlock,
-            states: finalStates,
-        };
-    }
-}
-_State_id = new WeakMap(), _State_name = new WeakMap(), _State_overrodeHaltState = new WeakMap(), _State_symbolToDataMap = new WeakMap();
-export default State;
-export const haltState = new State(null);