@turing-machine-js/machine 7.0.0-alpha.4 → 7.0.0-alpha.6

package/dist/index.cjs

@@ -13,13 +13,13 @@ function id(object) {
 id[idKey] = 0;
 id[idWeakMapKey] = new WeakMap();
 
-var __classPrivateFieldSet$8 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$9 = (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");
     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$8 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$9 = (undefined && undefined.__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);
@@ -39,36 +39,36 @@ class Alphabet {
         if (!isSymbolsValid) {
             throw new Error('symbols contains invalid symbol');
         }
-        __classPrivateFieldSet$8(this, _Alphabet_symbols, Array.from(uniqueSymbols), "f");
+        __classPrivateFieldSet$9(this, _Alphabet_symbols, Array.from(uniqueSymbols), "f");
     }
     get symbols() {
-        return Array.from(__classPrivateFieldGet$8(this, _Alphabet_symbols, "f"));
+        return Array.from(__classPrivateFieldGet$9(this, _Alphabet_symbols, "f"));
     }
     get blankSymbol() {
-        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f")[0];
+        return __classPrivateFieldGet$9(this, _Alphabet_symbols, "f")[0];
     }
     has(symbol) {
-        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f").indexOf(symbol) >= 0;
+        return __classPrivateFieldGet$9(this, _Alphabet_symbols, "f").indexOf(symbol) >= 0;
     }
     get(index) {
-        if (index < 0 || index >= __classPrivateFieldGet$8(this, _Alphabet_symbols, "f").length) {
+        if (index < 0 || index >= __classPrivateFieldGet$9(this, _Alphabet_symbols, "f").length) {
             throw new Error('Invalid index');
         }
-        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f")[index];
+        return __classPrivateFieldGet$9(this, _Alphabet_symbols, "f")[index];
     }
     index(symbol) {
-        return __classPrivateFieldGet$8(this, _Alphabet_symbols, "f").indexOf(symbol);
+        return __classPrivateFieldGet$9(this, _Alphabet_symbols, "f").indexOf(symbol);
     }
 }
 _Alphabet_symbols = new WeakMap();
 
-var __classPrivateFieldSet$7 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$8 = (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");
     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$7 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$8 = (undefined && undefined.__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);
@@ -91,30 +91,30 @@ class TapeCommand {
         if (!isValidMovement) {
             throw new Error('invalid movement');
         }
-        __classPrivateFieldSet$7(this, _TapeCommand_movement, movement, "f");
+        __classPrivateFieldSet$8(this, _TapeCommand_movement, movement, "f");
         const isValidSymbol = ((typeof symbol === 'string' && symbol.length === 1)
             || [symbolCommands.keep, symbolCommands.erase].includes(symbol));
         if (!isValidSymbol) {
             throw new Error('invalid symbol');
         }
-        __classPrivateFieldSet$7(this, _TapeCommand_symbol, symbol, "f");
+        __classPrivateFieldSet$8(this, _TapeCommand_symbol, symbol, "f");
     }
     get symbol() {
-        return __classPrivateFieldGet$7(this, _TapeCommand_symbol, "f");
+        return __classPrivateFieldGet$8(this, _TapeCommand_symbol, "f");
     }
     get movement() {
-        return __classPrivateFieldGet$7(this, _TapeCommand_movement, "f");
+        return __classPrivateFieldGet$8(this, _TapeCommand_movement, "f");
     }
 }
 _TapeCommand_movement = new WeakMap(), _TapeCommand_symbol = new WeakMap();
 
-var __classPrivateFieldSet$6 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$7 = (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");
     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$6 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$7 = (undefined && undefined.__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);
@@ -127,7 +127,7 @@ class Command {
             throw new Error('invalid parameter');
         }
         try {
-            __classPrivateFieldSet$6(this, _Command_tapesCommands, tapesCommands.map((tapeCommand) => {
+            __classPrivateFieldSet$7(this, _Command_tapesCommands, tapesCommands.map((tapeCommand) => {
                 if (tapeCommand instanceof TapeCommand) {
                     return tapeCommand;
                 }
@@ -139,17 +139,17 @@ class Command {
         }
     }
     get tapesCommands() {
-        return [...__classPrivateFieldGet$6(this, _Command_tapesCommands, "f")];
+        return [...__classPrivateFieldGet$7(this, _Command_tapesCommands, "f")];
     }
 }
 _Command_tapesCommands = new WeakMap();
 
-var __classPrivateFieldGet$5 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$6 = (undefined && undefined.__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$5 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$6 = (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");
     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");
@@ -161,16 +161,16 @@ class Reference {
         _Reference_referenceBinding.set(this, null);
     }
     get ref() {
-        if (!__classPrivateFieldGet$5(this, _Reference_referenceBinding, "f")) {
+        if (!__classPrivateFieldGet$6(this, _Reference_referenceBinding, "f")) {
             throw new Error('unbounded reference');
         }
-        return __classPrivateFieldGet$5(this, _Reference_referenceBinding, "f");
+        return __classPrivateFieldGet$6(this, _Reference_referenceBinding, "f");
     }
     bind(state) {
-        if (__classPrivateFieldGet$5(this, _Reference_referenceBinding, "f") == null) {
-            __classPrivateFieldSet$5(this, _Reference_referenceBinding, state, "f");
+        if (__classPrivateFieldGet$6(this, _Reference_referenceBinding, "f") == null) {
+            __classPrivateFieldSet$6(this, _Reference_referenceBinding, state, "f");
         }
-        return __classPrivateFieldGet$5(this, _Reference_referenceBinding, "f");
+        return __classPrivateFieldGet$6(this, _Reference_referenceBinding, "f");
     }
 }
 _Reference_referenceBinding = new WeakMap();
@@ -322,13 +322,13 @@ function decodeWriteSymbol(symbol) {
 }
 // Format converters (toMermaid / fromMermaid) live in ./graphFormats.
 
-var __classPrivateFieldSet$4 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$5 = (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");
     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$4 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$5 = (undefined && undefined.__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);
@@ -349,65 +349,65 @@ class Tape {
         if (!isSymbolsValid) {
             throw new Error('symbolList contains invalid symbol');
         }
-        __classPrivateFieldSet$4(this, _Tape_alphabet, new Alphabet(alphabet), "f");
-        __classPrivateFieldSet$4(this, _Tape_position, position, "f");
-        __classPrivateFieldSet$4(this, _Tape_viewportWidth, 1, "f");
-        const initialSymbols = symbols.length === 0 ? [__classPrivateFieldGet$4(this, _Tape_alphabet, "f").blankSymbol] : symbols;
+        __classPrivateFieldSet$5(this, _Tape_alphabet, new Alphabet(alphabet), "f");
+        __classPrivateFieldSet$5(this, _Tape_position, position, "f");
+        __classPrivateFieldSet$5(this, _Tape_viewportWidth, 1, "f");
+        const initialSymbols = symbols.length === 0 ? [__classPrivateFieldGet$5(this, _Tape_alphabet, "f").blankSymbol] : symbols;
         for (const symbol of initialSymbols) {
-            __classPrivateFieldGet$4(this, _Tape_right, "f").push(__classPrivateFieldGet$4(this, _Tape_alphabet, "f").index(symbol));
+            __classPrivateFieldGet$5(this, _Tape_right, "f").push(__classPrivateFieldGet$5(this, _Tape_alphabet, "f").index(symbol));
         }
         this.viewportWidth = viewportWidth;
     }
     get alphabet() {
-        return __classPrivateFieldGet$4(this, _Tape_alphabet, "f");
+        return __classPrivateFieldGet$5(this, _Tape_alphabet, "f");
     }
     get extraCellsCount() {
-        return (__classPrivateFieldGet$4(this, _Tape_viewportWidth, "f") - 1) / 2;
+        return (__classPrivateFieldGet$5(this, _Tape_viewportWidth, "f") - 1) / 2;
     }
     get position() {
         // Public contract: index of the head in the `symbols` array. With the
         // two-array deque, `#position` is the head's logical position; adding
         // `#left.length` shifts it back into "index from the leftmost backed cell".
-        return __classPrivateFieldGet$4(this, _Tape_position, "f") + __classPrivateFieldGet$4(this, _Tape_left, "f").length;
+        return __classPrivateFieldGet$5(this, _Tape_position, "f") + __classPrivateFieldGet$5(this, _Tape_left, "f").length;
     }
     get symbol() {
-        return __classPrivateFieldGet$4(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$4(this, _Tape_instances, "m", _Tape_cellAt).call(this, __classPrivateFieldGet$4(this, _Tape_position, "f")));
+        return __classPrivateFieldGet$5(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$5(this, _Tape_instances, "m", _Tape_cellAt).call(this, __classPrivateFieldGet$5(this, _Tape_position, "f")));
     }
     set symbol(symbol) {
-        if (!__classPrivateFieldGet$4(this, _Tape_alphabet, "f").has(symbol)) {
+        if (!__classPrivateFieldGet$5(this, _Tape_alphabet, "f").has(symbol)) {
             throw new Error('Invalid symbol');
         }
-        const index = __classPrivateFieldGet$4(this, _Tape_alphabet, "f").index(symbol);
-        if (__classPrivateFieldGet$4(this, _Tape_position, "f") >= 0) {
-            __classPrivateFieldGet$4(this, _Tape_right, "f")[__classPrivateFieldGet$4(this, _Tape_position, "f")] = index;
+        const index = __classPrivateFieldGet$5(this, _Tape_alphabet, "f").index(symbol);
+        if (__classPrivateFieldGet$5(this, _Tape_position, "f") >= 0) {
+            __classPrivateFieldGet$5(this, _Tape_right, "f")[__classPrivateFieldGet$5(this, _Tape_position, "f")] = index;
         }
         else {
-            __classPrivateFieldGet$4(this, _Tape_left, "f")[-__classPrivateFieldGet$4(this, _Tape_position, "f") - 1] = index;
+            __classPrivateFieldGet$5(this, _Tape_left, "f")[-__classPrivateFieldGet$5(this, _Tape_position, "f") - 1] = index;
         }
-        __classPrivateFieldSet$4(this, _Tape_viewportDirty, true, "f");
+        __classPrivateFieldSet$5(this, _Tape_viewportDirty, true, "f");
     }
     get symbols() {
-        const result = new Array(__classPrivateFieldGet$4(this, _Tape_left, "f").length + __classPrivateFieldGet$4(this, _Tape_right, "f").length);
-        for (let i = 0; i < __classPrivateFieldGet$4(this, _Tape_left, "f").length; i += 1) {
-            result[i] = __classPrivateFieldGet$4(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$4(this, _Tape_left, "f")[__classPrivateFieldGet$4(this, _Tape_left, "f").length - 1 - i]);
+        const result = new Array(__classPrivateFieldGet$5(this, _Tape_left, "f").length + __classPrivateFieldGet$5(this, _Tape_right, "f").length);
+        for (let i = 0; i < __classPrivateFieldGet$5(this, _Tape_left, "f").length; i += 1) {
+            result[i] = __classPrivateFieldGet$5(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$5(this, _Tape_left, "f")[__classPrivateFieldGet$5(this, _Tape_left, "f").length - 1 - i]);
         }
-        for (let i = 0; i < __classPrivateFieldGet$4(this, _Tape_right, "f").length; i += 1) {
-            result[__classPrivateFieldGet$4(this, _Tape_left, "f").length + i] = __classPrivateFieldGet$4(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$4(this, _Tape_right, "f")[i]);
+        for (let i = 0; i < __classPrivateFieldGet$5(this, _Tape_right, "f").length; i += 1) {
+            result[__classPrivateFieldGet$5(this, _Tape_left, "f").length + i] = __classPrivateFieldGet$5(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$5(this, _Tape_right, "f")[i]);
         }
         return result;
     }
     get viewport() {
-        if (__classPrivateFieldGet$4(this, _Tape_viewportDirty, "f")) {
-            const start = __classPrivateFieldGet$4(this, _Tape_position, "f") - this.extraCellsCount;
-            for (let i = 0; i < __classPrivateFieldGet$4(this, _Tape_viewportWidth, "f"); i += 1) {
-                __classPrivateFieldGet$4(this, _Tape_viewportBuffer, "f")[i] = __classPrivateFieldGet$4(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$4(this, _Tape_instances, "m", _Tape_cellAt).call(this, start + i));
+        if (__classPrivateFieldGet$5(this, _Tape_viewportDirty, "f")) {
+            const start = __classPrivateFieldGet$5(this, _Tape_position, "f") - this.extraCellsCount;
+            for (let i = 0; i < __classPrivateFieldGet$5(this, _Tape_viewportWidth, "f"); i += 1) {
+                __classPrivateFieldGet$5(this, _Tape_viewportBuffer, "f")[i] = __classPrivateFieldGet$5(this, _Tape_alphabet, "f").get(__classPrivateFieldGet$5(this, _Tape_instances, "m", _Tape_cellAt).call(this, start + i));
             }
-            __classPrivateFieldSet$4(this, _Tape_viewportDirty, false, "f");
+            __classPrivateFieldSet$5(this, _Tape_viewportDirty, false, "f");
         }
-        return [...__classPrivateFieldGet$4(this, _Tape_viewportBuffer, "f")];
+        return [...__classPrivateFieldGet$5(this, _Tape_viewportBuffer, "f")];
     }
     get viewportWidth() {
-        return __classPrivateFieldGet$4(this, _Tape_viewportWidth, "f");
+        return __classPrivateFieldGet$5(this, _Tape_viewportWidth, "f");
     }
     set viewportWidth(width) {
         let finalWidth = width;
@@ -417,46 +417,46 @@ class Tape {
         if (finalWidth % 2 === 0) {
             finalWidth += 1;
         }
-        __classPrivateFieldSet$4(this, _Tape_viewportWidth, finalWidth, "f");
-        __classPrivateFieldGet$4(this, _Tape_viewportBuffer, "f").length = finalWidth;
-        __classPrivateFieldSet$4(this, _Tape_viewportDirty, true, "f");
+        __classPrivateFieldSet$5(this, _Tape_viewportWidth, finalWidth, "f");
+        __classPrivateFieldGet$5(this, _Tape_viewportBuffer, "f").length = finalWidth;
+        __classPrivateFieldSet$5(this, _Tape_viewportDirty, true, "f");
         this.normalise();
     }
     left() {
-        __classPrivateFieldSet$4(this, _Tape_position, __classPrivateFieldGet$4(this, _Tape_position, "f") - 1, "f");
+        __classPrivateFieldSet$5(this, _Tape_position, __classPrivateFieldGet$5(this, _Tape_position, "f") - 1, "f");
         this.normalise();
-        __classPrivateFieldSet$4(this, _Tape_viewportDirty, true, "f");
+        __classPrivateFieldSet$5(this, _Tape_viewportDirty, true, "f");
     }
     normalise() {
-        const minLogical = __classPrivateFieldGet$4(this, _Tape_position, "f") - this.extraCellsCount;
-        const maxLogical = __classPrivateFieldGet$4(this, _Tape_position, "f") + this.extraCellsCount;
-        while (-__classPrivateFieldGet$4(this, _Tape_left, "f").length > minLogical) {
-            __classPrivateFieldGet$4(this, _Tape_left, "f").push(BLANK_INDEX);
+        const minLogical = __classPrivateFieldGet$5(this, _Tape_position, "f") - this.extraCellsCount;
+        const maxLogical = __classPrivateFieldGet$5(this, _Tape_position, "f") + this.extraCellsCount;
+        while (-__classPrivateFieldGet$5(this, _Tape_left, "f").length > minLogical) {
+            __classPrivateFieldGet$5(this, _Tape_left, "f").push(BLANK_INDEX);
         }
-        while (__classPrivateFieldGet$4(this, _Tape_right, "f").length - 1 < maxLogical) {
-            __classPrivateFieldGet$4(this, _Tape_right, "f").push(BLANK_INDEX);
+        while (__classPrivateFieldGet$5(this, _Tape_right, "f").length - 1 < maxLogical) {
+            __classPrivateFieldGet$5(this, _Tape_right, "f").push(BLANK_INDEX);
         }
     }
     right() {
-        __classPrivateFieldSet$4(this, _Tape_position, __classPrivateFieldGet$4(this, _Tape_position, "f") + 1, "f");
+        __classPrivateFieldSet$5(this, _Tape_position, __classPrivateFieldGet$5(this, _Tape_position, "f") + 1, "f");
         this.normalise();
-        __classPrivateFieldSet$4(this, _Tape_viewportDirty, true, "f");
+        __classPrivateFieldSet$5(this, _Tape_viewportDirty, true, "f");
     }
 }
 _Tape_alphabet = new WeakMap(), _Tape_right = new WeakMap(), _Tape_left = new WeakMap(), _Tape_position = new WeakMap(), _Tape_viewportWidth = new WeakMap(), _Tape_viewportBuffer = new WeakMap(), _Tape_viewportDirty = new WeakMap(), _Tape_instances = new WeakSet(), _Tape_cellAt = function _Tape_cellAt(logical) {
     if (logical >= 0) {
-        return logical < __classPrivateFieldGet$4(this, _Tape_right, "f").length ? __classPrivateFieldGet$4(this, _Tape_right, "f")[logical] : BLANK_INDEX;
+        return logical < __classPrivateFieldGet$5(this, _Tape_right, "f").length ? __classPrivateFieldGet$5(this, _Tape_right, "f")[logical] : BLANK_INDEX;
     }
     const ix = -logical - 1;
-    return ix < __classPrivateFieldGet$4(this, _Tape_left, "f").length ? __classPrivateFieldGet$4(this, _Tape_left, "f")[ix] : BLANK_INDEX;
+    return ix < __classPrivateFieldGet$5(this, _Tape_left, "f").length ? __classPrivateFieldGet$5(this, _Tape_left, "f")[ix] : BLANK_INDEX;
 };
 
-var __classPrivateFieldGet$3 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$4 = (undefined && undefined.__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$3 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+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");
     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");
@@ -468,30 +468,30 @@ class Lock {
         _Lock_lockSymbol.set(this, null);
     }
     lock(symbol) {
-        if (__classPrivateFieldGet$3(this, _Lock_lockSymbol, "f") === null) {
-            __classPrivateFieldSet$3(this, _Lock_lockSymbol, symbol, "f");
+        if (__classPrivateFieldGet$4(this, _Lock_lockSymbol, "f") === null) {
+            __classPrivateFieldSet$4(this, _Lock_lockSymbol, symbol, "f");
         }
     }
     unlock(symbol) {
-        if (__classPrivateFieldGet$3(this, _Lock_lockSymbol, "f") === symbol) {
-            __classPrivateFieldSet$3(this, _Lock_lockSymbol, null, "f");
+        if (__classPrivateFieldGet$4(this, _Lock_lockSymbol, "f") === symbol) {
+            __classPrivateFieldSet$4(this, _Lock_lockSymbol, null, "f");
         }
     }
     check(symbol) {
-        if (__classPrivateFieldGet$3(this, _Lock_lockSymbol, "f") && __classPrivateFieldGet$3(this, _Lock_lockSymbol, "f") !== symbol) {
+        if (__classPrivateFieldGet$4(this, _Lock_lockSymbol, "f") && __classPrivateFieldGet$4(this, _Lock_lockSymbol, "f") !== symbol) {
             throw new Error('Lock check failed');
         }
     }
 }
 _Lock_lockSymbol = new WeakMap();
 
-var __classPrivateFieldSet$2 = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$3 = (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");
     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$2 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$3 = (undefined && undefined.__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);
@@ -505,7 +505,7 @@ class TapeBlock {
         _TapeBlock_lock.set(this, new Lock());
         _TapeBlock_tapes.set(this, void 0);
         _TapeBlock_buildPatternList.set(this, (symbolList) => symbolList.reduce((result, symbol, ix) => {
-            const row = Math.floor(ix / __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length);
+            const row = Math.floor(ix / __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").length);
             if (!Array.isArray(result[row])) {
                 result[row] = [];
             }
@@ -521,7 +521,7 @@ class TapeBlock {
             if (patternList.some((pattern) => pattern.every((symbol) => symbol === ifOtherSymbol))) {
                 return ifOtherSymbol;
             }
-            const [storedPatternListSymbol] = [...__classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f").entries()]
+            const [storedPatternListSymbol] = [...__classPrivateFieldGet$3(this, _TapeBlock_symbolToPatternListMap, "f").entries()]
                 .find(([, storedPatternList]) => {
                 if (storedPatternList.length !== patternList.length) {
                     return false;
@@ -535,8 +535,8 @@ class TapeBlock {
                 symbol = storedPatternListSymbol;
             }
             else {
-                symbol = Symbol(__classPrivateFieldGet$2(_a$1, _a$1, "f", _TapeBlock_generateSymbolHint).call(_a$1, patternList));
-                __classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f").set(symbol, patternList);
+                symbol = Symbol(__classPrivateFieldGet$3(_a$1, _a$1, "f", _TapeBlock_generateSymbolHint).call(_a$1, patternList));
+                __classPrivateFieldGet$3(this, _TapeBlock_symbolToPatternListMap, "f").set(symbol, patternList);
             }
             return symbol;
         });
@@ -551,60 +551,60 @@ class TapeBlock {
             else if (Array.isArray(symbols)) {
                 localSymbols = [...symbols];
             }
-            if (localSymbols.length === 0 || localSymbols.length % __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length > 0) {
+            if (localSymbols.length === 0 || localSymbols.length % __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").length > 0) {
                 throw new Error('invalid symbol parameter');
             }
             const invalidSymbolIndex = localSymbols.findIndex((symbol, ix) => (symbol !== ifOtherSymbol
-                && !__classPrivateFieldGet$2(this, _TapeBlock_tapes, "f")[ix % __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length].alphabet.has(symbol)));
+                && !__classPrivateFieldGet$3(this, _TapeBlock_tapes, "f")[ix % __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").length].alphabet.has(symbol)));
             if (invalidSymbolIndex >= 0) {
                 throw new Error('invalid symbol parameter');
             }
             if (localSymbols.every((symbol) => symbol === ifOtherSymbol)) {
                 return ifOtherSymbol;
             }
-            return __classPrivateFieldGet$2(this, _TapeBlock_getSymbolForPatternList, "f").call(this, __classPrivateFieldGet$2(this, _TapeBlock_buildPatternList, "f").call(this, localSymbols));
+            return __classPrivateFieldGet$3(this, _TapeBlock_getSymbolForPatternList, "f").call(this, __classPrivateFieldGet$3(this, _TapeBlock_buildPatternList, "f").call(this, localSymbols));
         });
-        __classPrivateFieldSet$2(this, _TapeBlock_tapes, [], "f");
+        __classPrivateFieldSet$3(this, _TapeBlock_tapes, [], "f");
         if ('alphabets' in argument) {
             const { alphabets } = argument;
             if (alphabets.length === 0) {
                 throw new Error('empty alphabet list');
             }
-            __classPrivateFieldSet$2(this, _TapeBlock_tapes, alphabets.map((alphabet) => new Tape({
+            __classPrivateFieldSet$3(this, _TapeBlock_tapes, alphabets.map((alphabet) => new Tape({
                 alphabet,
             })), "f");
         }
         else if ('tapes' in argument) {
-            __classPrivateFieldSet$2(this, _TapeBlock_tapes, argument.tapes, "f");
+            __classPrivateFieldSet$3(this, _TapeBlock_tapes, argument.tapes, "f");
         }
-        if (__classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length === 0) {
+        if (__classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").length === 0) {
             throw new Error('empty tape list');
         }
     }
     get alphabets() {
-        return [...__classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").map((tape) => tape.alphabet)];
+        return [...__classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").map((tape) => tape.alphabet)];
     }
     get currentSymbols() {
-        return __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").map((tape) => tape.symbol);
+        return __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").map((tape) => tape.symbol);
     }
     get [(_TapeBlock_symbolToPatternListMap = new WeakMap(), _TapeBlock_lock = new WeakMap(), _TapeBlock_tapes = new WeakMap(), _TapeBlock_buildPatternList = new WeakMap(), _TapeBlock_getSymbolForPatternList = new WeakMap(), _TapeBlock_symbol = new WeakMap(), lockSymbol)]() {
-        return __classPrivateFieldGet$2(this, _TapeBlock_lock, "f");
+        return __classPrivateFieldGet$3(this, _TapeBlock_lock, "f");
     }
     get symbol() {
-        return __classPrivateFieldGet$2(this, _TapeBlock_symbol, "f").bind(this);
+        return __classPrivateFieldGet$3(this, _TapeBlock_symbol, "f").bind(this);
     }
     get tapes() {
-        return [...__classPrivateFieldGet$2(this, _TapeBlock_tapes, "f")];
+        return [...__classPrivateFieldGet$3(this, _TapeBlock_tapes, "f")];
     }
     set [symbolToPatternListMapSymbol](symbolToPatternListMap) {
-        __classPrivateFieldSet$2(this, _TapeBlock_symbolToPatternListMap, new Map(symbolToPatternListMap), "f");
+        __classPrivateFieldSet$3(this, _TapeBlock_symbolToPatternListMap, new Map(symbolToPatternListMap), "f");
     }
     applyCommand(command, executionSymbol = null) {
-        __classPrivateFieldGet$2(this, _TapeBlock_lock, "f").check(executionSymbol);
-        if (__classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length !== command.tapesCommands.length) {
+        __classPrivateFieldGet$3(this, _TapeBlock_lock, "f").check(executionSymbol);
+        if (__classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").length !== command.tapesCommands.length) {
             throw new Error('invalid command');
         }
-        __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").forEach((tape, ix) => {
+        __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").forEach((tape, ix) => {
             const { movement, symbol } = command.tapesCommands[ix];
             if (typeof symbol === 'string') {
                 tape.symbol = symbol;
@@ -640,27 +640,67 @@ class TapeBlock {
         else {
             tapeBlock = _a$1.fromAlphabets(this.alphabets);
         }
-        tapeBlock[symbolToPatternListMapSymbol] = __classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f");
+        tapeBlock[symbolToPatternListMapSymbol] = __classPrivateFieldGet$3(this, _TapeBlock_symbolToPatternListMap, "f");
         return tapeBlock;
     }
     isMatched({ currentSymbols = this.currentSymbols, symbol }) {
         if (symbol === ifOtherSymbol) {
             return true;
         }
-        if (!__classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f").has(symbol)) {
+        if (!__classPrivateFieldGet$3(this, _TapeBlock_symbolToPatternListMap, "f").has(symbol)) {
             throw new Error('invalid symbol');
         }
-        const patternList = __classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
+        const patternList = __classPrivateFieldGet$3(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
         return patternList?.some((pattern) => (pattern
             .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$3(this, _TapeBlock_tapes, "f").length;
+        if (symbol === ifOtherSymbol) {
+            return Array.from({ length: tapeCount }, () => 'wildcard');
+        }
+        const patternList = __classPrivateFieldGet$3(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) {
+        if (__classPrivateFieldGet$3(this, _TapeBlock_tapes, "f")[tapeIx] == null) {
             throw new Error('invalid tapeIx');
         }
-        if (tape.alphabet.symbols.join('') === __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f")[tapeIx].alphabet.symbols.join('')) {
-            __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f")[tapeIx] = tape;
+        if (tape.alphabet.symbols.join('') === __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f")[tapeIx].alphabet.symbols.join('')) {
+            __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f")[tapeIx] = tape;
         }
         else {
             throw new Error('invalid tape');
@@ -678,16 +718,11 @@ _TapeBlock_generateSymbolHint = { value: (patternList) => JSON.stringify(pattern
         .map((pattern) => pattern
         .map((symbol) => (symbol === ifOtherSymbol ? null : symbol)))) };
 
-// 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`
+// Graph serialization/reconstruction + state collection for State graphs.
+// Sibling-module access to State's internals uses 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`.
+// `State.toGraph` / `.fromGraph` / `.collectStates` static methods on
+// State are thin delegates to functions in this module.
 /**
  * Walks the reachable graph from `initialState` and returns a serializable
  * `Graph`. The walk is a BFS that visits each State exactly once (keyed by
@@ -789,7 +824,12 @@ function toGraph(initialState, tapeBlock) {
                     movement: decodeMovement(tc.movement.description),
                 })),
                 nextStateId: targetInternal.id,
-                id: `${stateInternal.id}-${patternIx}`,
+                // `${stateId}.${transitionIx}` — matches
+                // `MachineState.matchedTransition.id` so consumers can do
+                // `graph.nodes[stateId].transitions.find(t => t.id === id)`.
+                // `.` separator (vs `-`) avoids collision with negative
+                // halt-marker ids.
+                id: `${stateInternal.id}.${patternIx}`,
             });
             queue.push(target);
             patternIx += 1;
@@ -827,6 +867,9 @@ function toGraph(initialState, tapeBlock) {
             // `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;
             }
@@ -1071,7 +1114,8 @@ function fromGraph(graph) {
  * instance + per-pattern Symbol references for breakpoint setup (#195).
  *
  * **Positional alignment contract.** For any `GraphTransition` whose id
- * is `${N}-${K}`, `result.get(N)!.transitionSymbols[K]` is the Symbol
+ * 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.
@@ -1082,7 +1126,7 @@ function fromGraph(graph) {
  * 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
+ * `Graph.nodes[N].transitions` entry exists with id `${N}.${K}`. Sparse
  * on the Graph side, dense on the `transitionSymbols` side — same
  * indexing.
  *
@@ -1170,7 +1214,7 @@ function collectStates(initialState, tapeBlock) {
         }
         // 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).
+        // `${id}.${K}` GraphTransition fires on (positional contract).
         const state = stateById.get(id);
         const transitionSymbols = [...state[STATE_INTERNAL]().symbolToDataMap.keys()];
         result.set(id, { state, transitionSymbols });
@@ -1185,18 +1229,18 @@ function collectStates(initialState, tapeBlock) {
 // 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) {
+var __classPrivateFieldSet$2 = (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");
     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$1 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$2 = (undefined && undefined.__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 _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.
@@ -1228,7 +1272,7 @@ class DebugConfig {
         _DebugConfig_ownerState.set(this, void 0);
         _DebugConfig_before.set(this, void 0);
         _DebugConfig_after.set(this, void 0);
-        __classPrivateFieldSet$1(this, _DebugConfig_ownerState, ownerState, "f");
+        __classPrivateFieldSet$2(this, _DebugConfig_ownerState, ownerState, "f");
         if (initial) {
             if (initial.before !== undefined) {
                 this.before = initial.before;
@@ -1245,23 +1289,24 @@ class DebugConfig {
         Object.seal(this);
     }
     get before() {
-        return __classPrivateFieldGet$1(this, _DebugConfig_before, "f");
+        return __classPrivateFieldGet$2(this, _DebugConfig_before, "f");
     }
     set before(v) {
-        __classPrivateFieldGet$1(this, _DebugConfig_ownerState, "f")[validateDebugFilter]('before', v);
-        __classPrivateFieldSet$1(this, _DebugConfig_before, Array.isArray(v) ? Object.freeze([...v]) : v, "f");
+        __classPrivateFieldGet$2(this, _DebugConfig_ownerState, "f")[validateDebugFilter]('before', v);
+        __classPrivateFieldSet$2(this, _DebugConfig_before, Array.isArray(v) ? Object.freeze([...v]) : v, "f");
     }
     get after() {
-        return __classPrivateFieldGet$1(this, _DebugConfig_after, "f");
+        return __classPrivateFieldGet$2(this, _DebugConfig_after, "f");
     }
     set after(v) {
-        __classPrivateFieldGet$1(this, _DebugConfig_ownerState, "f")[validateDebugFilter]('after', v);
-        __classPrivateFieldSet$1(this, _DebugConfig_after, Array.isArray(v) ? Object.freeze([...v]) : v, "f");
+        __classPrivateFieldGet$2(this, _DebugConfig_ownerState, "f")[validateDebugFilter]('after', v);
+        __classPrivateFieldSet$2(this, _DebugConfig_after, Array.isArray(v) ? Object.freeze([...v]) : v, "f");
     }
 }
 _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
@@ -1270,8 +1315,8 @@ class State {
         _State_overriddenHaltState.set(this, null);
         // For wrapper states (produced by `withOverriddenHaltState`), points at the
         // State whose transition map was wrapped. `null` on bare/atomic states.
-        // Used by `toGraph` to collapse the wrapper-and-its-bare pair into a single
-        // "wrapped bare" graph node — see the v7 emit redesign for #138.
+        // `toGraph` reads this to render wrapper and bare as separate nodes linked
+        // by a `==> call` arrow.
         _State_bareState.set(this, null);
         _State_symbolToDataMap.set(this, new Map());
         // Shared mutable cell — withOverriddenHaltState wrappers reference the same
@@ -1279,6 +1324,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;
@@ -1290,11 +1343,11 @@ class State {
         if (stateDefinition) {
             const keys = Object.getOwnPropertyNames(stateDefinition);
             if (keys.length) {
-                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet$1(this, _State_id, "f")}`);
+                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet$2(this, _State_id, "f")}`);
             }
             const symbols = Object.getOwnPropertySymbols(stateDefinition);
             if (symbols.length === 0) {
-                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet$1(this, _State_id, "f")}`);
+                throw new Error(`invalid state definition while constructing state #${__classPrivateFieldGet$2(this, _State_id, "f")}`);
             }
             symbols.forEach((symbol) => {
                 const { nextState } = stateDefinition[symbol];
@@ -1322,7 +1375,7 @@ class State {
                 if (!(commandLocal instanceof Command)) {
                     throw new Error('invalid command');
                 }
-                __classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").set(symbol, {
+                __classPrivateFieldGet$2(this, _State_symbolToDataMap, "f").set(symbol, {
                     command: commandLocal,
                     nextState: nextStateLocal,
                 });
@@ -1331,44 +1384,86 @@ class State {
         if (name !== undefined && /[()]/.test(name)) {
             throw new Error(`invalid state name "${name}": must not contain '(' or ')' (reserved as wrapper-composition delimiters in withOverriddenHaltState)`);
         }
-        __classPrivateFieldSet$1(this, _State_name, name ?? `id:${__classPrivateFieldGet$1(this, _State_id, "f")}`, "f");
+        __classPrivateFieldSet$2(this, _State_name, name ?? `id:${__classPrivateFieldGet$2(this, _State_id, "f")}`, "f");
     }
     get id() {
-        return __classPrivateFieldGet$1(this, _State_id, "f");
+        return __classPrivateFieldGet$2(this, _State_id, "f");
     }
     get name() {
-        return __classPrivateFieldGet$1(this, _State_name, "f");
+        return __classPrivateFieldGet$2(this, _State_name, "f");
     }
     get isHalt() {
-        return __classPrivateFieldGet$1(this, _State_id, "f") === 0;
+        return __classPrivateFieldGet$2(this, _State_id, "f") === 0;
     }
     get overriddenHaltState() {
-        return __classPrivateFieldGet$1(this, _State_overriddenHaltState, "f");
+        return __classPrivateFieldGet$2(this, _State_overriddenHaltState, "f");
     }
     get ref() {
         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$2(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
         // filters; the next read recreates a fresh empty `DebugConfig` on demand.
         // See #150.
-        if (__classPrivateFieldGet$1(this, _State_debugRef, "f").current === null) {
-            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = new DebugConfig(this);
+        if (__classPrivateFieldGet$2(this, _State_debugRef, "f").current === null) {
+            __classPrivateFieldGet$2(this, _State_debugRef, "f").current = new DebugConfig(this);
         }
-        return __classPrivateFieldGet$1(this, _State_debugRef, "f").current;
+        return __classPrivateFieldGet$2(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) {
-            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = 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$2(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$2(this, _State_debugRef, "f").current = null;
             return;
         }
-        if (value instanceof DebugConfig) {
-            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = value;
+        if (v instanceof DebugConfig) {
+            __classPrivateFieldGet$2(this, _State_debugRef, "f").current = v;
             return;
         }
-        __classPrivateFieldGet$1(this, _State_debugRef, "f").current = new DebugConfig(this, value);
+        __classPrivateFieldGet$2(this, _State_debugRef, "f").current = new DebugConfig(this, v);
     }
     /**
      * Add one or more tags to this State (#186). Tags are out-of-band metadata
@@ -1378,7 +1473,7 @@ class State {
      */
     tag(...tags) {
         for (const t of tags) {
-            __classPrivateFieldGet$1(this, _State_tags, "f").add(t);
+            __classPrivateFieldGet$2(this, _State_tags, "f").add(t);
         }
         return this;
     }
@@ -1388,7 +1483,7 @@ class State {
      */
     untag(...tags) {
         for (const t of tags) {
-            __classPrivateFieldGet$1(this, _State_tags, "f").delete(t);
+            __classPrivateFieldGet$2(this, _State_tags, "f").delete(t);
         }
         return this;
     }
@@ -1398,37 +1493,26 @@ class State {
      * code uses). Order matches insertion order of the underlying Set.
      */
     get tags() {
-        return Object.freeze([...__classPrivateFieldGet$1(this, _State_tags, "f")]);
+        return Object.freeze([...__classPrivateFieldGet$2(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.
+     *  haltState's `debug` setter rejects object writes before reaching
+     *  DebugConfig, so this validator only sees non-halt states. */
+    [(_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)) {
+            if (sym !== ifOtherSymbol && !__classPrivateFieldGet$2(this, _State_symbolToDataMap, "f").has(sym)) {
                 throw new Error(`State.debug.${fieldName}: symbol is not a transition key of this state `
-                    + `(state name: ${__classPrivateFieldGet$1(this, _State_name, "f")}). Common cause: symbol comes from a `
+                    + `(state name: ${__classPrivateFieldGet$2(this, _State_name, "f")}). Common cause: symbol comes from a `
                     + 'different tape block, or doesn\'t match any of this state\'s transitions.');
             }
         }
     }
     getSymbol(tapeBlock) {
-        const symbol = [...__classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").keys()].find((currentSymbol) => tapeBlock.isMatched({
+        const symbol = [...__classPrivateFieldGet$2(this, _State_symbolToDataMap, "f").keys()].find((currentSymbol) => tapeBlock.isMatched({
             symbol: currentSymbol,
         }));
         if (symbol) {
@@ -1437,29 +1521,53 @@ 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$2(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$2(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$2(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$2(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
         // are dead at runtime anyway (only the outermost `.wohs()`'s override is
         // pushed onto the halt-stack on entry; verified empirically). Composite
         // name reflects runtime behavior, not construction history. See #176.
-        const bare = __classPrivateFieldGet$1(this, _State_bareState, "f") ?? this;
+        const bare = __classPrivateFieldGet$2(this, _State_bareState, "f") ?? this;
         // Memoize by (bare, override) so identical args return the same instance
         // (#175). The cache uses WeakMaps + WeakRefs so cached wrappers can be
         // GC'd when nothing else holds them. Compounds with the chain-collapse
         // above: `A.wohs(t1).wohs(t2)` keys as (A, t2) after the unwrap, hitting
         // the same cache slot as a direct `A.wohs(t2)`.
-        let innerCache = __classPrivateFieldGet$1(_a, _a, "f", _State_wrapperCache).get(bare);
+        let innerCache = __classPrivateFieldGet$2(_a, _a, "f", _State_wrapperCache).get(bare);
         if (innerCache !== undefined) {
             const ref = innerCache.get(overriddenHaltState);
             if (ref !== undefined) {
@@ -1471,17 +1579,17 @@ class State {
         }
         else {
             innerCache = new WeakMap();
-            __classPrivateFieldGet$1(_a, _a, "f", _State_wrapperCache).set(bare, innerCache);
+            __classPrivateFieldGet$2(_a, _a, "f", _State_wrapperCache).set(bare, innerCache);
         }
         // Cache miss — construct with no name, then overwrite #name directly
         // (composed names contain `(` and `)` which the constructor's user-facing
         // validation would reject; private-field access bypasses that).
         const state = new _a();
-        __classPrivateFieldSet$1(state, _State_name, `${bare.name}(${overriddenHaltState.name})`, "f");
-        __classPrivateFieldSet$1(state, _State_symbolToDataMap, __classPrivateFieldGet$1(bare, _State_symbolToDataMap, "f"), "f");
-        __classPrivateFieldSet$1(state, _State_overriddenHaltState, overriddenHaltState, "f");
-        __classPrivateFieldSet$1(state, _State_debugRef, __classPrivateFieldGet$1(bare, _State_debugRef, "f"), "f");
-        __classPrivateFieldSet$1(state, _State_bareState, bare, "f");
+        __classPrivateFieldSet$2(state, _State_name, `${bare.name}(${overriddenHaltState.name})`, "f");
+        __classPrivateFieldSet$2(state, _State_symbolToDataMap, __classPrivateFieldGet$2(bare, _State_symbolToDataMap, "f"), "f");
+        __classPrivateFieldSet$2(state, _State_overriddenHaltState, overriddenHaltState, "f");
+        __classPrivateFieldSet$2(state, _State_debugRef, __classPrivateFieldGet$2(bare, _State_debugRef, "f"), "f");
+        __classPrivateFieldSet$2(state, _State_bareState, bare, "f");
         innerCache.set(overriddenHaltState, new WeakRef(state));
         return state;
     }
@@ -1509,7 +1617,13 @@ class State {
      * read what they need. Adding fields here is a deliberate decision —
      * each adds to the implicit contract sibling modules can rely on.
      */
-    [STATE_INTERNAL]() {
+    [(_State_getEntry = function _State_getEntry(symbol) {
+        const entry = __classPrivateFieldGet$2(this, _State_symbolToDataMap, "f").get(symbol);
+        if (entry === undefined) {
+            throw new Error(`No transition for symbol at state named ${__classPrivateFieldGet$2(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-
@@ -1517,13 +1631,13 @@ class State {
         // 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"); },
+            get id() { return __classPrivateFieldGet$2(self, _State_id, "f"); },
+            get name() { return __classPrivateFieldGet$2(self, _State_name, "f"); },
+            set name(v) { __classPrivateFieldSet$2(self, _State_name, v, "f"); },
+            get bareState() { return __classPrivateFieldGet$2(self, _State_bareState, "f"); },
+            get overriddenHaltState() { return __classPrivateFieldGet$2(self, _State_overriddenHaltState, "f"); },
+            get symbolToDataMap() { return __classPrivateFieldGet$2(self, _State_symbolToDataMap, "f"); },
+            get tags() { return __classPrivateFieldGet$2(self, _State_tags, "f"); },
         };
     }
     // Single-state introspection — no traversal, no tapeBlock required.
@@ -1533,7 +1647,7 @@ class State {
     // interned JS Symbol (decode via decodePatternDescription if needed).
     static inspect(state) {
         const transitions = [];
-        for (const [sym, { command, nextState }] of __classPrivateFieldGet$1(state, _State_symbolToDataMap, "f")) {
+        for (const [sym, { command, nextState }] of __classPrivateFieldGet$2(state, _State_symbolToDataMap, "f")) {
             let target = null;
             try {
                 target = nextState instanceof _a ? nextState : nextState.ref;
@@ -1551,11 +1665,11 @@ class State {
             });
         }
         return {
-            id: __classPrivateFieldGet$1(state, _State_id, "f"),
-            name: __classPrivateFieldGet$1(state, _State_name, "f"),
+            id: __classPrivateFieldGet$2(state, _State_id, "f"),
+            name: __classPrivateFieldGet$2(state, _State_name, "f"),
             isHalt: state.isHalt,
-            overriddenHaltState: __classPrivateFieldGet$1(state, _State_overriddenHaltState, "f")
-                ? { id: __classPrivateFieldGet$1(state, _State_overriddenHaltState, "f").id, name: __classPrivateFieldGet$1(state, _State_overriddenHaltState, "f").name }
+            overriddenHaltState: __classPrivateFieldGet$2(state, _State_overriddenHaltState, "f")
+                ? { id: __classPrivateFieldGet$2(state, _State_overriddenHaltState, "f").id, name: __classPrivateFieldGet$2(state, _State_overriddenHaltState, "f").name }
                 : null,
             transitions,
         };
@@ -1601,20 +1715,37 @@ _a = State;
 _State_wrapperCache = { value: new WeakMap() };
 const haltState = new State(null);
 
-var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$1 = (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");
     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 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$1 = (undefined && undefined.__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 _TuringMachine_tapeBlock;
-// True iff `filter` matches `symbol` per the DebugConfig semantics.
-// undefined / [] -> never; true -> always; symbol[] -> exact membership.
+/**
+ * @internal — package-private accessor key for `MachineState` instances yielded
+ * by `runStepByStep`. Calling `machineState[MACHINE_STATE_INTERNAL]()` returns a
+ * frozen snapshot of the engine's halt-stack at yield time (BEFORE this iter's
+ * applyCommand / pop / push). Consumed by `DebugSession` for step-over /
+ * step-out endpoint detection without exposing the stack to public API.
+ *
+ * Re-exported from this module so the sibling `DebugSession` module can import
+ * it; intentionally NOT re-exported from the package's public `index.ts` —
+ * downstream consumers shouldn't reach for the stack. Same pattern as
+ * `STATE_INTERNAL` (#180).
+ */
+const MACHINE_STATE_INTERNAL = Symbol('MachineState.internal');
+/**
+ * @internal — true iff `filter` matches `symbol` per the DebugConfig semantics.
+ * undefined / [] -> never; true -> always; symbol[] -> exact membership.
+ * Exported for sibling-module use in `DebugSession` (which now owns breakpoint
+ * detection); NOT re-exported from the package's public `index.ts`.
+ */
 function matchFilter(filter, symbol) {
     if (filter === undefined)
         return false;
@@ -1628,43 +1759,42 @@ class TuringMachine {
         if (!tapeBlock) {
             throw new Error('invalid tapeBlock');
         }
-        __classPrivateFieldSet(this, _TuringMachine_tapeBlock, tapeBlock, "f");
+        __classPrivateFieldSet$1(this, _TuringMachine_tapeBlock, tapeBlock, "f");
     }
     get tapeBlock() {
-        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f");
-    }
-    async run({ initialState, stepsLimit = 1e5, onStep, onPause, onIter, debug = true, }) {
-        const generator = this.runStepByStep({ initialState, stepsLimit });
-        for (const machineState of generator) {
-            // Per-iter lifecycle: before → step → after. All three operate on the
-            // same yielded MachineState, so the consumer sees a coherent ordering
-            // within each iteration without cross-tick coordination.
-            if (debug && machineState.debugBreak?.before && onPause) {
-                await onPause({ ...machineState, debugBreak: { before: true } });
-            }
-            if (onStep) {
-                onStep(machineState);
-            }
-            if (debug && machineState.debugBreak?.after && onPause) {
-                await onPause({ ...machineState, debugBreak: { after: true } });
-            }
-            if (onIter) {
-                await onIter(machineState);
-            }
+        return __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f");
+    }
+    /**
+     * Run the machine to halt. Pure execution — synchronous, no observation
+     * callbacks, no debug overhead. For breakpoint-driven interactive debugging
+     * use `DebugSession`; for per-iter tracing use `runStepByStep`'s generator
+     * directly.
+     *
+     * Breakpoint metadata (`state.debug` / `haltState.debug` matches) is still
+     * resolved and attached to each yielded MachineState by the underlying
+     * generator — `run()` simply doesn't dispatch on it. A consumer that wants
+     * to dispatch on it constructs a `DebugSession` instead.
+     *
+     * Symmetric reversal of v4's `run` → `async run` change: v4 made the method
+     * async to support awaited `onPause`; with callbacks moved to `DebugSession`
+     * there's no async work left, so the method returns `void` again.
+     */
+    run({ initialState, stepsLimit = 1e5 }) {
+        // Drain the generator. We don't care about the yielded values — the
+        // generator's job is to advance the tape; only side effects matter here.
+        // Casting to unknown so eslint doesn't flag the unused `_` variable.
+        for (const machineState of this.runStepByStep({ initialState, stepsLimit })) {
         }
     }
     *runStepByStep({ initialState, stepsLimit = 1e5 }) {
         const executionSymbol = Symbol('execution');
         try {
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].check(executionSymbol);
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].lock(executionSymbol);
-            // 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.
+            __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f")[lockSymbol].check(executionSymbol);
+            __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f")[lockSymbol].lock(executionSymbol);
+            // Halt-stack is run-scoped, not machine-scoped (#196) — local
+            // declaration prevents leftover entries from a previous
+            // `runStepByStep` call (e.g. a build-time peek that never drained
+            // the generator) from leaking into a subsequent halt-bound transition.
             const stack = [];
             let state = initialState;
             if (state.overriddenHaltState) {
@@ -1676,30 +1806,43 @@ class TuringMachine {
                     throw new Error('Long execution');
                 }
                 i += 1;
-                const symbol = state.getSymbol(__classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f"));
+                const symbol = state.getSymbol(__classPrivateFieldGet$1(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$1(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);
+                    // `runStepByStep` is the minimal execution primitive: it advances the
+                    // machine and reports state. It does NO breakpoint detection — that's
+                    // a debug concern that lives entirely in `DebugSession`. The yielded
+                    // `MachineState` has no `pause` / `debugBreak` field.
                     const nextStateForYield = nextState.isHalt && stack.length
                         ? stack.slice(-1)[0]
                         : nextState;
                     const yielded = {
                         step: i,
                         state,
-                        currentSymbols: __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").currentSymbols,
+                        currentSymbols: __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f").currentSymbols,
                         nextSymbols: command.tapesCommands.map((tapeCommand, ix) => {
                             if (typeof tapeCommand.symbol === 'symbol') {
                                 switch (tapeCommand.symbol) {
                                     case symbolCommands.erase:
-                                        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].alphabet.blankSymbol;
+                                        return __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f").tapes[ix].alphabet.blankSymbol;
                                     case symbolCommands.keep:
-                                        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].symbol;
+                                        return __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f").tapes[ix].symbol;
                                     default:
                                         throw new Error('invalid symbol command');
                                 }
@@ -1708,17 +1851,26 @@ class TuringMachine {
                         }),
                         movements: command.tapesCommands.map((tapeCommand) => tapeCommand.movement),
                         nextState: nextStateForYield,
+                        matchedTransition,
                     };
-                    if (beforeMatch || afterMatch) {
-                        const dbg = {};
-                        if (beforeMatch)
-                            dbg.before = true;
-                        if (afterMatch)
-                            dbg.after = true;
-                        yielded.debugBreak = dbg;
-                    }
+                    // #102: expose the pre-iter halt-stack + the matched symbol to
+                    // DebugSession via a Symbol-keyed accessor (non-enumerable, so it
+                    // doesn't leak into serialization / spread / toEqual). The stack
+                    // snapshot is frozen so a consumer holding a reference can't mutate
+                    // the engine's stack. DebugSession reads `matchedSymbol` to evaluate
+                    // `state.debug` filters — keeping breakpoint detection out of this
+                    // primitive.
+                    const stackSnapshot = Object.freeze(stack.slice());
+                    // Snapshot halt-imminence on the RAW nextState NOW, before the
+                    // post-yield pop reassigns `nextState` — so the closure can't capture
+                    // the mutated value.
+                    const haltImminent = nextState === haltState;
+                    Object.defineProperty(yielded, MACHINE_STATE_INTERNAL, {
+                        value: () => ({ stack: stackSnapshot, matchedSymbol: symbol, haltImminent }),
+                        enumerable: false,
+                    });
                     yield yielded;
-                    __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").applyCommand(command, executionSymbol);
+                    __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f").applyCommand(command, executionSymbol);
                     if (nextState.isHalt && stack.length) {
                         nextState = stack.pop();
                     }
@@ -1736,12 +1888,312 @@ class TuringMachine {
             }
         }
         finally {
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].unlock(executionSymbol);
+            __classPrivateFieldGet$1(this, _TuringMachine_tapeBlock, "f")[lockSymbol].unlock(executionSymbol);
         }
     }
 }
 _TuringMachine_tapeBlock = new WeakMap();
 
+var __classPrivateFieldSet = (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");
+    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 = (undefined && undefined.__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 _DebugSession_instances, _DebugSession_machine, _DebugSession_parameter, _DebugSession_listeners, _DebugSession_started, _DebugSession_stopped, _DebugSession_iterating, _DebugSession_pauseResolver, _DebugSession_activeStepMode, _DebugSession_capturedDepth, _DebugSession_clickTimeDepth, _DebugSession_runIntervalMs, _DebugSession_pauseRequested, _DebugSession_releasePause, _DebugSession_dispatchPause, _DebugSession_readInternal, _DebugSession_readStack, _DebugSession_drive;
+/**
+ * Interactive debugger session for `TuringMachine`. Owns the coordination
+ * layer that every UI debugger / IDE extension / educational demo would
+ * otherwise reimplement: breakpoint dispatch, step-in / step-over / step-out,
+ * click-pause from outside, per-iter throttle, pause/resume promise plumbing.
+ *
+ * Construction is direct — the engine class stays minimal and doesn't expose a
+ * `debugRun()` factory; consumers import both classes and write
+ * `new DebugSession(machine, {initialState})`.
+ *
+ * Lifecycle:
+ *   const session = new DebugSession(machine, {initialState});
+ *   session.on('pause', (m) => { ...; session.continue(); });
+ *   session.on('halt', () => { ... });
+ *   await session.start();           // resolves on natural halt or stop()
+ *
+ * Each session is single-use: `start()` may only be called once. Construct a
+ * fresh session to re-run.
+ */
+class DebugSession {
+    constructor(machine, parameter) {
+        _DebugSession_instances.add(this);
+        _DebugSession_machine.set(this, void 0);
+        _DebugSession_parameter.set(this, void 0);
+        _DebugSession_listeners.set(this, {
+            pause: [],
+            step: [],
+            iter: [],
+            halt: [],
+        });
+        _DebugSession_started.set(this, false);
+        _DebugSession_stopped.set(this, false);
+        _DebugSession_iterating.set(this, false);
+        _DebugSession_pauseResolver.set(this, null);
+        _DebugSession_activeStepMode.set(this, null);
+        /**
+         * Halt-stack DEPTH snapshotted at the most recent pause dispatch (= number
+         * of frames on the stack). DevTools-style step granularity is depth-based:
+         * stepOver pauses at the next iter with `depth <= clickTimeDepth` (skip
+         * frames the stepped-over iter pushes, pause back at the start level);
+         * stepOut at `depth < clickTimeDepth` (the current frame itself exited).
+         * Captured on EVERY pause so a step* call from the listener can freeze it.
+         */
+        _DebugSession_capturedDepth.set(this, 0);
+        /** The click-time depth frozen when a stepOver / stepOut directive is issued. */
+        _DebugSession_clickTimeDepth.set(this, 0);
+        _DebugSession_runIntervalMs.set(this, 0);
+        _DebugSession_pauseRequested.set(this, false);
+        __classPrivateFieldSet(this, _DebugSession_machine, machine, "f");
+        __classPrivateFieldSet(this, _DebugSession_parameter, parameter, "f");
+    }
+    on(event, listener) {
+        __classPrivateFieldGet(this, _DebugSession_listeners, "f")[event].push(listener);
+        return this;
+    }
+    off(event, listener) {
+        const arr = __classPrivateFieldGet(this, _DebugSession_listeners, "f")[event];
+        const ix = arr.indexOf(listener);
+        if (ix >= 0)
+            arr.splice(ix, 1);
+        return this;
+    }
+    stop() {
+        __classPrivateFieldSet(this, _DebugSession_stopped, true, "f");
+        __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_releasePause).call(this);
+    }
+    /**
+     * Request a pause from outside the run loop. The pause fires on the next
+     * iter's before-side with `cause: 'manual'`. If a breakpoint matches that
+     * same iter, the breakpoint takes precedence and the request is consumed
+     * silently (one pause, cause: 'breakpoint').
+     *
+     * No-op if the session is already paused — the next `continue` / step call
+     * resumes normal execution, then the flag fires on the iter AFTER that.
+     * Equivalent to a debouncing one-shot.
+     */
+    pause() {
+        __classPrivateFieldSet(this, _DebugSession_pauseRequested, true, "f");
+    }
+    /**
+     * Set the per-iter throttle delay in milliseconds. After each iter (including
+     * any pause + step + iter listeners on that iter), the loop awaits
+     * `setTimeout(ms)` before proceeding to the next iter. `0` disables the
+     * throttle.
+     *
+     * Useful for visualization UIs that want to animate execution at a fixed
+     * pace. Updates take effect on the next iter.
+     */
+    setRunInterval(ms) {
+        if (!Number.isFinite(ms) || ms < 0) {
+            throw new Error(`DebugSession.setRunInterval(${ms}): expected a non-negative finite number.`);
+        }
+        __classPrivateFieldSet(this, _DebugSession_runIntervalMs, ms, "f");
+    }
+    /**
+     * Resume from the current pause, returning to normal execution until the
+     * next breakpoint or natural halt. No-op when called outside of a paused
+     * state.
+     */
+    continue() {
+        __classPrivateFieldSet(this, _DebugSession_activeStepMode, null, "f");
+        __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_releasePause).call(this);
+    }
+    /**
+     * Resume and force a pause on the next iter regardless of whether that
+     * iter's `state.debug` filter matches. Step-mode is one-shot: any
+     * subsequent pause dispatch (this step-in's endpoint, an inner
+     * breakpoint, or a manual pause) drops it. To keep stepping, call
+     * stepIn() again from the new pause.
+     */
+    stepIn() {
+        __classPrivateFieldSet(this, _DebugSession_activeStepMode, 'step-in', "f");
+        __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_releasePause).call(this);
+    }
+    /**
+     * Resume and pause at the next iter back at (or above) the click-time depth
+     * — i.e. `depth <= clickTimeDepth`. Frames the stepped-over iter pushes are
+     * run to completion without pausing inside (the engine's continuation-passing
+     * `withOverriddenHaltState` "calls"). Mirrors DevTools Step Over.
+     *
+     * For a plain iter (no frame push) this coincides with stepIn (next iter is
+     * already at the same depth). The Over-vs-In / Over-vs-Out distinction only
+     * appears under genuine nesting (a bare that itself enters a wrapper).
+     *
+     * One-shot: an inner breakpoint or any other pause drops the step-over
+     * intent. The endpoint pause carries `cause: 'step'`.
+     */
+    stepOver() {
+        __classPrivateFieldSet(this, _DebugSession_activeStepMode, 'step-over', "f");
+        __classPrivateFieldSet(this, _DebugSession_clickTimeDepth, __classPrivateFieldGet(this, _DebugSession_capturedDepth, "f"), "f");
+        __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_releasePause).call(this);
+    }
+    /**
+     * Resume and pause at the next iter STRICTLY shallower than the click-time
+     * depth — `depth < clickTimeDepth` — i.e. once the current frame itself has
+     * been popped. Mirrors DevTools Step Out.
+     *
+     * Throws when the click-time depth is 0: there's no enclosing frame to exit
+     * (IDE convention — "step out of nothing" is a programming error, not a
+     * silent no-op).
+     */
+    stepOut() {
+        if (__classPrivateFieldGet(this, _DebugSession_capturedDepth, "f") === 0) {
+            throw new Error('DebugSession.stepOut() called with an empty click-time halt-stack — there is no enclosing frame to exit.');
+        }
+        __classPrivateFieldSet(this, _DebugSession_activeStepMode, 'step-out', "f");
+        __classPrivateFieldSet(this, _DebugSession_clickTimeDepth, __classPrivateFieldGet(this, _DebugSession_capturedDepth, "f"), "f");
+        __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_releasePause).call(this);
+    }
+    async start() {
+        if (__classPrivateFieldGet(this, _DebugSession_started, "f")) {
+            throw new Error('DebugSession.start() has already been called; construct a fresh session to re-run.');
+        }
+        __classPrivateFieldSet(this, _DebugSession_started, true, "f");
+        try {
+            await __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_drive).call(this);
+        }
+        catch (error) {
+            // `runStepByStep` acquires the TapeBlock lock at its first advance. If
+            // another DebugSession (or a bare `run()`) is already active on this
+            // machine, that acquisition throws the low-level 'Lock check failed'.
+            // Remap it to a message that names the real cause. The `#iterating`
+            // guard scopes the remap to the startup acquisition only — once we hold
+            // the lock and are iterating, a same-named error can't originate here.
+            if (!__classPrivateFieldGet(this, _DebugSession_iterating, "f") && error instanceof Error && error.message === 'Lock check failed') {
+                throw new Error('Cannot start this DebugSession: a run is already in progress on this machine. '
+                    + 'Only one DebugSession or run() may be active on a TuringMachine at a time — '
+                    + 'stop the active session (or let it halt) before starting another.');
+            }
+            throw error;
+        }
+    }
+}
+_DebugSession_machine = new WeakMap(), _DebugSession_parameter = new WeakMap(), _DebugSession_listeners = new WeakMap(), _DebugSession_started = new WeakMap(), _DebugSession_stopped = new WeakMap(), _DebugSession_iterating = new WeakMap(), _DebugSession_pauseResolver = new WeakMap(), _DebugSession_activeStepMode = new WeakMap(), _DebugSession_capturedDepth = new WeakMap(), _DebugSession_clickTimeDepth = new WeakMap(), _DebugSession_runIntervalMs = new WeakMap(), _DebugSession_pauseRequested = new WeakMap(), _DebugSession_instances = new WeakSet(), _DebugSession_releasePause = function _DebugSession_releasePause() {
+    const resolver = __classPrivateFieldGet(this, _DebugSession_pauseResolver, "f");
+    if (resolver) {
+        __classPrivateFieldSet(this, _DebugSession_pauseResolver, null, "f");
+        resolver();
+    }
+}, _DebugSession_dispatchPause = 
+/**
+ * Emit a `pause` event with the synthesized pause descriptor and await the
+ * consumer's resume signal. Resolver is installed BEFORE listeners fire so a listener
+ * that synchronously calls `session.continue()` (or any other resume method)
+ * sees a live resolver to drop.
+ *
+ * One-shot rule: any pause dispatch (step-mode endpoint, inner breakpoint,
+ * manual pause) drops the active step-mode BEFORE listeners fire. Listeners
+ * that want to keep stepping must call stepIn/Over/Out from the new pause.
+ *
+ * The pre-iter halt-stack DEPTH is snapshotted into `#capturedDepth` so a
+ * `stepOver` / `stepOut` issued from inside the listener can freeze it as
+ * the click-time depth.
+ */
+async function _DebugSession_dispatchPause(machineState, pause) {
+    __classPrivateFieldSet(this, _DebugSession_activeStepMode, null, "f");
+    __classPrivateFieldSet(this, _DebugSession_capturedDepth, __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_readStack).call(this, machineState).length, "f");
+    // Note: the spread drops the non-enumerable MACHINE_STATE_INTERNAL Symbol
+    // accessor — that's intentional. Pause listeners are public API; the
+    // Symbol accessor is package-private and only consumed by the session's
+    // OWN detection (which reads the original `machineState` via #readInternal).
+    const paused = { ...machineState, pause };
+    const pausePromise = new Promise((resolve) => {
+        __classPrivateFieldSet(this, _DebugSession_pauseResolver, resolve, "f");
+    });
+    for (const fn of __classPrivateFieldGet(this, _DebugSession_listeners, "f").pause) {
+        void fn(paused);
+    }
+    await pausePromise;
+}, _DebugSession_readInternal = function _DebugSession_readInternal(machineState) {
+    const fn = machineState[MACHINE_STATE_INTERNAL];
+    return typeof fn === 'function' ? fn() : null;
+}, _DebugSession_readStack = function _DebugSession_readStack(machineState) {
+    return __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_readInternal).call(this, machineState)?.stack ?? [];
+}, _DebugSession_drive = async function _DebugSession_drive() {
+    for (const machineState of __classPrivateFieldGet(this, _DebugSession_machine, "f").runStepByStep(__classPrivateFieldGet(this, _DebugSession_parameter, "f"))) {
+        __classPrivateFieldSet(this, _DebugSession_iterating, true, "f");
+        if (__classPrivateFieldGet(this, _DebugSession_stopped, "f"))
+            return;
+        // Breakpoint detection lives HERE (not in the generator). Evaluate the
+        // current state's debug filters against the matched symbol the generator
+        // stashed in the internal accessor. `machineState.state` is always
+        // non-halt (halt is terminal), so `.debug` is a DebugConfig at runtime.
+        // The after side also fires on halt-imminent (`haltState.debug`, #207) —
+        // read via the internal flag, since the yielded `nextState` shows the
+        // post-pop continuation on subroutine-return iters, not haltState.
+        const internal = __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_readInternal).call(this, machineState);
+        const matchedSymbol = internal?.matchedSymbol;
+        const hasBeforeBreakpoint = matchedSymbol !== undefined
+            && matchFilter(machineState.state.debug?.before, matchedSymbol);
+        const hasAfterBreakpoint = (matchedSymbol !== undefined
+            && matchFilter(machineState.state.debug?.after, matchedSymbol))
+            || (internal?.haltImminent === true && haltState.debug === true);
+        const stepInForcesPause = __classPrivateFieldGet(this, _DebugSession_activeStepMode, "f") === 'step-in';
+        // Depth-based endpoints (DevTools semantics). currentDepth = pre-iter
+        // halt-stack length. stepOver: back at/above click-time depth (skip
+        // pushed frames). stepOut: strictly shallower (current frame exited).
+        const currentDepth = __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_readStack).call(this, machineState).length;
+        const stepOverEndpointReached = __classPrivateFieldGet(this, _DebugSession_activeStepMode, "f") === 'step-over' && currentDepth <= __classPrivateFieldGet(this, _DebugSession_clickTimeDepth, "f");
+        const stepOutEndpointReached = __classPrivateFieldGet(this, _DebugSession_activeStepMode, "f") === 'step-out' && currentDepth < __classPrivateFieldGet(this, _DebugSession_clickTimeDepth, "f");
+        // Consume the manual-pause flag at iter start. If a breakpoint also
+        // matches this iter, the request is silently consumed by the
+        // breakpoint dispatch (one pause, cause: 'breakpoint').
+        const manualPauseFires = __classPrivateFieldGet(this, _DebugSession_pauseRequested, "f");
+        if (manualPauseFires)
+            __classPrivateFieldSet(this, _DebugSession_pauseRequested, false, "f");
+        // Before-side pause: fires if any of breakpoint / step-mode endpoint /
+        // manual request is true. Precedence: breakpoint > step > manual.
+        const fireBeforePause = hasBeforeBreakpoint || stepInForcesPause || stepOverEndpointReached || stepOutEndpointReached || manualPauseFires;
+        if (fireBeforePause) {
+            const cause = hasBeforeBreakpoint ? 'breakpoint'
+                : (stepInForcesPause || stepOverEndpointReached || stepOutEndpointReached) ? 'step'
+                    : 'manual';
+            await __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_dispatchPause).call(this, machineState, { side: 'before', cause });
+            if (__classPrivateFieldGet(this, _DebugSession_stopped, "f"))
+                return;
+        }
+        // step: fires once per iter, after any before-pause and before any after-pause.
+        for (const fn of __classPrivateFieldGet(this, _DebugSession_listeners, "f").step) {
+            void fn(machineState);
+        }
+        if (hasAfterBreakpoint) {
+            await __classPrivateFieldGet(this, _DebugSession_instances, "m", _DebugSession_dispatchPause).call(this, machineState, { side: 'after', cause: 'breakpoint' });
+            if (__classPrivateFieldGet(this, _DebugSession_stopped, "f"))
+                return;
+        }
+        // iter: end-of-iter, after both before- and after-pause have fired.
+        // Listeners are AWAITED (sequenced, blocking the engine) — matches the
+        // v6 `onIter` contract that downstream consumers rely on for
+        // throttle / per-iter coordination / step-boundary synthesis.
+        for (const fn of __classPrivateFieldGet(this, _DebugSession_listeners, "f").iter) {
+            await fn(machineState);
+        }
+        if (__classPrivateFieldGet(this, _DebugSession_stopped, "f"))
+            return;
+        if (__classPrivateFieldGet(this, _DebugSession_runIntervalMs, "f") > 0) {
+            await new Promise((resolve) => setTimeout(resolve, __classPrivateFieldGet(this, _DebugSession_runIntervalMs, "f")));
+            if (__classPrivateFieldGet(this, _DebugSession_stopped, "f"))
+                return;
+        }
+    }
+    if (!__classPrivateFieldGet(this, _DebugSession_stopped, "f")) {
+        for (const fn of __classPrivateFieldGet(this, _DebugSession_listeners, "f").halt) {
+            void fn();
+        }
+    }
+};
+
 // Format converters between a Graph (the data model produced by State.toGraph
 // and consumed by State.fromGraph) and external string representations.
 //
@@ -1851,6 +2303,8 @@ function unescapeMermaidLabel(s) {
                     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;
             }
         }
@@ -2455,10 +2909,10 @@ function summarizeGraph(graph) {
     }
     let hasCycles = false;
     const visit = (id) => {
-        // 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.
+        // No `if (hasCycles) return` guard at function entry: the 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.
         if (color.get(id) === GREY) {
             hasCycles = true;
             return;
@@ -2577,6 +3031,7 @@ function runOnce(runnable, input, stepsLimit) {
 exports.Alphabet = Alphabet;
 exports.Command = Command;
 exports.DebugConfig = DebugConfig;
+exports.DebugSession = DebugSession;
 exports.Reference = Reference;
 exports.State = State;
 exports.Tape = Tape;