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

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,17 +640,17 @@ 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;
@@ -680,11 +680,11 @@ class TapeBlock {
      *   the State's normal matching): fall back to all `'literal'`.
      */
     patternKinds(symbol, currentSymbols = this.currentSymbols) {
-        const tapeCount = __classPrivateFieldGet$2(this, _TapeBlock_tapes, "f").length;
+        const tapeCount = __classPrivateFieldGet$3(this, _TapeBlock_tapes, "f").length;
         if (symbol === ifOtherSymbol) {
             return Array.from({ length: tapeCount }, () => 'wildcard');
         }
-        const patternList = __classPrivateFieldGet$2(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
+        const patternList = __classPrivateFieldGet$3(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
         if (patternList === undefined) {
             return Array.from({ length: tapeCount }, () => 'literal');
         }
@@ -696,11 +696,11 @@ class TapeBlock {
         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');
@@ -718,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
@@ -829,13 +824,11 @@ function toGraph(initialState, tapeBlock) {
                     movement: decodeMovement(tc.movement.description),
                 })),
                 nextStateId: targetInternal.id,
-                // Transition id format: `${stateId}.${transitionIx}` (#205).
-                // Matches `TuringMachine.runStepByStep`'s `MachineState.
-                // matchedTransition.id` so consumers can do
+                // `${stateId}.${transitionIx}` — matches
+                // `MachineState.matchedTransition.id` so consumers can do
                 // `graph.nodes[stateId].transitions.find(t => t.id === id)`.
-                // Was `${stateId}-${ix}` pre-#205 — the `.` separator avoids
-                // the hyphen reading as a minus sign next to negative halt-
-                // marker ids in adjacent contexts.
+                // `.` separator (vs `-`) avoids collision with negative
+                // halt-marker ids.
                 id: `${stateInternal.id}.${patternIx}`,
             });
             queue.push(target);
@@ -860,33 +853,70 @@ function toGraph(initialState, tapeBlock) {
         };
     }
     // Pass 2: For each bare, compute its forward-reachable set (following
-    // transitions; stopping at halt and at wrappers — both are frame
-    // boundaries).
+    // transitions; stopping at halt; including wrappers AND tunneling through
+    // them to their `overriddenHaltStateId` continuation).
+    //
+    // Wrappers are call-site markers — semantically owned by the CALLER (the
+    // bare whose body invokes the sub-call). Both the wrapper itself and its
+    // continuation (its `--> override` arrow in the rendered diagram, sourced
+    // from `overriddenHaltStateId`) belong to the caller's frame: the wrapper
+    // visually anchors the call site inside the caller's subgraph; the
+    // continuation is the state the caller's body resumes at AFTER the inner
+    // sub-call returns. So when reach traversal hits a wrapper, we PUSH the
+    // wrapper (joining the caller's reach-set) AND tunnel through to its
+    // continuation (also joining). Wrappers carry no `transitions` of their
+    // own (Pass 1 emits `transitions: []` on wrapper nodes), so the main loop
+    // pops them and adds them to `reach` without further traversal — but the
+    // continuation already entered via the wrapper-tunnel chain in
+    // `resolveAndPush`.
+    //
+    // Halt-bound retargeting + union-find then "just work": continuation
+    // states' halt-bound transitions get retargeted to the caller's halt
+    // marker (so an in-subroutine halt returns to the caller, not the
+    // program's terminal halt); when two bares both reach the same
+    // continuation through different wrapper chains, union-find merges their
+    // frames as it already does for non-wrapper overlap.
+    //
+    // Wrapper chains (continuation IS another wrapper, e.g., nested
+    // compositions) are walked transitively by the inner while-loop in
+    // `resolveAndPush` — each tunnel hop pushes the intermediate wrapper.
     const computeReach = (startId) => {
         const reach = new Set();
-        const stack = [startId];
+        const stack = [];
+        const resolveAndPush = (id) => {
+            let current = id;
+            while (true) {
+                const target = nodes[current];
+                if (!target || target.isHalt) {
+                    return;
+                }
+                if (!target.isWrapper) {
+                    stack.push(current);
+                    return;
+                }
+                // Wrapper: push it (so it joins the caller's frame) AND tunnel to
+                // its continuation. Both belong to the caller's frame.
+                stack.push(current);
+                /* c8 ignore next 3 — every wrapper emitted by Pass 1 has a
+                   non-null overriddenHaltStateId (lines 76-101); this branch
+                   only guards against future wrapper variants that might not. */
+                if (target.overriddenHaltStateId === null) {
+                    return;
+                }
+                current = target.overriddenHaltStateId;
+            }
+        };
+        resolveAndPush(startId);
         while (stack.length > 0) {
             const id = stack.pop();
             if (reach.has(id)) {
                 continue;
             }
-            const node = nodes[id];
-            // `nodes[id]` is always populated for `id` that the BFS reached, so
-            // a defensive `!node` check would be dead. `isHalt` / `isWrapper`
-            // are real boundaries — both stop reach-set expansion.
-            /* c8 ignore next 3 — defensive: the push site below already filters
-               halt/wrapper targets, and the initial push is always a bare, so
-               this branch is unreachable in practice. */
-            if (node.isHalt || node.isWrapper) {
-                continue;
-            }
             reach.add(id);
-            for (const t of node.transitions) {
-                const target = nodes[t.nextStateId];
-                if (!target || target.isHalt || target.isWrapper) {
-                    continue;
-                }
-                stack.push(t.nextStateId);
+            // Wrappers have empty transitions arrays — the for-loop runs zero
+            // iterations and we proceed to the next stack entry.
+            for (const t of nodes[id].transitions) {
+                resolveAndPush(t.nextStateId);
             }
         }
         return reach;
@@ -1236,18 +1266,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, _State_instances, _a, _State_wrapperCache, _State_id, _State_name, _State_overriddenHaltState, _State_bareState, _State_symbolToDataMap, _State_debugRef, _State_haltDebug, _State_tags, _State_getEntry;
+var _DebugConfig_ownerState, _DebugConfig_before, _DebugConfig_after, _State_instances, _a, _State_wrapperCache, _State_id, _State_name, _State_symbolToDataMap, _State_debugRef, _State_haltDebug, _State_tags, _State_getEntry, _CallFrame_bare, _CallFrame_override;
 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.
@@ -1279,7 +1309,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;
@@ -1296,18 +1326,18 @@ 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();
@@ -1319,12 +1349,6 @@ class State {
         // composed name on a no-arg `new State()` to bypass the constructor's
         // user-facing name validation (composite names contain `(` and `)`).
         _State_name.set(this, void 0);
-        _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.
-        _State_bareState.set(this, null);
         _State_symbolToDataMap.set(this, new Map());
         // Shared mutable cell — withOverriddenHaltState wrappers reference the same
         // object so that `state.debug = ...` (and nullings) propagate across them.
@@ -1350,11 +1374,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];
@@ -1382,7 +1406,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,
                 });
@@ -1391,19 +1415,21 @@ 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;
     }
+    // Plain States never override the halt state — only a `CallFrame` (produced
+    // by `withOverriddenHaltState`) carries an override, via its own getter.
     get overriddenHaltState() {
-        return __classPrivateFieldGet$1(this, _State_overriddenHaltState, "f");
+        return null;
     }
     get ref() {
         return this;
@@ -1418,17 +1444,17 @@ class State {
         // declared `DebugConfig` for any rare caller that holds a State
         // reference happening to be haltState.
         if (this.isHalt) {
-            return __classPrivateFieldGet$1(this, _State_haltDebug, "f");
+            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.
@@ -1447,7 +1473,7 @@ class State {
         // (no own iter to anchor on; halt is terminal).
         if (this.isHalt) {
             if (v === null || typeof v === 'boolean') {
-                __classPrivateFieldSet$1(this, _State_haltDebug, v === true, "f");
+                __classPrivateFieldSet$2(this, _State_haltDebug, v === true, "f");
                 return;
             }
             throw new Error('haltState.debug only accepts boolean (or null to reset). Use '
@@ -1463,14 +1489,14 @@ class State {
                 + '(or null to reset). Boolean assignment is reserved for `haltState`.');
         }
         if (v === null) {
-            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = null;
+            __classPrivateFieldGet$2(this, _State_debugRef, "f").current = null;
             return;
         }
         if (v instanceof DebugConfig) {
-            __classPrivateFieldGet$1(this, _State_debugRef, "f").current = v;
+            __classPrivateFieldGet$2(this, _State_debugRef, "f").current = v;
             return;
         }
-        __classPrivateFieldGet$1(this, _State_debugRef, "f").current = new DebugConfig(this, v);
+        __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
@@ -1480,7 +1506,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;
     }
@@ -1490,7 +1516,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;
     }
@@ -1500,27 +1526,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.
-     *  Per #207, haltState no longer flows through DebugConfig (its `debug`
-     *  setter rejects object writes before construction), so the validator
-     *  only sees non-halt states here. */
-    [(_State_id = new WeakMap(), _State_name = new WeakMap(), _State_overriddenHaltState = new WeakMap(), _State_bareState = new WeakMap(), _State_symbolToDataMap = new WeakMap(), _State_debugRef = new WeakMap(), _State_haltDebug = new WeakMap(), _State_tags = new WeakMap(), _State_instances = new WeakSet(), validateDebugFilter)](fieldName, filter) {
+     *  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_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;
         if (filter === true)
             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) {
@@ -1529,10 +1554,10 @@ class State {
         return ifOtherSymbol;
     }
     getCommand(symbol) {
-        return __classPrivateFieldGet$1(this, _State_instances, "m", _State_getEntry).call(this, symbol).command;
+        return __classPrivateFieldGet$2(this, _State_instances, "m", _State_getEntry).call(this, symbol).command;
     }
     getNextState(symbol) {
-        return __classPrivateFieldGet$1(this, _State_instances, "m", _State_getEntry).call(this, symbol).nextState;
+        return __classPrivateFieldGet$2(this, _State_instances, "m", _State_getEntry).call(this, symbol).nextState;
     }
     /**
      * Like `getNextState`, but also returns the matched Symbol and its index
@@ -1551,13 +1576,13 @@ class State {
      * bare's transition iteration order — they're the same map.
      */
     getMatchedTransition(symbol) {
-        const entry = __classPrivateFieldGet$1(this, _State_instances, "m", _State_getEntry).call(this, symbol);
+        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$1(this, _State_symbolToDataMap, "f").keys()) {
+        for (const key of __classPrivateFieldGet$2(this, _State_symbolToDataMap, "f").keys()) {
             if (key === symbol)
                 break;
             ix += 1;
@@ -1565,17 +1590,17 @@ class State {
         return { nextState: entry.nextState, matchedSymbol: symbol, ix };
     }
     withOverriddenHaltState(overriddenHaltState) {
-        // Unwrap `this` if it's itself a wrapper — the chain's inner overrides
+        // Unwrap `this` if it's itself a CallFrame — 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 = this instanceof CallFrame ? this.bare : this;
         // Memoize by (bare, override) so identical args return the same instance
-        // (#175). The cache uses WeakMaps + WeakRefs so cached wrappers can be
+        // (#175). The cache uses WeakMaps + WeakRefs so cached frames 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) {
@@ -1587,19 +1612,11 @@ class State {
         }
         else {
             innerCache = new WeakMap();
-            __classPrivateFieldGet$1(_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");
-        innerCache.set(overriddenHaltState, new WeakRef(state));
-        return state;
+            __classPrivateFieldGet$2(_a, _a, "f", _State_wrapperCache).set(bare, innerCache);
+        }
+        const frame = new CallFrame(bare, overriddenHaltState);
+        innerCache.set(overriddenHaltState, new WeakRef(frame));
+        return frame;
     }
     /**
      * @internal
@@ -1626,9 +1643,9 @@ class State {
      * each adds to the implicit contract sibling modules can rely on.
      */
     [(_State_getEntry = function _State_getEntry(symbol) {
-        const entry = __classPrivateFieldGet$1(this, _State_symbolToDataMap, "f").get(symbol);
+        const entry = __classPrivateFieldGet$2(this, _State_symbolToDataMap, "f").get(symbol);
         if (entry === undefined) {
-            throw new Error(`No transition for symbol at state named ${__classPrivateFieldGet$1(this, _State_name, "f")}`);
+            throw new Error(`No transition for symbol at state named ${__classPrivateFieldGet$2(this, _State_name, "f")}`);
         }
         return entry;
     }, STATE_INTERNAL)]() {
@@ -1639,13 +1656,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 null; },
+            get overriddenHaltState() { return null; },
+            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.
@@ -1654,8 +1671,13 @@ class State {
     // Symbol patterns are returned as the raw description string from the
     // interned JS Symbol (decode via decodePatternDescription if needed).
     static inspect(state) {
+        // Route through the STATE_INTERNAL view so a CallFrame reports its bare's
+        // transitions and its own override — the view delegates those to the bare
+        // / the frame's #override, whereas the raw private fields on a CallFrame
+        // are empty/null.
+        const internal = state[STATE_INTERNAL]();
         const transitions = [];
-        for (const [sym, { command, nextState }] of __classPrivateFieldGet$1(state, _State_symbolToDataMap, "f")) {
+        for (const [sym, { command, nextState }] of internal.symbolToDataMap) {
             let target = null;
             try {
                 target = nextState instanceof _a ? nextState : nextState.ref;
@@ -1672,12 +1694,13 @@ class State {
                 nextState: target ? { id: target.id, name: target.name } : null,
             });
         }
+        const override = internal.overriddenHaltState;
         return {
-            id: __classPrivateFieldGet$1(state, _State_id, "f"),
-            name: __classPrivateFieldGet$1(state, _State_name, "f"),
+            id: internal.id,
+            name: internal.name,
             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: override
+                ? { id: override.id, name: override.name }
                 : null,
             transitions,
         };
@@ -1722,21 +1745,111 @@ _a = State;
 // them, with cache misses simply reconstructing fresh wrappers.
 _State_wrapperCache = { value: new WeakMap() };
 const haltState = new State(null);
+/**
+ * A first-class call frame produced by `State.withOverriddenHaltState`
+ * (#213). A `CallFrame` is a `State` — `instanceof State` holds, so it flows
+ * anywhere a `State` does (as a `nextState`, through `toGraph`/`fromGraph`,
+ * etc.) — but it carries its own `bare` (the wrapped State) and `override`
+ * (the continuation pushed onto the run-stack on entry). `instanceof
+ * CallFrame` is the explicit wrapper discriminator.
+ *
+ * It owns no transitions of its own: lookups (`getSymbol`/`getCommand`/
+ * `getNextState`/`getMatchedTransition`) and `debug` DELEGATE to the bare,
+ * replacing the v6 field-aliasing (where a wrapper was a plain `State` whose
+ * private `#symbolToDataMap`/`#debugRef` were physically shared with the
+ * bare). `id`, `name` (composite `bare(override)`), and `tags` are its own
+ * (inherited State fields) — so memoized frames sharing a bare keep
+ * independent tags (#186), and the frame is never the halt singleton
+ * (fresh nonzero `#id` → `isHalt === false`).
+ */
+class CallFrame extends State {
+    constructor(bare, override) {
+        super(null);
+        _CallFrame_bare.set(this, void 0);
+        _CallFrame_override.set(this, void 0);
+        __classPrivateFieldSet$2(this, _CallFrame_bare, bare, "f");
+        __classPrivateFieldSet$2(this, _CallFrame_override, override, "f");
+        // Composite name contains `(` / `)`, which the constructor's user-facing
+        // name validator rejects; the STATE_INTERNAL name setter bypasses it
+        // (writes the inherited #name). `super[...]` reaches State's own view so
+        // we don't recurse through this subclass's override below.
+        super[STATE_INTERNAL]().name = `${bare.name}(${override.name})`;
+    }
+    get bare() {
+        return __classPrivateFieldGet$2(this, _CallFrame_bare, "f");
+    }
+    get overriddenHaltState() {
+        return __classPrivateFieldGet$2(this, _CallFrame_override, "f");
+    }
+    getSymbol(tapeBlock) {
+        return __classPrivateFieldGet$2(this, _CallFrame_bare, "f").getSymbol(tapeBlock);
+    }
+    getCommand(symbol) {
+        return __classPrivateFieldGet$2(this, _CallFrame_bare, "f").getCommand(symbol);
+    }
+    getNextState(symbol) {
+        return __classPrivateFieldGet$2(this, _CallFrame_bare, "f").getNextState(symbol);
+    }
+    getMatchedTransition(symbol) {
+        return __classPrivateFieldGet$2(this, _CallFrame_bare, "f").getMatchedTransition(symbol);
+    }
+    get debug() {
+        return __classPrivateFieldGet$2(this, _CallFrame_bare, "f").debug;
+    }
+    set debug(value) {
+        __classPrivateFieldGet$2(this, _CallFrame_bare, "f").debug = value;
+    }
+    [(_CallFrame_bare = new WeakMap(), _CallFrame_override = new WeakMap(), STATE_INTERNAL)]() {
+        // Own id / name / tags come from the inherited State fields (via super's
+        // view); bareState / overriddenHaltState / the transition map delegate to
+        // #bare / #override so sibling modules (stateGraph, inspect) see the
+        // frame's true shape.
+        const own = super[STATE_INTERNAL]();
+        const bare = __classPrivateFieldGet$2(this, _CallFrame_bare, "f");
+        const override = __classPrivateFieldGet$2(this, _CallFrame_override, "f");
+        return {
+            get id() { return own.id; },
+            get name() { return own.name; },
+            set name(v) { own.name = v; },
+            get bareState() { return bare; },
+            get overriddenHaltState() { return override; },
+            get symbolToDataMap() { return bare[STATE_INTERNAL]().symbolToDataMap; },
+            get tags() { return own.tags; },
+        };
+    }
+}
 
-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;
@@ -1750,43 +1863,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) {
@@ -1798,59 +1910,37 @@ 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);
                 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;
+                // For wrapper-entry iters, a CallFrame's own transitions in `toGraph`
+                // are empty (it delegates lookups to its bare); the resolvable
+                // transition id lives under the bare's stateId.
+                const resolvableStateId = state instanceof CallFrame ? state.bare.id : state.id;
                 const matchedTransition = {
                     id: `${resolvableStateId}.${matched.ix}`,
-                    matchKinds: __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").patternKinds(matched.matchedSymbol),
+                    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.
-                    //
-                    // #207: `haltState.debug` is now a boolean, and pauses on the
-                    // halt-triggering iter's AFTER side (not before). The previous
-                    // before-side check (`nextState.debug?.before === true`) was
-                    // "early-warning" timing — the user paused before the halt-bound
-                    // transition fired, then had to mentally re-derive what would
-                    // happen. Now the pause anchors post-step (after the iter's own
-                    // after-pause if armed), so consumers see the just-fired halt-
-                    // bound transition + diagram cursor still on the triggering state.
-                    //
-                    // `state` here is always non-halt (halt is terminal — the run
-                    // loop never iterates with state === haltState), so `state.debug`
-                    // is always `DebugConfig` at runtime. The public getter's return
-                    // type matches that.
-                    const beforeMatch = matchFilter(state.debug?.before, symbol);
-                    const afterMatch = matchFilter(state.debug?.after, symbol)
-                        || (nextState === haltState && haltState.debug);
+                    // `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');
                                 }
@@ -1861,16 +1951,24 @@ class TuringMachine {
                         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();
                     }
@@ -1888,12 +1986,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.
 //
@@ -2021,14 +2419,20 @@ function toMermaid(graph) {
     const nodes = Object.values(graph.nodes).slice().sort((a, b) => a.id - b.id);
     // Bucket nodes for emit order.
     const topLevelNodes = nodes.filter((n) => n.frameId === null && !n.isWrapper);
+    // All wrappers — needed by the call / return / wrapper-to-override
+    // arrow emit passes below regardless of where the wrapper renders.
     const wrapperNodes = nodes.filter((n) => n.isWrapper);
-    // Bares-and-bodies inside frames, grouped by frameId.
+    // Top-level wrappers: wrappers whose caller has no frame (the caller is
+    // the top-level program). Framed wrappers (whose caller IS a subroutine
+    // with its own frame) render INSIDE that frame's subgraph below.
+    const topLevelWrapperNodes = wrapperNodes.filter((w) => w.frameId === null);
+    // Bares-bodies-and-framed-wrappers inside frames, grouped by frameId.
     const nodesByFrame = new Map();
     // Halt-marker per frame (kept separate so it always emits LAST inside the
     // subgraph for deterministic shape).
     const haltMarkerByFrame = new Map();
     for (const node of nodes) {
-        if (node.frameId === null || node.isWrapper)
+        if (node.frameId === null)
             continue;
         if (node.isHaltMarker) {
             haltMarkerByFrame.set(node.frameId, node);
@@ -2071,8 +2475,9 @@ function toMermaid(graph) {
             lines.push(`  ${mid}["${labelOf(node)}"]`);
         }
     }
-    // 2. Emit wrappers at top level.
-    for (const wrapper of wrapperNodes) {
+    // 2. Emit top-level wrappers (wrappers owned by the top-level program;
+    // wrappers owned by a subroutine emit inside that subroutine's subgraph).
+    for (const wrapper of topLevelWrapperNodes) {
         lines.push(`  ${mermaidIdFor(wrapper.id)}[["${labelOf(wrapper)}"]]`);
     }
     // 3. `idle` sentinel.
@@ -2089,9 +2494,16 @@ function toMermaid(graph) {
             ? `callable scope: ${frameBareNames.join(' ∪ ')}`
             : `callable subtree of ${frameBareNames[0] ?? frameId}`;
         lines.push(`  subgraph ${frameSubgraphId(frameId)}["${label}"]`);
-        // Inner nodes — sort by id for determinism.
+        // Inner nodes — sort by id for determinism. Framed wrappers (call sites
+        // owned by this frame) render with the `[[name]]` wrapper shape; bares
+        // and body states render with the regular `["name"]` shape.
         for (const node of (nodesByFrame.get(frameId) ?? []).slice().sort((a, b) => a.id - b.id)) {
-            lines.push(`    ${mermaidIdFor(node.id)}["${labelOf(node)}"]`);
+            if (node.isWrapper) {
+                lines.push(`    ${mermaidIdFor(node.id)}[["${labelOf(node)}"]]`);
+            }
+            else {
+                lines.push(`    ${mermaidIdFor(node.id)}["${labelOf(node)}"]`);
+            }
         }
         // Every frame has a halt marker — `State.toGraph`'s frame-emit pass
         // creates one for each frame. Non-null assertion is safe; a defensive
@@ -2609,10 +3021,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;
@@ -2729,8 +3141,10 @@ function runOnce(runnable, input, stepsLimit) {
 }
 
 exports.Alphabet = Alphabet;
+exports.CallFrame = CallFrame;
 exports.Command = Command;
 exports.DebugConfig = DebugConfig;
+exports.DebugSession = DebugSession;
 exports.Reference = Reference;
 exports.State = State;
 exports.Tape = Tape;