@turing-machine-js/machine 7.0.0-alpha.3 → 7.0.0-alpha.5

package/dist/index.cjs

@@ -175,6 +175,153 @@ class Reference {
 }
 _Reference_referenceBinding = new WeakMap();
 
+const movementDescriptionToLabel = {
+    'move caret left command': 'L',
+    'move caret right command': 'R',
+    'do not move carer': 'S',
+};
+const symbolCommandDescriptionToLabel = {
+    'keep symbol command': 'K',
+    'erase symbol command': 'E',
+};
+// Reserved characters in the encoded pattern string:
+//   '*'  ASCII asterisk (U+002A) — per-cell ifOtherSymbol, matches any symbol
+//        on that tape. ASCII (not a fancier glyph like U+1F7B0) so it renders
+//        in every Mermaid environment and every monospace font. A literal `*`
+//        in the alphabet is unambiguous from the marker because it's quoted
+//        (`'*'`).
+//   'B'  the tape's blank symbol shorthand (in read patterns). A literal `B`
+//        in the alphabet is unambiguous from the marker because it's quoted
+//        (`'B'`).
+//   ','  separates per-tape cells inside one pattern
+//   '|'  separates alternative patterns
+//   "'"  surrounds a literal alphabet symbol — e.g. `'0'` for literal `0`,
+//        `'X'` for literal `X`. The quoting is what visually separates literal
+//        symbols from the convention markers `*` / `B` and from the write
+//        commands `K` / `E`.
+//   '\\' escape prefix — to represent any of '*', 'B', ',', '|', "'", or '\\'
+//        as a *literal* alphabet symbol *inside* the quotes (e.g. `'\''` for
+//        a literal apostrophe).
+const IF_OTHER_MARKER = '*';
+const BLANK_MARKER = 'B';
+function escapeAlphabetSymbol(s) {
+    return s
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'");
+}
+function decodePatternDescription(description, alphabets) {
+    if (!description) {
+        return '?';
+    }
+    if (description === 'other symbol') {
+        return IF_OTHER_MARKER;
+    }
+    try {
+        const patternList = JSON.parse(description);
+        return patternList
+            .map((pattern) => pattern
+            .map((s, tapeIx) => {
+            if (s === null) {
+                return IF_OTHER_MARKER;
+            }
+            if (s === alphabets[tapeIx]?.[0]) {
+                return BLANK_MARKER;
+            }
+            return `'${escapeAlphabetSymbol(s)}'`;
+        })
+            .join(','))
+            .join('|');
+    }
+    catch {
+        return description;
+    }
+}
+function decodeMovement(description) {
+    if (!description) {
+        return '?';
+    }
+    return movementDescriptionToLabel[description] ?? description;
+}
+function splitUnescaped(s, sep) {
+    const parts = [];
+    let current = '';
+    let i = 0;
+    while (i < s.length) {
+        if (s[i] === '\\' && i + 1 < s.length) {
+            current += s[i + 1];
+            i += 2;
+        }
+        else if (s[i] === sep) {
+            parts.push(current);
+            current = '';
+            i += 1;
+        }
+        else {
+            current += s[i];
+            i += 1;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+function parsePatternString(s, alphabets) {
+    if (s === IF_OTHER_MARKER) {
+        return null;
+    }
+    const alternatives = splitUnescaped(s, '|');
+    return alternatives.map((alt) => {
+        const cells = splitUnescaped(alt, ',');
+        return cells.map((cell, tapeIx) => {
+            if (cell === IF_OTHER_MARKER) {
+                return null;
+            }
+            if (cell === BLANK_MARKER) {
+                return alphabets[tapeIx]?.[0] ?? cell;
+            }
+            // Literal alphabet symbols are wrapped in single quotes by
+            // `decodePatternDescription` — strip them on the way back.
+            if (cell.length >= 2 && cell.startsWith("'") && cell.endsWith("'")) {
+                return cell.slice(1, -1);
+            }
+            return cell;
+        });
+    });
+}
+const movementLabelToSymbol = {
+    L: movements.left,
+    R: movements.right,
+    S: movements.stay,
+};
+function parseMovementLabel(label) {
+    const m = movementLabelToSymbol[label];
+    if (!m) {
+        throw new Error(`unknown movement label: ${label}`);
+    }
+    return m;
+}
+function parseWriteSymbolLabel(label) {
+    if (label === 'K') {
+        return symbolCommands.keep;
+    }
+    if (label === 'E') {
+        return symbolCommands.erase;
+    }
+    // Literal alphabet symbols are wrapped in single quotes by
+    // `decodeWriteSymbol` — strip them on the way back.
+    if (label.length >= 2 && label.startsWith("'") && label.endsWith("'")) {
+        return label.slice(1, -1);
+    }
+    return label;
+}
+function decodeWriteSymbol(symbol) {
+    if (typeof symbol === 'symbol') {
+        const description = symbol.description ?? '?';
+        return symbolCommandDescriptionToLabel[description] ?? description;
+    }
+    return `'${symbol}'`;
+}
+// Format converters (toMermaid / fromMermaid) live in ./graphFormats.
+
 var __classPrivateFieldSet$4 = (undefined && undefined.__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");
@@ -508,6 +655,46 @@ class TapeBlock {
             .every((everySymbol, ix) => (everySymbol === ifOtherSymbol
             || everySymbol === currentSymbols[ix])))) ?? false;
     }
+    /**
+     * For a Symbol returned by `this.symbol([...])` (or the catch-all
+     * `ifOtherSymbol`), returns the per-tape match kind for the
+     * **alternative that actually matched** given `currentSymbols`:
+     * `'wildcard'` if that tape position was `ifOtherSymbol` in the winning
+     * alternative, `'literal'` otherwise. Length always equals the tape
+     * count.
+     *
+     * Used by `TuringMachine.runStepByStep` to populate
+     * `MachineState.matchedTransition.matchKinds` for #205. The "winning
+     * alternative" disambiguation matters for alternations like
+     * `[[ifOtherSymbol, 'c'], ['a', 'b']]` — different alternatives can
+     * have different per-tape kinds, and only the alternative that matched
+     * the current head symbols is meaningful.
+     *
+     * - `ifOtherSymbol` (the State's catch-all transition fired): all
+     *   positions are `'wildcard'`.
+     * - Symbol with patternList: find the first alternative that matches
+     *   `currentSymbols` (same predicate as `isMatched`), return its
+     *   per-position kinds.
+     * - Symbol with no winning alternative under the given `currentSymbols`
+     *   (defensive — shouldn't happen if the caller resolved the Symbol via
+     *   the State's normal matching): fall back to all `'literal'`.
+     */
+    patternKinds(symbol, currentSymbols = this.currentSymbols) {
+        const tapeCount = __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length;
+        if (symbol === ifOtherSymbol) {
+            return Array.from({ length: tapeCount }, () => 'wildcard');
+        }
+        const patternList = __classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
+        if (patternList === undefined) {
+            return Array.from({ length: tapeCount }, () => 'literal');
+        }
+        const winning = patternList.find((pattern) => (pattern.every((everySymbol, ix) => (everySymbol === ifOtherSymbol
+            || everySymbol === currentSymbols[ix]))));
+        if (winning === undefined) {
+            return Array.from({ length: tapeCount }, () => 'literal');
+        }
+        return winning.map((everySymbol) => (everySymbol === ifOtherSymbol ? 'wildcard' : 'literal'));
+    }
     replaceTape(tape, tapeIx = 0) {
         if (__classPrivateFieldGet$2(this, _TapeBlock_tapes, "f")[tapeIx] == null) {
             throw new Error('invalid tapeIx');
@@ -531,152 +718,523 @@ _TapeBlock_generateSymbolHint = { value: (patternList) => JSON.stringify(pattern
         .map((pattern) => pattern
         .map((symbol) => (symbol === ifOtherSymbol ? null : symbol)))) };
 
-const movementDescriptionToLabel = {
-    'move caret left command': 'L',
-    'move caret right command': 'R',
-    'do not move carer': 'S',
-};
-const symbolCommandDescriptionToLabel = {
-    'keep symbol command': 'K',
-    'erase symbol command': 'E',
-};
-// Reserved characters in the encoded pattern string:
-//   '*'  ASCII asterisk (U+002A) — per-cell ifOtherSymbol, matches any symbol
-//        on that tape. ASCII (not a fancier glyph like U+1F7B0) so it renders
-//        in every Mermaid environment and every monospace font. A literal `*`
-//        in the alphabet is unambiguous from the marker because it's quoted
-//        (`'*'`).
-//   'B'  the tape's blank symbol shorthand (in read patterns). A literal `B`
-//        in the alphabet is unambiguous from the marker because it's quoted
-//        (`'B'`).
-//   ','  separates per-tape cells inside one pattern
-//   '|'  separates alternative patterns
-//   "'"  surrounds a literal alphabet symbol — e.g. `'0'` for literal `0`,
-//        `'X'` for literal `X`. The quoting is what visually separates literal
-//        symbols from the convention markers `*` / `B` and from the write
-//        commands `K` / `E`.
-//   '\\' escape prefix — to represent any of '*', 'B', ',', '|', "'", or '\\'
-//        as a *literal* alphabet symbol *inside* the quotes (e.g. `'\''` for
-//        a literal apostrophe).
-const IF_OTHER_MARKER = '*';
-const BLANK_MARKER = 'B';
-function escapeAlphabetSymbol(s) {
-    return s
-        .replace(/\\/g, '\\\\')
-        .replace(/'/g, "\\'");
-}
-function decodePatternDescription(description, alphabets) {
-    if (!description) {
-        return '?';
-    }
-    if (description === 'other symbol') {
-        return IF_OTHER_MARKER;
-    }
-    try {
-        const patternList = JSON.parse(description);
-        return patternList
-            .map((pattern) => pattern
-            .map((s, tapeIx) => {
-            if (s === null) {
-                return IF_OTHER_MARKER;
+// Graph serialization/reconstruction for State graphs. Extracted from
+// `classes/State.ts` (#180) so the State class stays focused on the runtime
+// machinery (transitions, debug, halt-stack composition). Sibling-module
+// private access to State's internals goes through the `STATE_INTERNAL`
+// Symbol re-exported from State.ts — see the @internal JSDoc there.
+//
+// Public surface is preserved: `State.toGraph` and `State.fromGraph` static
+// methods continue to exist as thin delegates to the functions in this
+// module. New consumers (e.g. #195's planned `collectStates`) will live
+// here too and share the BFS-walk shape with `toGraph`.
+/**
+ * Walks the reachable graph from `initialState` and returns a serializable
+ * `Graph`. The walk is a BFS that visits each State exactly once (keyed by
+ * the State's internal id) and emits one `GraphNode` per State plus
+ * synthetic halt-marker nodes per callable-subtree frame.
+ *
+ * Round-trips losslessly with `fromGraph` in the sense that running the
+ * rebuilt machine on the same input produces the same output — but State
+ * instance identities are NOT preserved across the cycle.
+ *
+ * See `classes/State.ts` for the runtime model these graph nodes describe;
+ * see `utilities/graphFormats.ts` for the Mermaid-flavored serialization
+ * built on top of `Graph`.
+ */
+function toGraph(initialState, tapeBlock) {
+    const nodes = {};
+    const alphabets = tapeBlock.alphabets.map((alphabet) => alphabet.symbols);
+    // Pass 1: BFS-discover all reachable States; emit one GraphNode per State
+    // (wrapper or bare/regular). Wrappers and bares are separate nodes.
+    const visited = new Set();
+    const queue = [initialState];
+    const bareIds = new Set(); // ids referenced as a wrapper's bareStateId
+    while (queue.length > 0) {
+        const state = queue.shift();
+        const stateInternal = state[STATE_INTERNAL]();
+        if (visited.has(stateInternal.id)) {
+            continue;
+        }
+        visited.add(stateInternal.id);
+        if (state.isHalt) {
+            if (!(0 in nodes)) {
+                nodes[0] = {
+                    id: 0,
+                    name: stateInternal.name,
+                    isHalt: true,
+                    isHaltMarker: false,
+                    isWrapper: false,
+                    bareStateId: null,
+                    frameId: null,
+                    transitions: [],
+                    overriddenHaltStateId: null,
+                    tags: [...stateInternal.tags],
+                };
             }
-            if (s === alphabets[tapeIx]?.[0]) {
-                return BLANK_MARKER;
+            continue;
+        }
+        // Wrapper? Emit wrapper node + queue bare and override target.
+        if (stateInternal.overriddenHaltState !== null && stateInternal.bareState !== null) {
+            const bareState = stateInternal.bareState;
+            const overrideTarget = stateInternal.overriddenHaltState;
+            const bareInternal = bareState[STATE_INTERNAL]();
+            const overrideInternal = overrideTarget[STATE_INTERNAL]();
+            nodes[stateInternal.id] = {
+                id: stateInternal.id,
+                name: stateInternal.name, // composite name like "A(target)"
+                isHalt: false,
+                isHaltMarker: false,
+                isWrapper: true,
+                bareStateId: bareInternal.id,
+                frameId: null,
+                transitions: [],
+                overriddenHaltStateId: overrideInternal.id,
+                tags: [...stateInternal.tags],
+            };
+            bareIds.add(bareInternal.id);
+            queue.push(bareState);
+            queue.push(overrideTarget);
+            continue;
+        }
+        // Regular (or bare) state — build node with transitions.
+        const node = {
+            id: stateInternal.id,
+            name: stateInternal.name,
+            isHalt: false,
+            isHaltMarker: false,
+            isWrapper: false,
+            bareStateId: null,
+            frameId: null,
+            transitions: [],
+            overriddenHaltStateId: null,
+            tags: [...stateInternal.tags],
+        };
+        nodes[stateInternal.id] = node;
+        let patternIx = 0;
+        for (const [sym, { command, nextState }] of stateInternal.symbolToDataMap) {
+            let target;
+            try {
+                target = nextState instanceof State ? nextState : nextState.ref;
             }
-            return `'${escapeAlphabetSymbol(s)}'`;
-        })
-            .join(','))
-            .join('|');
+            catch {
+                patternIx += 1;
+                continue;
+            }
+            const targetInternal = target[STATE_INTERNAL]();
+            node.transitions.push({
+                pattern: decodePatternDescription(sym.description, alphabets),
+                command: command.tapesCommands.map((tc) => ({
+                    symbol: decodeWriteSymbol(tc.symbol),
+                    movement: decodeMovement(tc.movement.description),
+                })),
+                nextStateId: targetInternal.id,
+                // Transition id format: `${stateId}.${transitionIx}` (#205).
+                // Matches `TuringMachine.runStepByStep`'s `MachineState.
+                // matchedTransition.id` so consumers can do
+                // `graph.nodes[stateId].transitions.find(t => t.id === id)`.
+                // Was `${stateId}-${ix}` pre-#205 — the `.` separator avoids
+                // the hyphen reading as a minus sign next to negative halt-
+                // marker ids in adjacent contexts.
+                id: `${stateInternal.id}.${patternIx}`,
+            });
+            queue.push(target);
+            patternIx += 1;
+        }
+    }
+    // Always emit real halt as a sentinel, even if no transition targets it.
+    // It anchors the `subtree -. halt .-> s0` frame-level arrow whenever a
+    // frame demand-emits one, and it's the canonical machine-halt singleton.
+    if (!(0 in nodes)) {
+        nodes[0] = {
+            id: 0,
+            name: 'halt',
+            isHalt: true,
+            isHaltMarker: false,
+            isWrapper: false,
+            bareStateId: null,
+            frameId: null,
+            transitions: [],
+            overriddenHaltStateId: null,
+            tags: [...haltState[STATE_INTERNAL]().tags],
+        };
     }
-    catch {
-        return description;
+    // Pass 2: For each bare, compute its forward-reachable set (following
+    // transitions; stopping at halt and at wrappers — both are frame
+    // boundaries).
+    const computeReach = (startId) => {
+        const reach = new Set();
+        const stack = [startId];
+        while (stack.length > 0) {
+            const id = stack.pop();
+            if (reach.has(id)) {
+                continue;
+            }
+            const node = nodes[id];
+            // `nodes[id]` is always populated for `id` that the BFS reached, so
+            // a defensive `!node` check would be dead. `isHalt` / `isWrapper`
+            // are real boundaries — both stop reach-set expansion.
+            /* c8 ignore next 3 — defensive: the push site below already filters
+               halt/wrapper targets, and the initial push is always a bare, so
+               this branch is unreachable in practice. */
+            if (node.isHalt || node.isWrapper) {
+                continue;
+            }
+            reach.add(id);
+            for (const t of node.transitions) {
+                const target = nodes[t.nextStateId];
+                if (!target || target.isHalt || target.isWrapper) {
+                    continue;
+                }
+                stack.push(t.nextStateId);
+            }
+        }
+        return reach;
+    };
+    const reachByBare = new Map();
+    for (const bareId of bareIds) {
+        reachByBare.set(bareId, computeReach(bareId));
+    }
+    // Pass 3: Union-find on bare overlaps. Two bares merge if their reach
+    // sets share any state. Canonical representative = smallest bare-id in
+    // the component.
+    const ufParent = new Map();
+    // Note: no path compression. The union policy below ("smaller id always
+    // becomes root") keeps the tree flat — every union targets bares[0] as
+    // the root, so any node's parent IS the root. Walking up never exceeds
+    // one step. Path compression would be dead code under this invariant.
+    const ufFind = (id) => {
+        if (!ufParent.has(id)) {
+            ufParent.set(id, id);
+        }
+        let root = id;
+        while (ufParent.get(root) !== root) {
+            root = ufParent.get(root);
+        }
+        return root;
+    };
+    const ufUnion = (a, b) => {
+        const ra = ufFind(a);
+        const rb = ufFind(b);
+        if (ra === rb)
+            return;
+        if (ra < rb) {
+            ufParent.set(rb, ra);
+        }
+        else {
+            ufParent.set(ra, rb);
+        }
+    };
+    for (const bareId of bareIds) {
+        ufFind(bareId);
+    }
+    // For each state, collect the bares that reach it; union all bares that
+    // share a state.
+    const stateToReachingBares = new Map();
+    for (const [bareId, reachSet] of reachByBare) {
+        for (const stateId of reachSet) {
+            let bares = stateToReachingBares.get(stateId);
+            if (!bares) {
+                bares = [];
+                stateToReachingBares.set(stateId, bares);
+            }
+            bares.push(bareId);
+        }
+    }
+    for (const bares of stateToReachingBares.values()) {
+        for (let i = 1; i < bares.length; i += 1) {
+            ufUnion(bares[0], bares[i]);
+        }
+    }
+    // Assign frameId to each in-reach state.
+    const frameIds = new Set();
+    for (const [stateId, bares] of stateToReachingBares) {
+        const frameId = ufFind(bares[0]);
+        nodes[stateId].frameId = frameId;
+        frameIds.add(frameId);
+    }
+    // Pass 4: Retarget halt-bound transitions for in-frame states to the
+    // frame's halt marker. Out-of-frame states (top-level dispatcher, override
+    // targets, etc.) keep their halt-bound transitions pointing at real halt.
+    for (const node of Object.values(nodes)) {
+        if (node.frameId === null) {
+            continue;
+        }
+        const haltMarkerId = -node.frameId;
+        for (const t of node.transitions) {
+            const target = nodes[t.nextStateId];
+            if (target && target.isHalt && !target.isHaltMarker) {
+                t.nextStateId = haltMarkerId;
+            }
+        }
     }
-}
-function decodeMovement(description) {
-    if (!description) {
-        return '?';
+    // Pass 5: Emit one halt marker per frame.
+    for (const frameId of frameIds) {
+        const haltMarkerId = -frameId;
+        nodes[haltMarkerId] = {
+            id: haltMarkerId,
+            name: 'halt',
+            isHalt: true,
+            isHaltMarker: true,
+            isWrapper: false,
+            bareStateId: null,
+            frameId,
+            transitions: [],
+            overriddenHaltStateId: null,
+            tags: [],
+        };
     }
-    return movementDescriptionToLabel[description] ?? description;
+    return { initialId: initialState[STATE_INTERNAL]().id, alphabets, nodes };
 }
-function splitUnescaped(s, sep) {
-    const parts = [];
-    let current = '';
-    let i = 0;
-    while (i < s.length) {
-        if (s[i] === '\\' && i + 1 < s.length) {
-            current += s[i + 1];
-            i += 2;
+/**
+ * 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.
+ *
+ * Under the v7 callable-subtree model (#174), graph nodes split into:
+ *   - Wrapper nodes (`isWrapper: true`, no transitions) — reconstructed via
+ *     `bareStates[bareStateId].withOverriddenHaltState(finalStates[overriddenHaltStateId])`.
+ *   - Bare/regular nodes — constructed as normal States with transitions.
+ *   - Halt + halt-marker nodes — collapse to the singleton `haltState`.
+ */
+function 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 non-halt-marker node
+    // (both wrappers and regulars). Halt and halt-marker nodes collapse to the
+    // singleton `haltState` and need no ref.
+    const refs = {};
+    for (const nodeId of ids) {
+        const node = graph.nodes[nodeId];
+        if (!node.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 State for each non-wrapper non-halt non-halt-marker
+    // node. Transitions point at refs so cycles work; haltState (and halt
+    // markers, which collapse to haltState) are used directly.
+    const bareStates = {};
+    for (const nodeId of ids) {
+        const node = graph.nodes[nodeId];
+        if (node.isHalt || node.isWrapper) {
+            continue;
         }
-        else if (s[i] === sep) {
-            parts.push(current);
-            current = '';
-            i += 1;
+        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 || target.isHalt
+                ? haltState
+                : refs[t.nextStateId];
+            stateDefinition[key] = {
+                command: t.command.map((c) => ({
+                    symbol: parseWriteSymbolLabel(c.symbol),
+                    movement: parseMovementLabel(c.movement),
+                })),
+                nextState,
+            };
+        }
+        // Graph-sourced names may contain `(` and `)` (composite wrapper names —
+        // although wrappers go through a separate path below, defensive
+        // construction here keeps the bypass uniform). Construct without a name
+        // and assign `name` directly through the internal accessor's setter to
+        // skip the constructor's user-facing name validation.
+        const bare = new State(stateDefinition);
+        bare[STATE_INTERNAL]().name = node.name;
+        if (node.tags.length > 0) {
+            bare.tag(...node.tags);
+        }
+        bareStates[nodeId] = bare;
+    }
+    // Pass 3: resolve every node to its final State (memoized + cycle-safe).
+    // Wrappers compose lazily via `withOverriddenHaltState` once their bare
+    // and override are resolved.
+    const finalStates = {};
+    const inProgress = new Set();
+    const getFinal = (nodeId) => {
+        if (finalStates[nodeId]) {
+            return finalStates[nodeId];
+        }
+        const node = graph.nodes[nodeId];
+        if (!node || 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;
+        if (node.isWrapper) {
+            const bare = getFinal(node.bareStateId);
+            const override = getFinal(node.overriddenHaltStateId);
+            state = bare.withOverriddenHaltState(override);
+            // Apply wrapper-scoped tags (#186). Tags don't leak across wrappers
+            // sharing a bare — the wrapper instance owns its own tag set, and
+            // engine #175 memoization returns the same instance for the same
+            // (bare, override) pair, so this is idempotent across rebuilds.
+            if (node.tags.length > 0) {
+                state.tag(...node.tags);
+            }
         }
         else {
-            current += s[i];
-            i += 1;
+            state = bareStates[nodeId];
         }
+        inProgress.delete(nodeId);
+        finalStates[nodeId] = state;
+        return state;
+    };
+    for (const nodeId of ids) {
+        getFinal(nodeId);
     }
-    parts.push(current);
-    return parts;
-}
-function parsePatternString(s, alphabets) {
-    if (s === IF_OTHER_MARKER) {
-        return null;
+    // Pass 4: bind each ref to the resolved final State so cross-node
+    // transitions land on the right instance.
+    for (const nodeId of ids) {
+        if (!graph.nodes[nodeId].isHalt) {
+            refs[nodeId].bind(finalStates[nodeId]);
+        }
     }
-    const alternatives = splitUnescaped(s, '|');
-    return alternatives.map((alt) => {
-        const cells = splitUnescaped(alt, ',');
-        return cells.map((cell, tapeIx) => {
-            if (cell === IF_OTHER_MARKER) {
-                return null;
-            }
-            if (cell === BLANK_MARKER) {
-                return alphabets[tapeIx]?.[0] ?? cell;
+    return {
+        start: finalStates[graph.initialId],
+        tapeBlock,
+        states: finalStates,
+    };
+}
+/**
+ * Returns a `Map<number, {state, transitionSymbols}>` keyed by engine
+ * `GraphNode.id`, giving downstream tooling direct access to the `State`
+ * instance + per-pattern Symbol references for breakpoint setup (#195).
+ *
+ * **Positional alignment contract.** For any `GraphTransition` whose id
+ * is `${N}.${K}` (#205 changed the separator from `-` to `.`),
+ * `result.get(N)!.transitionSymbols[K]` is the Symbol
+ * the transition fires on (reference equality, not structural). The K-th
+ * entry is the K-th key from the source State's `#symbolToDataMap` in
+ * insertion order, including `ifOtherSymbol` when the user wrote one.
+ * Consumers filtering the catch-all path identity-compare against the
+ * engine-exported `ifOtherSymbol`.
+ *
+ * **Unbound-`Reference` slots.** `toGraph` increments `patternIx` even
+ * when a transition's `nextState` is an unresolved `Reference` (it
+ * `continue`s without pushing the GraphTransition). In that case
+ * `transitionSymbols[K]` is still set to the K-th Map key, but no
+ * `Graph.nodes[N].transitions` entry exists with id `${N}.${K}`. Sparse
+ * on the Graph side, dense on the `transitionSymbols` side — same
+ * indexing.
+ *
+ * **Coverage.** Map keys are the State-backed subset of `graph.nodes`:
+ * regulars + bares + wrappers + the halt singleton (id `0`). Synthetic
+ * halt markers (id `-frameId`) are excluded — they all reach the same
+ * `haltState` object at runtime, and the named consumer
+ * ([machines-demo#37](https://github.com/mellonis/machines-demo/issues/37))
+ * surfaces halt-pause via a separate UI control, not via clicks on
+ * halt glyphs. If a future consumer needs uniform-by-id lookup, the
+ * helper can be extended additively.
+ *
+ * **Halt-singleton warning.** `result.get(0)!.state === haltState` — the
+ * process-wide halt. Toggling `.debug` on that entry affects every
+ * machine in the runtime, not just the one this map was built from.
+ */
+function collectStates(initialState, tapeBlock) {
+    // Anchor on toGraph's authoritative id set — it knows the canonical
+    // ordering of wrapper/bare/regular emission and which nodes are
+    // synthetic halt markers we have to skip. Building our own BFS would
+    // duplicate that logic; reusing the Graph guarantees collectStates'
+    // id keys never drift from toGraph's GraphTransition ids.
+    const graph = toGraph(initialState, tapeBlock);
+    // Walk the State graph to associate each State instance with its
+    // engine id. The shape mirrors toGraph's Pass 1 — visit by id, branch
+    // on halt / wrapper / regular — but only collects the (id → State)
+    // mapping. Lighter than re-running the union-find passes; no
+    // GraphNode construction.
+    const stateById = new Map();
+    const visited = new Set();
+    const queue = [initialState];
+    while (queue.length > 0) {
+        const state = queue.shift();
+        const internal = state[STATE_INTERNAL]();
+        if (visited.has(internal.id))
+            continue;
+        visited.add(internal.id);
+        stateById.set(internal.id, state);
+        if (state.isHalt)
+            continue;
+        if (internal.bareState !== null && internal.overriddenHaltState !== null) {
+            queue.push(internal.bareState);
+            queue.push(internal.overriddenHaltState);
+            continue;
+        }
+        for (const { nextState } of internal.symbolToDataMap.values()) {
+            let target;
+            try {
+                target = nextState instanceof State ? nextState : nextState.ref;
             }
-            // Literal alphabet symbols are wrapped in single quotes by
-            // `decodePatternDescription` — strip them on the way back.
-            if (cell.length >= 2 && cell.startsWith("'") && cell.endsWith("'")) {
-                return cell.slice(1, -1);
+            catch {
+                continue; // unbound Reference — skip silently, matches toGraph
             }
-            return cell;
-        });
-    });
-}
-const movementLabelToSymbol = {
-    L: movements.left,
-    R: movements.right,
-    S: movements.stay,
-};
-function parseMovementLabel(label) {
-    const m = movementLabelToSymbol[label];
-    if (!m) {
-        throw new Error(`unknown movement label: ${label}`);
-    }
-    return m;
-}
-function parseWriteSymbolLabel(label) {
-    if (label === 'K') {
-        return symbolCommands.keep;
-    }
-    if (label === 'E') {
-        return symbolCommands.erase;
-    }
-    // Literal alphabet symbols are wrapped in single quotes by
-    // `decodeWriteSymbol` — strip them on the way back.
-    if (label.length >= 2 && label.startsWith("'") && label.endsWith("'")) {
-        return label.slice(1, -1);
+            queue.push(target);
+        }
     }
-    return label;
-}
-function decodeWriteSymbol(symbol) {
-    if (typeof symbol === 'symbol') {
-        const description = symbol.description ?? '?';
-        return symbolCommandDescriptionToLabel[description] ?? description;
+    // Build the result by iterating graph.nodes — the authoritative id set
+    // minus halt markers — and dispatching on node kind. The halt singleton
+    // entry's `state` reads from `stateById` (the BFS visited haltState if
+    // any path reached it) but falls back to the module-level singleton
+    // for graphs whose only halt presence is the always-emitted sentinel.
+    const result = new Map();
+    for (const idStr of Object.keys(graph.nodes)) {
+        const id = Number(idStr);
+        const node = graph.nodes[id];
+        if (node.isHaltMarker)
+            continue; // synthetic; collapses to haltState at id 0
+        if (node.isHalt) {
+            // The real halt — always the engine-wide singleton. Prefer the
+            // BFS-visited instance for identity-equality with whatever the
+            // caller has; fall back to the module singleton when the BFS
+            // didn't reach haltState (toGraph emits id 0 unconditionally).
+            result.set(id, {
+                state: stateById.get(0) ?? haltState,
+                transitionSymbols: [],
+            });
+            continue;
+        }
+        if (node.isWrapper) {
+            result.set(id, {
+                state: stateById.get(id),
+                transitionSymbols: [],
+            });
+            continue;
+        }
+        // Regular or bare State — enumerate `#symbolToDataMap.keys()` for
+        // the patternIx alignment. The K-th key is the Symbol that
+        // `${id}.${K}` GraphTransition fires on (positional contract).
+        const state = stateById.get(id);
+        const transitionSymbols = [...state[STATE_INTERNAL]().symbolToDataMap.keys()];
+        result.set(id, { state, transitionSymbols });
     }
-    return `'${symbol}'`;
+    return result;
 }
-// Format converters (toMermaid / fromMermaid) live in ./graphFormats.
+// Note on the import cycle with `State.ts`: stateGraph.ts value-imports
+// `State`, `STATE_INTERNAL`, `haltState`, and `ifOtherSymbol`; State.ts
+// value-imports `toGraph` and `fromGraph` for its static-method delegates.
+// ESM resolves cycles via live bindings — both modules see each other's
+// exports as long as nothing at module-load reads a binding before its
+// source module finishes evaluating. All references here live inside
+// function bodies, so the cycle is safe.
 
 var __classPrivateFieldSet$1 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
@@ -689,11 +1247,33 @@ var __classPrivateFieldGet$1 = (undefined && undefined.__classPrivateFieldGet) |
     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 _DebugConfig_ownerState, _DebugConfig_before, _DebugConfig_after, _a, _State_wrapperCache, _State_id, _State_name, _State_overriddenHaltState, _State_bareState, _State_symbolToDataMap, _State_debugRef, _State_tags;
+var _DebugConfig_ownerState, _DebugConfig_before, _DebugConfig_after, _State_instances, _a, _State_wrapperCache, _State_id, _State_name, _State_overriddenHaltState, _State_bareState, _State_symbolToDataMap, _State_debugRef, _State_haltDebug, _State_tags, _State_getEntry;
 const ifOtherSymbol = Symbol('other symbol');
 // Module-private symbol used by DebugConfig setters to call State's validator
 // without exposing the validator on the public surface.
 const validateDebugFilter = Symbol('validateDebugFilter');
+/**
+ * @internal
+ *
+ * Package-private accessor key for sibling modules in
+ * `packages/machine/src` (e.g. `utilities/stateGraph.ts`, and the planned
+ * `utilities/stateCollect.ts` for #195). Re-exported from this module so
+ * sibling files can import it; intentionally NOT re-exported from the
+ * package's public `index.ts`, so downstream consumers don't see it on
+ * the supported surface.
+ *
+ * Calling `state[STATE_INTERNAL]()` returns a getter/setter view onto the
+ * State's private fields. Reads are live (they close over `this`), so the
+ * view stays in sync with subsequent mutations on the State. There's one
+ * mutating setter on the view — `name` — used exclusively by
+ * `fromGraph` to assign graph-sourced composite names (e.g. `A(target)`)
+ * that the public name validator would reject; see the JSDoc on the
+ * accessor itself.
+ *
+ * Designed in #180 with #195 in mind so its surface doesn't need to grow
+ * when `collectStates` lands.
+ */
+const STATE_INTERNAL = Symbol('State.internal');
 class DebugConfig {
     constructor(ownerState, initial) {
         _DebugConfig_ownerState.set(this, void 0);
@@ -733,6 +1313,7 @@ class DebugConfig {
 _DebugConfig_ownerState = new WeakMap(), _DebugConfig_before = new WeakMap(), _DebugConfig_after = new WeakMap();
 class State {
     constructor(stateDefinition = null, name) {
+        _State_instances.add(this);
         _State_id.set(this, id(this));
         // Not `readonly` because `withOverriddenHaltState` and `fromGraph` set the
         // composed name on a no-arg `new State()` to bypass the constructor's
@@ -750,6 +1331,14 @@ class State {
         // Note: toGraph / fromGraph deliberately do not serialize debug — debug is
         // a runtime concern, not part of the structural graph.
         _State_debugRef.set(this, { current: null });
+        // Storage for `haltState.debug` (#207). haltState is a singleton terminal
+        // state — it has no iter of its own, so the per-side `{ before, after }`
+        // DebugConfig shape doesn't model anything meaningful for it. Instead the
+        // halt breakpoint is a single boolean ("enabled / disabled"). The pause
+        // anchors on the iter whose transition LEADS to halt, fired at end-of-iter
+        // (after that iter's own after-pause if armed). Only used when `isHalt`;
+        // ignored on every other State (whose `#debugRef` flow is unchanged).
+        _State_haltDebug.set(this, false);
         // Out-of-band tags applied to this State (#186). Tags are visualization
         // and debugger-tooling metadata — they don't affect runtime transition
         // lookup or `equivalentOn` comparisons. Stored as a Set for de-duplication;
@@ -820,6 +1409,17 @@ class State {
         return this;
     }
     get debug() {
+        // haltState (#207): the canonical access path is the `haltState` singleton
+        // export, which is typed `HaltState` — its `debug` getter is narrowed to
+        // `boolean`. Generic `State` references statically see `DebugConfig` and
+        // (in practice) never refer to haltState — the run loop's `state` is
+        // never haltState because halt is terminal and doesn't iterate. The cast
+        // below makes the runtime boolean return type-compatible with the
+        // declared `DebugConfig` for any rare caller that holds a State
+        // reference happening to be haltState.
+        if (this.isHalt) {
+            return __classPrivateFieldGet$1(this, _State_haltDebug, "f");
+        }
         // Lazy-init: `state.debug` is never null at read time, so chained writes
         // like `state.debug.before = true` work on a fresh state without a prior
         // whole-object assignment. The setter still accepts `null` to reset the
@@ -830,16 +1430,47 @@ class State {
         }
         return __classPrivateFieldGet$1(this, _State_debugRef, "f").current;
     }
+    // TS signature: non-halt callers (generic `State` reference) get the
+    // `DebugConfig | object | null` surface; boolean is rejected statically.
+    // The `HaltState` typed alias on the singleton export overrides this to
+    // `boolean | null` for the canonical halt access path. Runtime checks
+    // below are defensive against type-bypass / mixed-source callers.
     set debug(value) {
-        if (value === null) {
+        // Defensive runtime cast: TS signature excludes boolean for the generic
+        // State surface, but haltState (via the HaltState alias) DOES accept
+        // boolean, and the runtime needs to handle it for the singleton path.
+        const v = value;
+        // haltState (#207): only `boolean | null` is accepted. `null` aliases
+        // to `false` (reset). Any object-shaped write throws at write-time so
+        // misuse surfaces immediately rather than silently no-op'ing — the
+        // `{before, after}` shape doesn't model anything meaningful for halt
+        // (no own iter to anchor on; halt is terminal).
+        if (this.isHalt) {
+            if (v === null || typeof v === 'boolean') {
+                __classPrivateFieldSet$1(this, _State_haltDebug, v === true, "f");
+                return;
+            }
+            throw new Error('haltState.debug only accepts boolean (or null to reset). Use '
+                + '`haltState.debug = true` to enable the halt breakpoint, false to '
+                + 'disable. The pause fires after the iter whose transition leads to '
+                + 'halt (post-iter, before halt processing).');
+        }
+        // Non-halt states: boolean writes are rejected — the per-side
+        // `{before, after}` granularity is the contract. A boolean shortcut
+        // would hide the asymmetry between before / after.
+        if (typeof v === 'boolean') {
+            throw new Error('state.debug only accepts a DebugConfig or `{ before, after }` object '
+                + '(or null to reset). Boolean assignment is reserved for `haltState`.');
+        }
+        if (v === null) {
             __classPrivateFieldGet$1(this, _State_debugRef, "f").current = null;
             return;
         }
-        if (value instanceof DebugConfig) {
-            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = value;
+        if (v instanceof DebugConfig) {
+            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = v;
             return;
         }
-        __classPrivateFieldGet$1(this, _State_debugRef, "f").current = new DebugConfig(this, value);
+        __classPrivateFieldGet$1(this, _State_debugRef, "f").current = new DebugConfig(this, v);
     }
     /**
      * Add one or more tags to this State (#186). Tags are out-of-band metadata
@@ -871,25 +1502,15 @@ class State {
     get tags() {
         return Object.freeze([...__classPrivateFieldGet$1(this, _State_tags, "f")]);
     }
-    /** @internal — invoked by DebugConfig setters via module-private symbol. */
-    [(_State_id = new WeakMap(), _State_name = new WeakMap(), _State_overriddenHaltState = new WeakMap(), _State_bareState = new WeakMap(), _State_symbolToDataMap = new WeakMap(), _State_debugRef = new WeakMap(), _State_tags = new WeakMap(), validateDebugFilter)](fieldName, filter) {
+    /** @internal — invoked by DebugConfig setters via module-private symbol.
+     *  Per #207, haltState no longer flows through DebugConfig (its `debug`
+     *  setter rejects object writes before construction), so the validator
+     *  only sees non-halt states here. */
+    [(_State_id = new WeakMap(), _State_name = new WeakMap(), _State_overriddenHaltState = new WeakMap(), _State_bareState = new WeakMap(), _State_symbolToDataMap = new WeakMap(), _State_debugRef = new WeakMap(), _State_haltDebug = new WeakMap(), _State_tags = new WeakMap(), _State_instances = new WeakSet(), validateDebugFilter)](fieldName, filter) {
         if (filter === undefined)
             return;
-        // #108 part 2: `.after` on haltState has no semantic anchor — halt is
-        // terminal, so there is no iteration-after-halt for an after-fire to
-        // attach to. Reject any truthy assignment (true OR list) at write time
-        // so misuse surfaces immediately rather than silently no-op'ing.
-        if (this.isHalt && fieldName === 'after') {
-            throw new Error('haltState.debug.after is not supported: halt is terminal, so there is '
-                + 'no iteration-after-halt for an after-fire to anchor on. Use '
-                + '{ before: true } to pause on halt entry.');
-        }
         if (filter === true)
             return;
-        // haltState has no own transitions; symbol-list filters on `before` are
-        // silent no-ops at the engine level (spec §8.6), so accept any list shape.
-        if (this.isHalt)
-            return;
         for (const sym of filter) {
             if (sym !== ifOtherSymbol && !__classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").has(sym)) {
                 throw new Error(`State.debug.${fieldName}: symbol is not a transition key of this state `
@@ -908,16 +1529,40 @@ class State {
         return ifOtherSymbol;
     }
     getCommand(symbol) {
-        if (__classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").has(symbol)) {
-            return __classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").get(symbol).command;
-        }
-        throw new Error(`No command for symbol at state named ${__classPrivateFieldGet$1(this, _State_name, "f")}`);
+        return __classPrivateFieldGet$1(this, _State_instances, "m", _State_getEntry).call(this, symbol).command;
     }
     getNextState(symbol) {
-        if (__classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").has(symbol)) {
-            return __classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").get(symbol).nextState;
-        }
-        throw new Error(`No nextState for symbol at state named ${__classPrivateFieldGet$1(this, _State_id, "f")}`);
+        return __classPrivateFieldGet$1(this, _State_instances, "m", _State_getEntry).call(this, symbol).nextState;
+    }
+    /**
+     * Like `getNextState`, but also returns the matched Symbol and its index
+     * in this State's transition declaration order (= the `K` in `toGraph`'s
+     * `${stateId}.${K}` transition ids). Used by `TuringMachine.runStepByStep`
+     * to populate `MachineState.matchedTransition` for #205 — exposes which
+     * transition fired so consumers (UIs, log tools, coverage maps) can
+     * resolve the firing edge without re-deriving from `(source, nextState)`,
+     * which is ambiguous when multiple transitions on the same source go to
+     * the same destination.
+     *
+     * Throws (matching `getNextState` / `getCommand`) when no entry exists for
+     * the symbol. For wrappers (states produced by `withOverriddenHaltState`):
+     * the symbol-to-data map is shared with the bare via `bareState`, so the
+     * returned `ix` is a valid position into BOTH the wrapper's and the
+     * bare's transition iteration order — they're the same map.
+     */
+    getMatchedTransition(symbol) {
+        const entry = __classPrivateFieldGet$1(this, _State_instances, "m", _State_getEntry).call(this, symbol);
+        // Iteration order on a Map is insertion order; index lookup is O(N),
+        // acceptable since this fires at most once per iter and N (transitions
+        // per state) is typically tiny. If hot-path measurement ever flags it,
+        // cache as `#symbolToIxMap` mirror.
+        let ix = 0;
+        for (const key of __classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").keys()) {
+            if (key === symbol)
+                break;
+            ix += 1;
+        }
+        return { nextState: entry.nextState, matchedSymbol: symbol, ix };
     }
     withOverriddenHaltState(overriddenHaltState) {
         // Unwrap `this` if it's itself a wrapper — the chain's inner overrides
@@ -956,6 +1601,53 @@ class State {
         innerCache.set(overriddenHaltState, new WeakRef(state));
         return state;
     }
+    /**
+     * @internal
+     *
+     * Package-private getter/setter view onto this State's private fields,
+     * for sibling modules in `packages/machine/src` (currently `stateGraph.ts`
+     * for `toGraph` / `fromGraph`, and the planned `stateCollect.ts` for
+     * #195's `collectStates`).
+     *
+     * Read access is live — the getters close over `this`, so the view
+     * stays in sync with subsequent mutations on this State. There's a
+     * single mutating setter on the view, `name`, which exists to let
+     * `fromGraph` assign graph-sourced composite names (e.g. `A(target)`)
+     * to freshly-constructed bare States. The constructor's name validator
+     * rejects parens (reserved as wrapper-composition delimiters in
+     * `withOverriddenHaltState`); the setter intentionally bypasses that
+     * check because the same delimiters appear in legitimate wrapper-bare
+     * names round-tripped through the graph.
+     *
+     * Returns a fresh view object on every call — cheap enough for the
+     * BFS-once-per-build callers, and avoids holding a reference object on
+     * every State instance. Keep this surface tight: callers should only
+     * read what they need. Adding fields here is a deliberate decision —
+     * each adds to the implicit contract sibling modules can rely on.
+     */
+    [(_State_getEntry = function _State_getEntry(symbol) {
+        const entry = __classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").get(symbol);
+        if (entry === undefined) {
+            throw new Error(`No transition for symbol at state named ${__classPrivateFieldGet$1(this, _State_name, "f")}`);
+        }
+        return entry;
+    }, STATE_INTERNAL)]() {
+        // Aliasing `this` so the nested object-literal getters/setters below
+        // can read/write the enclosing State's private fields — getters in an
+        // object literal can't be arrow functions, so the standard arrow-
+        // captures-`this` trick doesn't apply here.
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return {
+            get id() { return __classPrivateFieldGet$1(self, _State_id, "f"); },
+            get name() { return __classPrivateFieldGet$1(self, _State_name, "f"); },
+            set name(v) { __classPrivateFieldSet$1(self, _State_name, v, "f"); },
+            get bareState() { return __classPrivateFieldGet$1(self, _State_bareState, "f"); },
+            get overriddenHaltState() { return __classPrivateFieldGet$1(self, _State_overriddenHaltState, "f"); },
+            get symbolToDataMap() { return __classPrivateFieldGet$1(self, _State_symbolToDataMap, "f"); },
+            get tags() { return __classPrivateFieldGet$1(self, _State_tags, "f"); },
+        };
+    }
     // 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.
@@ -990,382 +1682,36 @@ class State {
             transitions,
         };
     }
-    // Walks the State graph and emits a `Graph` data structure. v7 callable-
-    // subtree emit shape (#174):
-    //
-    // Each `withOverriddenHaltState` wrapper produces TWO graph nodes:
-    //   - A wrapper node (`isWrapper: true`, `[[composite-name]]` shape) — the
-    //     call site. No transitions of its own. `bareStateId` points to the
-    //     bare's GraphNode; `overriddenHaltStateId` points to the override
-    //     target's GraphNode.
-    //   - A bare node (`isWrapper: false`, regular shape) — the callable body.
-    //     Has the bare's transitions. Shared across all wrappers that wrap
-    //     this bare (no per-context duplication).
-    //
-    // Frames are computed via union-find on bare reachability: two bares whose
-    // forward-reachable sets overlap merge into one frame. Each frame contains
-    // its bares + body states + a single halt marker (id = `-frameId`). The
-    // canonical `frameId` is the smallest bare-id in the component.
-    //
-    // Halt-bound transitions of any in-frame state are retargeted to the
-    // frame's halt marker. The frame's `subtree -. return .-> wrapper` and
-    // `subtree -. halt .-> s0` arrows are demand-emitted by `toMermaid` from
-    // the frame structure; they're not stored as graph edges.
+    /**
+     * Walks the reachable State graph from `initialState` and returns a
+     * serializable `Graph`. Thin delegate to `utilities/stateGraph.ts`'s
+     * `toGraph` (extracted in #180); see that module for the BFS shape and
+     * v7 callable-subtree emit semantics.
+     */
     static toGraph(initialState, tapeBlock) {
-        const nodes = {};
-        const alphabets = tapeBlock.alphabets.map((alphabet) => alphabet.symbols);
-        // Pass 1: BFS-discover all reachable States; emit one GraphNode per State
-        // (wrapper or bare/regular). Wrappers and bares are separate nodes.
-        const visited = new Set();
-        const queue = [initialState];
-        const bareIds = new Set(); // ids referenced as a wrapper's bareStateId
-        while (queue.length > 0) {
-            const state = queue.shift();
-            if (visited.has(__classPrivateFieldGet$1(state, _State_id, "f"))) {
-                continue;
-            }
-            visited.add(__classPrivateFieldGet$1(state, _State_id, "f"));
-            if (state.isHalt) {
-                if (!(0 in nodes)) {
-                    nodes[0] = {
-                        id: 0,
-                        name: __classPrivateFieldGet$1(state, _State_name, "f"),
-                        isHalt: true,
-                        isHaltMarker: false,
-                        isWrapper: false,
-                        bareStateId: null,
-                        frameId: null,
-                        transitions: [],
-                        overriddenHaltStateId: null,
-                        tags: [...__classPrivateFieldGet$1(state, _State_tags, "f")],
-                    };
-                }
-                continue;
-            }
-            // Wrapper? Emit wrapper node + queue bare and override target.
-            if (__classPrivateFieldGet$1(state, _State_overriddenHaltState, "f") !== null && __classPrivateFieldGet$1(state, _State_bareState, "f") !== null) {
-                const bareState = __classPrivateFieldGet$1(state, _State_bareState, "f");
-                const overrideTarget = __classPrivateFieldGet$1(state, _State_overriddenHaltState, "f");
-                nodes[__classPrivateFieldGet$1(state, _State_id, "f")] = {
-                    id: __classPrivateFieldGet$1(state, _State_id, "f"),
-                    name: __classPrivateFieldGet$1(state, _State_name, "f"), // composite name like "A(target)"
-                    isHalt: false,
-                    isHaltMarker: false,
-                    isWrapper: true,
-                    bareStateId: __classPrivateFieldGet$1(bareState, _State_id, "f"),
-                    frameId: null,
-                    transitions: [],
-                    overriddenHaltStateId: __classPrivateFieldGet$1(overrideTarget, _State_id, "f"),
-                    tags: [...__classPrivateFieldGet$1(state, _State_tags, "f")],
-                };
-                bareIds.add(__classPrivateFieldGet$1(bareState, _State_id, "f"));
-                queue.push(bareState);
-                queue.push(overrideTarget);
-                continue;
-            }
-            // Regular (or bare) state — build node with transitions.
-            const node = {
-                id: __classPrivateFieldGet$1(state, _State_id, "f"),
-                name: __classPrivateFieldGet$1(state, _State_name, "f"),
-                isHalt: false,
-                isHaltMarker: false,
-                isWrapper: false,
-                bareStateId: null,
-                frameId: null,
-                transitions: [],
-                overriddenHaltStateId: null,
-                tags: [...__classPrivateFieldGet$1(state, _State_tags, "f")],
-            };
-            nodes[__classPrivateFieldGet$1(state, _State_id, "f")] = node;
-            let patternIx = 0;
-            for (const [sym, { command, nextState }] of __classPrivateFieldGet$1(state, _State_symbolToDataMap, "f")) {
-                let target;
-                try {
-                    target = nextState instanceof _a ? nextState : nextState.ref;
-                }
-                catch {
-                    patternIx += 1;
-                    continue;
-                }
-                node.transitions.push({
-                    pattern: decodePatternDescription(sym.description, alphabets),
-                    command: command.tapesCommands.map((tc) => ({
-                        symbol: decodeWriteSymbol(tc.symbol),
-                        movement: decodeMovement(tc.movement.description),
-                    })),
-                    nextStateId: __classPrivateFieldGet$1(target, _State_id, "f"),
-                    id: `${__classPrivateFieldGet$1(state, _State_id, "f")}-${patternIx}`,
-                });
-                queue.push(target);
-                patternIx += 1;
-            }
-        }
-        // Always emit real halt as a sentinel, even if no transition targets it.
-        // It anchors the `subtree -. halt .-> s0` frame-level arrow whenever a
-        // frame demand-emits one, and it's the canonical machine-halt singleton.
-        if (!(0 in nodes)) {
-            nodes[0] = {
-                id: 0,
-                name: 'halt',
-                isHalt: true,
-                isHaltMarker: false,
-                isWrapper: false,
-                bareStateId: null,
-                frameId: null,
-                transitions: [],
-                overriddenHaltStateId: null,
-                tags: [...__classPrivateFieldGet$1(haltState, _State_tags, "f")],
-            };
-        }
-        // Pass 2: For each bare, compute its forward-reachable set (following
-        // transitions; stopping at halt and at wrappers — both are frame
-        // boundaries).
-        const computeReach = (startId) => {
-            const reach = new Set();
-            const stack = [startId];
-            while (stack.length > 0) {
-                const id = stack.pop();
-                if (reach.has(id)) {
-                    continue;
-                }
-                const node = nodes[id];
-                // `nodes[id]` is always populated for `id` that the BFS reached, so
-                // a defensive `!node` check would be dead. `isHalt` / `isWrapper`
-                // are real boundaries — both stop reach-set expansion.
-                if (node.isHalt || node.isWrapper) {
-                    continue;
-                }
-                reach.add(id);
-                for (const t of node.transitions) {
-                    const target = nodes[t.nextStateId];
-                    if (!target || target.isHalt || target.isWrapper) {
-                        continue;
-                    }
-                    stack.push(t.nextStateId);
-                }
-            }
-            return reach;
-        };
-        const reachByBare = new Map();
-        for (const bareId of bareIds) {
-            reachByBare.set(bareId, computeReach(bareId));
-        }
-        // Pass 3: Union-find on bare overlaps. Two bares merge if their reach
-        // sets share any state. Canonical representative = smallest bare-id in
-        // the component.
-        const ufParent = new Map();
-        // Note: no path compression. The union policy below ("smaller id always
-        // becomes root") keeps the tree flat — every union targets bares[0] as
-        // the root, so any node's parent IS the root. Walking up never exceeds
-        // one step. Path compression would be dead code under this invariant.
-        const ufFind = (id) => {
-            if (!ufParent.has(id)) {
-                ufParent.set(id, id);
-            }
-            let root = id;
-            while (ufParent.get(root) !== root) {
-                root = ufParent.get(root);
-            }
-            return root;
-        };
-        const ufUnion = (a, b) => {
-            const ra = ufFind(a);
-            const rb = ufFind(b);
-            if (ra === rb)
-                return;
-            if (ra < rb) {
-                ufParent.set(rb, ra);
-            }
-            else {
-                ufParent.set(ra, rb);
-            }
-        };
-        for (const bareId of bareIds) {
-            ufFind(bareId);
-        }
-        // For each state, collect the bares that reach it; union all bares that
-        // share a state.
-        const stateToReachingBares = new Map();
-        for (const [bareId, reachSet] of reachByBare) {
-            for (const stateId of reachSet) {
-                let bares = stateToReachingBares.get(stateId);
-                if (!bares) {
-                    bares = [];
-                    stateToReachingBares.set(stateId, bares);
-                }
-                bares.push(bareId);
-            }
-        }
-        for (const bares of stateToReachingBares.values()) {
-            for (let i = 1; i < bares.length; i += 1) {
-                ufUnion(bares[0], bares[i]);
-            }
-        }
-        // Assign frameId to each in-reach state.
-        const frameIds = new Set();
-        for (const [stateId, bares] of stateToReachingBares) {
-            const frameId = ufFind(bares[0]);
-            nodes[stateId].frameId = frameId;
-            frameIds.add(frameId);
-        }
-        // Pass 4: Retarget halt-bound transitions for in-frame states to the
-        // frame's halt marker. Out-of-frame states (top-level dispatcher, override
-        // targets, etc.) keep their halt-bound transitions pointing at real halt.
-        for (const node of Object.values(nodes)) {
-            if (node.frameId === null) {
-                continue;
-            }
-            const haltMarkerId = -node.frameId;
-            for (const t of node.transitions) {
-                const target = nodes[t.nextStateId];
-                if (target && target.isHalt && !target.isHaltMarker) {
-                    t.nextStateId = haltMarkerId;
-                }
-            }
-        }
-        // Pass 5: Emit one halt marker per frame.
-        for (const frameId of frameIds) {
-            const haltMarkerId = -frameId;
-            nodes[haltMarkerId] = {
-                id: haltMarkerId,
-                name: 'halt',
-                isHalt: true,
-                isHaltMarker: true,
-                isWrapper: false,
-                bareStateId: null,
-                frameId,
-                transitions: [],
-                overriddenHaltStateId: null,
-                tags: [],
-            };
-        }
-        return { initialId: __classPrivateFieldGet$1(initialState, _State_id, "f"), alphabets, nodes };
+        return toGraph(initialState, tapeBlock);
     }
-    // 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.
-    //
-    // Under the v7 callable-subtree model (#174), graph nodes split into:
-    //   - Wrapper nodes (`isWrapper: true`, no transitions) — reconstructed via
-    //     `bareStates[bareStateId].withOverriddenHaltState(finalStates[overriddenHaltStateId])`.
-    //   - Bare/regular nodes — constructed as normal States with transitions.
-    //   - Halt + halt-marker nodes — collapse to the singleton `haltState`.
+    /**
+     * Inverse of `toGraph`: rebuilds a State graph and a fresh TapeBlock
+     * from a serialized `Graph`. Thin delegate to `utilities/stateGraph.ts`'s
+     * `fromGraph` (extracted in #180); see that module for the
+     * reconstruction pass shape (Reference pre-create, bare build, wrapper
+     * resolution via `withOverriddenHaltState`, ref binding).
+     */
     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 non-halt-marker node
-        // (both wrappers and regulars). Halt and halt-marker nodes collapse to the
-        // singleton `haltState` and need no ref.
-        const refs = {};
-        for (const nodeId of ids) {
-            const node = graph.nodes[nodeId];
-            if (!node.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 State for each non-wrapper non-halt non-halt-marker
-        // node. Transitions point at refs so cycles work; haltState (and halt
-        // markers, which collapse to haltState) are used directly.
-        const bareStates = {};
-        for (const nodeId of ids) {
-            const node = graph.nodes[nodeId];
-            if (node.isHalt || node.isWrapper) {
-                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 || target.isHalt
-                    ? haltState
-                    : refs[t.nextStateId];
-                stateDefinition[key] = {
-                    command: t.command.map((c) => ({
-                        symbol: parseWriteSymbolLabel(c.symbol),
-                        movement: parseMovementLabel(c.movement),
-                    })),
-                    nextState,
-                };
-            }
-            // Graph-sourced names may contain `(` and `)` (composite wrapper names —
-            // although wrappers go through a separate path below, defensive
-            // construction here keeps the bypass uniform). Construct without a name
-            // and assign `#name` directly to skip user-facing name validation.
-            const bare = new _a(stateDefinition);
-            __classPrivateFieldSet$1(bare, _State_name, node.name, "f");
-            if (node.tags.length > 0) {
-                bare.tag(...node.tags);
-            }
-            bareStates[nodeId] = bare;
-        }
-        // Pass 3: resolve every node to its final State (memoized + cycle-safe).
-        // Wrappers compose lazily via `withOverriddenHaltState` once their bare
-        // and override are resolved.
-        const finalStates = {};
-        const inProgress = new Set();
-        const getFinal = (nodeId) => {
-            if (finalStates[nodeId]) {
-                return finalStates[nodeId];
-            }
-            const node = graph.nodes[nodeId];
-            if (!node || 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;
-            if (node.isWrapper) {
-                const bare = getFinal(node.bareStateId);
-                const override = getFinal(node.overriddenHaltStateId);
-                state = bare.withOverriddenHaltState(override);
-                // Apply wrapper-scoped tags (#186). Tags don't leak across wrappers
-                // sharing a bare — the wrapper instance owns its own tag set, and
-                // engine #175 memoization returns the same instance for the same
-                // (bare, override) pair, so this is idempotent across rebuilds.
-                if (node.tags.length > 0) {
-                    state.tag(...node.tags);
-                }
-            }
-            else {
-                state = bareStates[nodeId];
-            }
-            inProgress.delete(nodeId);
-            finalStates[nodeId] = state;
-            return state;
-        };
-        for (const nodeId of ids) {
-            getFinal(nodeId);
-        }
-        // Pass 4: bind each ref to the resolved final State so cross-node
-        // transitions land on the right instance.
-        for (const nodeId of ids) {
-            if (!graph.nodes[nodeId].isHalt) {
-                refs[nodeId].bind(finalStates[nodeId]);
-            }
-        }
-        return {
-            start: finalStates[graph.initialId],
-            tapeBlock,
-            states: finalStates,
-        };
+        return fromGraph(graph);
+    }
+    /**
+     * Returns a `Map<number, {state, transitionSymbols}>` keyed by engine
+     * `GraphNode.id`, exposing the live `State` instance + per-pattern
+     * Symbol references for each node so downstream tooling can mutate
+     * `state.debug` by numeric id and set per-pattern breakpoints by
+     * `GraphTransition.id` (#195). Thin delegate to
+     * `utilities/stateGraph.ts`'s `collectStates`; see that module for
+     * the alignment contract, coverage rules, and halt-singleton warning.
+     */
+    static collectStates(initialState, tapeBlock) {
+        return collectStates(initialState, tapeBlock);
     }
 }
 _a = State;
@@ -1388,7 +1734,7 @@ var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) ||
     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 _TuringMachine_tapeBlock, _TuringMachine_stack;
+var _TuringMachine_tapeBlock;
 // True iff `filter` matches `symbol` per the DebugConfig semantics.
 // undefined / [] -> never; true -> always; symbol[] -> exact membership.
 function matchFilter(filter, symbol) {
@@ -1401,7 +1747,6 @@ function matchFilter(filter, symbol) {
 class TuringMachine {
     constructor({ tapeBlock, } = {}) {
         _TuringMachine_tapeBlock.set(this, void 0);
-        _TuringMachine_stack.set(this, []);
         if (!tapeBlock) {
             throw new Error('invalid tapeBlock');
         }
@@ -1435,7 +1780,14 @@ class TuringMachine {
         try {
             __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].check(executionSymbol);
             __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].lock(executionSymbol);
-            const stack = __classPrivateFieldGet(this, _TuringMachine_stack, "f");
+            // Halt-stack is run-scoped, not machine-scoped (#196). Declaring it
+            // local makes that lifetime explicit and prevents leftover entries
+            // from a previous `runStepByStep` call (e.g. a build-time peek that
+            // never drained the generator) from being popped during a subsequent
+            // halt-bound transition. Before this change `#stack` was an instance
+            // field and accumulated one extra push per call when the same machine
+            // was reused.
+            const stack = [];
             let state = initialState;
             if (state.overriddenHaltState) {
                 stack.push(state.overriddenHaltState);
@@ -1448,14 +1800,43 @@ class TuringMachine {
                 i += 1;
                 const symbol = state.getSymbol(__classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f"));
                 const command = state.getCommand(symbol);
-                let nextState = state.getNextState(symbol).ref;
+                const matched = state.getMatchedTransition(symbol);
+                let nextState = matched.nextState.ref;
+                // For wrapper-entry iters, the wrapper's transitions in `toGraph`
+                // are empty (wrappers delegate to the bare via shared
+                // `#symbolToDataMap`); the resolvable transition id lives under
+                // the bare's stateId. `bareState` is non-null only when `state`
+                // is a wrapper produced by `withOverriddenHaltState`. Accessed
+                // via the STATE_INTERNAL package-private view (same pattern
+                // `utilities/stateGraph.ts` uses) to avoid widening the public
+                // State API for this internal need.
+                const stateInternal = state[STATE_INTERNAL]();
+                const resolvableStateId = stateInternal.bareState?.id ?? state.id;
+                const matchedTransition = {
+                    id: `${resolvableStateId}.${matched.ix}`,
+                    matchKinds: __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").patternKinds(matched.matchedSymbol),
+                };
                 try {
                     // Both before and after refer to THIS iter (#119 / v6.0.0).
                     // The halting iter's after-fire just rides along on the iter's
                     // own yield — no post-loop drain needed.
-                    const beforeMatch = matchFilter(state.debug?.before, symbol)
-                        || (nextState.isHalt && nextState.debug?.before === true);
-                    const afterMatch = matchFilter(state.debug?.after, symbol);
+                    //
+                    // #207: `haltState.debug` is now a boolean, and pauses on the
+                    // halt-triggering iter's AFTER side (not before). The previous
+                    // before-side check (`nextState.debug?.before === true`) was
+                    // "early-warning" timing — the user paused before the halt-bound
+                    // transition fired, then had to mentally re-derive what would
+                    // happen. Now the pause anchors post-step (after the iter's own
+                    // after-pause if armed), so consumers see the just-fired halt-
+                    // bound transition + diagram cursor still on the triggering state.
+                    //
+                    // `state` here is always non-halt (halt is terminal — the run
+                    // loop never iterates with state === haltState), so `state.debug`
+                    // is always `DebugConfig` at runtime. The public getter's return
+                    // type matches that.
+                    const beforeMatch = matchFilter(state.debug?.before, symbol);
+                    const afterMatch = matchFilter(state.debug?.after, symbol)
+                        || (nextState === haltState && haltState.debug);
                     const nextStateForYield = nextState.isHalt && stack.length
                         ? stack.slice(-1)[0]
                         : nextState;
@@ -1478,6 +1859,7 @@ class TuringMachine {
                         }),
                         movements: command.tapesCommands.map((tapeCommand) => tapeCommand.movement),
                         nextState: nextStateForYield,
+                        matchedTransition,
                     };
                     if (beforeMatch || afterMatch) {
                         const dbg = {};
@@ -1510,7 +1892,7 @@ class TuringMachine {
         }
     }
 }
-_TuringMachine_tapeBlock = new WeakMap(), _TuringMachine_stack = new WeakMap();
+_TuringMachine_tapeBlock = new WeakMap();
 
 // Format converters between a Graph (the data model produced by State.toGraph
 // and consumed by State.fromGraph) and external string representations.
@@ -1553,6 +1935,81 @@ function parseMermaidId(s) {
 function frameSubgraphId(frameId) {
     return `w_${frameId}`;
 }
+// User-controlled content (state names, tag names, alphabet symbols inside
+// edge labels) is interpolated into Mermaid label strings (`"..."` wrappers
+// on nodes, wrappers, subgraphs, and edges). Mermaid's grammar terminates
+// the string on a literal `"`, and labels render via HTML/foreignObject so
+// `<`, `>`, `&` get interpreted as markup. Statement terminators (`\n`,
+// `\r`), C0 controls (except `\t`), DEL, bidi controls, and lone UTF-16
+// surrogates are encoded as numeric entities so they can't confuse the
+// tokenizer or flip text direction silently (#194).
+//
+// Printable Unicode (Cyrillic, CJK, emoji, accented Latin, etc.) passes
+// through unchanged — a tape alphabet of Cyrillic or Brainfuck glyphs
+// stays readable in the emitted `.mmd`.
+//
+// Escape is applied at the leaf — to each user-supplied fragment BEFORE
+// it's composed into a label. Structural pieces this module emits (`<br>`
+// tag separator, ` ∪ ` bare-name join, `[`, `]`, `,`, `|`, `/`, ` → `,
+// the `callable subtree of `/`callable scope: ` prefixes) are NOT escaped;
+// only user-controlled content is. fromMermaid mirrors with
+// `unescapeMermaidLabel` on each extracted leaf AFTER structural parsing,
+// so a literal `<br>` inside a state name (encoded as `&lt;br&gt;`)
+// survives the tag-split and decodes back at the leaf.
+const MERMAID_LABEL_ESCAPE_RE = /[&"<>\n\r\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\u202A-\u202E\u2066-\u2069\uD800-\uDFFF]/g;
+function escapeMermaidLabel(s) {
+    return s.replace(MERMAID_LABEL_ESCAPE_RE, (ch) => {
+        switch (ch) {
+            case '&': return '&amp;';
+            case '"': return '&quot;';
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '\n': return '&#10;';
+            case '\r': return '&#13;';
+            default: return `&#${ch.charCodeAt(0)};`;
+        }
+    });
+}
+// Inverse of escapeMermaidLabel. Decodes the four named entities the
+// encoder emits (`&amp;`, `&quot;`, `&lt;`, `&gt;`) plus arbitrary
+// numeric entities (`&#NN;`, `&#xHH;`) — the latter to round-trip the
+// control / bidi / lone-surrogate cases from encode. Other named entities
+// pass through unchanged: fromMermaid is strict to the dialect toMermaid
+// emits, and a future-proof full HTML-entity decoder would muddle that.
+//
+// Replacement is single-pass: each `&...;` match is consumed once with
+// no re-scanning of the substitution, so nested-looking inputs like
+// `&amp;quot;` (literal `&quot;` as user text) decode to `&quot;` not `"`.
+const MERMAID_LABEL_UNESCAPE_RE = /&(?:(amp|quot|lt|gt)|#(\d+)|#x([0-9a-fA-F]+));/g;
+function unescapeMermaidLabel(s) {
+    return s.replace(MERMAID_LABEL_UNESCAPE_RE, (match, named, dec, hex) => {
+        switch (named) {
+            case 'amp': return '&';
+            case 'quot': return '"';
+            case 'lt': return '<';
+            case 'gt': return '>';
+            default: {
+                // Code units up to U+FFFF decode via fromCharCode so lone
+                // surrogates we encoded by UTF-16 code unit round-trip exactly.
+                // Hand-edited supplementary code points (`&#x1F600;`) use
+                // fromCodePoint to produce the right surrogate pair — but only
+                // when we didn't emit them ourselves, since encode runs per code
+                // unit.
+                if (dec !== undefined) {
+                    const n = Number.parseInt(dec, 10);
+                    return n <= 0xFFFF ? String.fromCharCode(n) : String.fromCodePoint(n);
+                }
+                if (hex !== undefined) {
+                    const n = Number.parseInt(hex, 16);
+                    return n <= 0xFFFF ? String.fromCharCode(n) : String.fromCodePoint(n);
+                }
+                /* c8 ignore next 2 — defensive: the regex shape guarantees one of
+                   named / dec / hex is always set, so this fallback is unreachable. */
+                return match;
+            }
+        }
+    });
+}
 function toMermaid(graph) {
     const lines = [
         'flowchart TD',
@@ -1591,9 +2048,18 @@ function toMermaid(graph) {
     // Mermaid line-break that works across renderers without `classDef`-
     // pseudo-element hacks (#186).
     const labelOf = (node) => {
+        const name = escapeMermaidLabel(node.name);
         if (node.tags.length === 0)
-            return node.name;
-        return `${node.name}<br>${node.tags.join(', ')}`;
+            return name;
+        // Per-tag escape that ALSO encodes `,` — tags are joined with `, ` and
+        // split on `,` in `splitLabelTags`, so a literal comma in user tag
+        // content would be mistaken for a separator on the way back. `,` isn't
+        // in the base escape set because it's structural in edge labels
+        // (between per-tape cells in `writes`/`moves`), where the encode pass
+        // happens after composition — different context, different escape.
+        const tagFragments = node.tags
+            .map((t) => escapeMermaidLabel(t).replace(/,/g, '&#44;'));
+        return `${name}<br>${tagFragments.join(', ')}`;
     };
     // 1. Emit top-level nodes (real halt, non-wrapper regulars outside any frame).
     for (const node of topLevelNodes) {
@@ -1618,7 +2084,7 @@ function toMermaid(graph) {
         const frameBareNames = frameBares
             .slice()
             .sort((a, b) => a.id - b.id)
-            .map((n) => n.name);
+            .map((n) => escapeMermaidLabel(n.name));
         const label = frameBareNames.length > 1
             ? `callable scope: ${frameBareNames.join(' ∪ ')}`
             : `callable subtree of ${frameBareNames[0] ?? frameId}`;
@@ -1720,7 +2186,12 @@ function toMermaid(graph) {
             const reads = alternatives.map((alt) => `[${alt}]`).join('|');
             const writes = `[${t.command.map((c) => c.symbol).join(',')}]`;
             const moves = `[${t.command.map((c) => c.movement).join(',')}]`;
-            const label = `${reads} → ${writes}/${moves}`;
+            // Escape the WHOLE composed label — structural separators ([, ], ,,
+            // |, /, ' → ') are all in our safe ASCII set and pass through
+            // unchanged; only embedded user alphabet symbols inside `'...'` get
+            // entity-encoded. fromMermaid unescapes the captured label as the
+            // first step before structural parsing.
+            const label = escapeMermaidLabel(`${reads} → ${writes}/${moves}`);
             lines.push(`  ${mermaidIdFor(node.id)} -- "${label}" --> ${mermaidIdFor(t.nextStateId)}`);
         }
     }
@@ -1851,14 +2322,23 @@ const classAssignTagRegex = /^class ([sc]\d+(?:,[sc]\d+)*) tag_([A-Za-z0-9_-]+)$
 // Labels without `<br>` have no tags. Tags are comma-joined; trimmed of
 // whitespace. The `<br>` is the single source of truth for tag-name parsing —
 // `class` lines are decorative-only and not consulted here.
+//
+// Mermaid-label entities (`&lt;`, `&quot;`, etc., #194) are decoded AFTER
+// structural splitting: the `<br>` separator and `,` tag delimiter survive
+// encode unchanged, and a user state name / tag containing a literal `<br>`
+// or `,` was encoded leaf-side so it can't be confused with the structural
+// form. Decode at the leaves recovers the original characters.
 function splitLabelTags(label) {
     const brIx = label.indexOf('<br>');
     if (brIx < 0) {
-        return { name: label, tags: [] };
+        return { name: unescapeMermaidLabel(label), tags: [] };
     }
-    const name = label.slice(0, brIx);
+    const name = unescapeMermaidLabel(label.slice(0, brIx));
     const tagsStr = label.slice(brIx + '<br>'.length);
-    const tags = tagsStr.split(',').map((t) => t.trim()).filter((t) => t.length > 0);
+    const tags = tagsStr
+        .split(',')
+        .map((t) => unescapeMermaidLabel(t.trim()))
+        .filter((t) => t.length > 0);
     return { name, tags };
 }
 function fromMermaid(text) {
@@ -2018,7 +2498,12 @@ function fromMermaid(text) {
         const tm = line.match(labeledTransitionRegex);
         if (tm) {
             const fromId = parseMermaidId(tm[1]);
-            const label = tm[2];
+            // Decode the WHOLE captured label up front (#194). Structural
+            // separators (`[`, `]`, `,`, `|`, `/`, ` → `) are all safe ASCII
+            // outside the escape set and pass through encode unchanged, so it's
+            // safe to decode before structural parsing; only embedded alphabet
+            // symbols inside `'...'` get reconstituted.
+            const label = unescapeMermaidLabel(tm[2]);
             const toId = parseMermaidId(tm[3]);
             const arrowIx = label.indexOf(' → ');
             if (arrowIx === -1) {