@turing-machine-js/visuals 7.0.0-alpha.6 → 7.0.0-alpha.7

package/src/applyHighlight.spec.ts

@@ -1,331 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { applyHighlight, applyIndicator } from './applyHighlight';
-import { indexGraph } from './graphIndexes';
-import { recordingOps, type RecordedOp } from './highlightOps';
-import type { GraphHighlight } from './types';
-import type { Graph } from '@turing-machine-js/machine';
-
-/**
- * Rule tests for `applyHighlight`. Section numbers mirror
- * `docs/graph-highlight-and-breakpoints.md` — any rule change must
- * update both the doc and the matching `describe` block here.
- *
- * Fixtures come from `tests/fixtures/graphs/`, which are committed
- * snapshots of `State.toGraph` output for each bundled example
- * (regenerable via `REGEN_FIXTURES=1 npm test`). Using real engine output
- * means these tests also catch any drift between engine emit and
- * rule expectations.
- *
- * Helpful fixture ids for `turing-callable-subtree`:
- *   bare walkToBlank             = 3   (frameId 3)
- *   writeMarker (override)       = 4
- *   wrapper walkToBlank(writeMarker) = 5  (bareStateId 3, overriddenHaltStateId 4)
- *   halt singleton               = 0
- *   frame halt marker            = -3  (id = -frameId)
- */
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const FIXTURE_DIR = resolve(__dirname, './fixtures/graphs');
-
-function loadGraph(name: string): Graph {
-  return JSON.parse(readFileSync(resolve(FIXTURE_DIR, `${name}.json`), 'utf-8'));
-}
-
-/** Run `applyHighlight` with a recording ops impl, return the ordered ops list. */
-function run(highlight: GraphHighlight | null, graph: Graph, prev: number | 'idle' | null = null): {
-  ops: RecordedOp[];
-  next: number | 'idle' | null;
-} {
-  const indexes = indexGraph(graph);
-  const { highlight: opsImpl, record } = recordingOps();
-  const { nextPrevStrongId } = applyHighlight(highlight, graph, indexes, prev, opsImpl);
-  return { ops: record, next: nextPrevStrongId };
-}
-
-describe('applyHighlight', () => {
-  describe('null/empty highlight', () => {
-    it('returns no-op with nextPrev=null when highlight is null', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { ops, next } = run(null, g, 3);
-      expect(ops).toEqual([]);
-      expect(next).toBeNull();
-    });
-  });
-
-  describe('§5 halt-target retargeting', () => {
-    it('rewrites toId=0 to -frameId when fromId is in a frame', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // Bare walkToBlank (id 3, frameId 3) halts → engine reports toId=0,
-      // should retarget to -3 (frame halt marker).
-      const { ops } = run({ fromId: 3, toId: 0, strong: 'from', paused: false }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      // halt marker -3 gets highlight-to; halt singleton 0 does not.
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: -3, cls: 'mg-highlight-to' });
-      expect(classOps).not.toContainEqual({ op: 'addNodeClass', id: 0, cls: 'mg-highlight-to' });
-    });
-
-    it('does NOT retarget when fromId is outside any frame', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // writeMarker (id 4) is the wrapper's override-target; sits outside
-      // the frame (frameId: null), so its halt→halt-singleton stays as id 0.
-      const { ops } = run({ fromId: 4, toId: 0, strong: 'from', paused: false }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 0, cls: 'mg-highlight-to' });
-    });
-  });
-
-  describe('§2 + §3 wrapper/bare equivalence (asymmetric)', () => {
-    it('wrapper-strong expands to [wrapper, bare] — both get highlight-to + strong', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // Wrapper-entry pause: idle → wrapper(5), pauseBefore strong=to.
-      const { ops } = run({ fromId: 'idle', toId: 5, strong: 'to', paused: true }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 5, cls: 'mg-highlight-to' });
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 5, cls: 'mg-highlight-strong' });
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 3, cls: 'mg-highlight-to' });
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 3, cls: 'mg-highlight-strong' });
-    });
-
-    it('bare-strong stays bare only — does NOT light up wrapper', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // Bare-loop pause: prev=bare(3), to=bare(3), pauseBefore strong=to.
-      const { ops } = run({ fromId: 3, toId: 3, strong: 'to', paused: true }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 3, cls: 'mg-highlight-to' });
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 3, cls: 'mg-highlight-strong' });
-      // Wrapper 5 gets NOTHING from the to-side expansion.
-      expect(classOps).not.toContainEqual({ op: 'addNodeClass', id: 5, cls: 'mg-highlight-to' });
-      expect(classOps).not.toContainEqual({ op: 'addNodeClass', id: 5, cls: 'mg-highlight-strong' });
-    });
-  });
-
-  describe('§6 source return chain (toId < 0)', () => {
-    it('lights up return arrow + wrapper + override edge + override target', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // Just-fired halt-bound transition: from=bare(3), to=halt-marker(-3),
-      // strong=from (pause-after-style).
-      const { ops } = run({ fromId: 3, toId: -3, strong: 'from', paused: true }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      const edgeOps = ops.filter((o) => o.op === 'highlightEdge');
-      // Return arrow w_3 → wrapper(5).
-      expect(edgeOps).toContainEqual({ op: 'highlightEdge', fromKey: 'w_3', toKey: 's5' });
-      // Wrapper gets highlight-to.
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 5, cls: 'mg-highlight-to' });
-      // Wrapper → override edge.
-      expect(edgeOps).toContainEqual({ op: 'highlightEdge', fromKey: 's5', toKey: 's4' });
-      // Override (writeMarker) gets highlight-to.
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 4, cls: 'mg-highlight-to' });
-    });
-  });
-
-  describe('§7 destination return chain (paused at override after pop)', () => {
-    it('lights the full path bare → halt-marker → return → wrapper → override + frame', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // Paused-before writeMarker: prev=bare(3) (last yield was bare's halt),
-      // current=writeMarker(4). strong=to. Bare is in frame 3; wrapper 5's
-      // override is 4 → matches.
-      const { ops } = run({ fromId: 3, toId: 4, strong: 'to', paused: true }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      const edgeOps = ops.filter((o) => o.op === 'highlightEdge');
-      const frameOps = ops.filter((o) => o.op === 'markFrameActive');
-
-      // Halt marker lit.
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: -3, cls: 'mg-highlight-to' });
-      // bare → halt-marker edge.
-      expect(edgeOps).toContainEqual({ op: 'highlightEdge', fromKey: 's3', toKey: 'c3' });
-      // Return arrow.
-      expect(edgeOps).toContainEqual({ op: 'highlightEdge', fromKey: 'w_3', toKey: 's5' });
-      // Wrapper highlight-to.
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 5, cls: 'mg-highlight-to' });
-      // Wrapper → override edge.
-      expect(edgeOps).toContainEqual({ op: 'highlightEdge', fromKey: 's5', toKey: 's4' });
-      // Frame active (override sits outside frame, but the chain fired so
-      // we still mark the frame to show "we came out of THIS subtree").
-      expect(frameOps).toContainEqual({ op: 'markFrameActive', frameId: 3 });
-    });
-
-    it('does NOT fire when fromId is not in any frame', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // From idle → writeMarker(4): no frame on the from side, no chain.
-      const { ops } = run({ fromId: 'idle', toId: 4, strong: 'to', paused: true }, g);
-      const edgeOps = ops.filter((o) => o.op === 'highlightEdge');
-      expect(edgeOps).not.toContainEqual({ op: 'highlightEdge', fromKey: 's3', toKey: 'c3' });
-      expect(edgeOps).not.toContainEqual({ op: 'highlightEdge', fromKey: 'w_3', toKey: 's5' });
-    });
-  });
-
-  describe('§8 halt singleton (toId === 0, no retarget)', () => {
-    it('marks the halt singleton with highlight-to + strong', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // writeMarker (id 4, no frame) → halt singleton (0). strong=from
-      // (pause-after applying writeMarker's command).
-      const { ops } = run({ fromId: 4, toId: 0, strong: 'from', paused: true }, g);
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: 0, cls: 'mg-highlight-to' });
-      // strong is 'from', so halt singleton is not strong.
-      expect(classOps).not.toContainEqual({ op: 'addNodeClass', id: 0, cls: 'mg-highlight-strong' });
-    });
-  });
-
-  describe('§9 frame-active', () => {
-    it('marks the frame when canonical strong is inside it (wrapper case)', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // Wrapper-entry pause: strong=wrapper(5). bareIdOf(5)=3. nodeFrameMap[3]=3.
-      const { ops } = run({ fromId: 'idle', toId: 5, strong: 'to', paused: true }, g);
-      const frameOps = ops.filter((o) => o.op === 'markFrameActive');
-      expect(frameOps).toContainEqual({ op: 'markFrameActive', frameId: 3 });
-    });
-
-    it('marks the frame when bare is strong', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { ops } = run({ fromId: 3, toId: 3, strong: 'to', paused: true }, g);
-      const frameOps = ops.filter((o) => o.op === 'markFrameActive');
-      expect(frameOps).toContainEqual({ op: 'markFrameActive', frameId: 3 });
-    });
-
-    it('does NOT mark a frame when strong is outside any frame', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // writeMarker (4, no frame) is strong.
-      const { ops } = run({ fromId: 4, toId: 0, strong: 'from', paused: true }, g);
-      const frameOps = ops.filter((o) => o.op === 'markFrameActive');
-      expect(frameOps).toEqual([]);
-    });
-  });
-
-  describe('§10 wrapper-entry call edge', () => {
-    it('highlights the wrapper → bare call edge when to-side expanded to both', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { ops } = run({ fromId: 'idle', toId: 5, strong: 'to', paused: true }, g);
-      const edgeOps = ops.filter((o) => o.op === 'highlightEdge');
-      expect(edgeOps).toContainEqual({ op: 'highlightEdge', fromKey: 's5', toKey: 's3' });
-    });
-
-    it('does NOT highlight a call edge when to-side is bare only', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { ops } = run({ fromId: 3, toId: 3, strong: 'to', paused: true }, g);
-      const edgeOps = ops.filter((o) => o.op === 'highlightEdge');
-      // No s5→s3 call edge (bare doesn't expand to include wrapper).
-      expect(edgeOps).not.toContainEqual({ op: 'highlightEdge', fromKey: 's5', toKey: 's3' });
-    });
-  });
-
-  describe('§11 pause-revisit pulse (raw, not canonical)', () => {
-    it('does NOT pulse on wrapper-pause → bare-pause transition', () => {
-      const g = loadGraph('turing-callable-subtree');
-      // First pause: wrapper-entry. prev=null → no pulse. nextPrev=5 (wrapper).
-      const r1 = run({ fromId: 'idle', toId: 5, strong: 'to', paused: true }, g, null);
-      expect(r1.ops.find((o) => o.op === 'pulse')).toBeUndefined();
-      expect(r1.next).toBe(5);
-      // Second pause: bare loop iter. prev=5 (wrapper), strong=3 (bare).
-      // 5 !== 3 → NO pulse, even though they share #debugRef.
-      const r2 = run({ fromId: 3, toId: 3, strong: 'to', paused: true }, g, r1.next);
-      expect(r2.ops.find((o) => o.op === 'pulse')).toBeUndefined();
-      expect(r2.next).toBe(3);
-    });
-
-    it('pulses on same-state revisit (bare → bare)', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const r1 = run({ fromId: 3, toId: 3, strong: 'to', paused: true }, g, null);
-      expect(r1.ops.find((o) => o.op === 'pulse')).toBeUndefined();
-      const r2 = run({ fromId: 3, toId: 3, strong: 'to', paused: true }, g, r1.next);
-      expect(r2.ops).toContainEqual({ op: 'pulse', id: 3 });
-    });
-
-    it('does NOT update prev on non-paused (idle / RUNNING_AUTO) events', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const r = run({ fromId: 3, toId: 3, strong: 'from', paused: false }, g, 5);
-      expect(r.next).toBe(5); // unchanged
-    });
-
-    it('resets prev to null on null highlight', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const r = run(null, g, 3);
-      expect(r.next).toBeNull();
-    });
-  });
-
-  describe('scroll-into-view', () => {
-    it('scrolls to the strong node', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { ops } = run({ fromId: 3, toId: 4, strong: 'to', paused: true }, g);
-      expect(ops).toContainEqual({ op: 'scrollIntoView', id: 4 });
-    });
-
-    it('does not scroll when strong is null (no highlight)', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { ops } = run(null, g);
-      expect(ops.find((o) => o.op === 'scrollIntoView')).toBeUndefined();
-    });
-  });
-
-  describe('applyIndicator (§2 canonical breakpoint + §3 indicator class)', () => {
-    it('marks every member of the equivalence class when canonical id is in set', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { indicator, record } = recordingOps();
-      // BP set has the bare id (3). Both wrapper (5) and bare (3) should turn on.
-      applyIndicator(new Set([3]), g, [3, 4, 5, -3, 0, 'idle'], indicator);
-      const onIds = record
-        .filter((r): r is Extract<RecordedOp, { op: 'setBreakpoint' }> => r.op === 'setBreakpoint' && r.on)
-        .map((r) => r.id);
-      expect(onIds).toContain(3);
-      expect(onIds).toContain(5);
-      // writeMarker (4), halt-marker (-3), halt (0), idle: never on.
-      expect(onIds).not.toContain(4);
-      expect(onIds).not.toContain(-3);
-      expect(onIds).not.toContain(0);
-      expect(onIds).not.toContain('idle');
-    });
-
-    it('clears every node when the set is empty', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { indicator, record } = recordingOps();
-      applyIndicator(new Set(), g, [3, 4, 5, 'idle'], indicator);
-      const onCount = record.filter((r) => r.op === 'setBreakpoint' && r.on).length;
-      expect(onCount).toBe(0);
-      // Every node still gets an explicit off call (idempotent clears).
-      expect(record.length).toBe(4);
-    });
-
-    // machines-demo#37 — halt singleton (id 0) is a valid breakpoint
-    // target (engine-wide haltState). The set stores canonical id 0;
-    // both the halt singleton AND every halt marker (negative ids; one
-    // per frame) collapse to that class via `bareIdOf(-N, g) === 0`.
-    it('marks halt singleton AND every halt marker when 0 is in the set', () => {
-      const g = loadGraph('turing-callable-subtree');
-      const { indicator, record } = recordingOps();
-      applyIndicator(new Set([0]), g, [3, 4, 5, -3, 0, 'idle'], indicator);
-      const onIds = record
-        .filter((r): r is Extract<RecordedOp, { op: 'setBreakpoint' }> => r.op === 'setBreakpoint' && r.on)
-        .map((r) => r.id);
-      expect(onIds).toContain(0); // halt singleton
-      expect(onIds).toContain(-3); // halt marker for frame 3
-      // Regular and wrapper / bare nodes: never on.
-      expect(onIds).not.toContain(3);
-      expect(onIds).not.toContain(4);
-      expect(onIds).not.toContain(5);
-      expect(onIds).not.toContain('idle');
-    });
-  });
-
-  describe('regression: simple machines (no callable subtree)', () => {
-    it('lights from + to + strong + edge for a plain RUNNING_AUTO tick', () => {
-      const g = loadGraph('turing-replace-b');
-      // Pick any two ids that have a transition between them.
-      const nodes = Object.values(g.nodes).filter((n) => !n.isHalt && !n.isHaltMarker);
-      const src = nodes.find((n) => n.transitions.length > 0)!;
-      const transition = src.transitions[0];
-      const dst = transition.nextStateId;
-      const { ops } = run(
-        { fromId: src.id, toId: dst, strong: 'from', paused: false },
-        g,
-      );
-      const classOps = ops.filter((o) => o.op === 'addNodeClass');
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: src.id, cls: 'mg-highlight-from' });
-      expect(classOps).toContainEqual({ op: 'addNodeClass', id: src.id, cls: 'mg-highlight-strong' });
-    });
-  });
-});

package/src/applyHighlight.ts

@@ -1,217 +0,0 @@
-import type { GraphHighlight } from './types';
-import type { Graph } from '@turing-machine-js/machine';
-import type { GraphIndexes } from './graphIndexes';
-import type { HighlightOps, IndicatorOps, NodeKey } from './highlightOps';
-import { bareIdOf, highlightExpand } from './graphUtils';
-
-/**
- * Pure highlight-rule evaluator. Given the current `highlight` (from
- * `MachineView`'s `$derived`), the engine `graph`, derived `indexes`,
- * and the previous strong-id (for pause-revisit pulse detection), emit
- * a sequence of `ops` calls describing the resulting visual state.
- *
- * Strictly additive — the caller is expected to clear previously-applied
- * highlight classes / edge marks / cluster activations BEFORE invoking
- * this function. The function never reads back from the consumer.
- *
- * Returns the new prev-strong-id to thread into the next call. Pulse
- * comparison uses the RAW strong id (not canonical), so wrapper-pause
- * and bare-pause register as different positions and don't pulse each
- * other. Updates only when `highlight.paused === true`; non-paused
- * events (idle / RUNNING_AUTO ticks) leave it untouched. Null highlight
- * resets it to null.
- *
- * See `docs/graph-highlight-and-breakpoints.md` for the 16 rules
- * enumerated.
- */
-export function applyHighlight(
-  highlight: GraphHighlight | null,
-  graph: Graph | null,
-  indexes: GraphIndexes,
-  prevStrongId: NodeKey | null,
-  ops: HighlightOps,
-): { nextPrevStrongId: NodeKey | null } {
-  if (!highlight || !graph) {
-    return { nextPrevStrongId: null };
-  }
-
-  // §5 Halt-target retargeting: real halt (id 0) reached from an in-frame
-  // state retargets to the frame's halt marker (id = -frameId), so the
-  // visible edge lands inside the cluster.
-  let toId: number | null = highlight.toId;
-  if (toId === 0 && typeof highlight.fromId === 'number') {
-    const fromFrameId = indexes.nodeFrameMap.get(highlight.fromId);
-    if (fromFrameId !== undefined) toId = -fromFrameId;
-  }
-
-  // §2 Equivalence-class expansion (asymmetric, via highlightExpand):
-  //   wrapper → [wrapper, bare]  (joined visual pair for wrapper-entry pause)
-  //   bare    → [bare]           (engine genuinely on the bare; no wrapper sync)
-  // From-side expansion only fires for positive numeric ids; the 'idle'
-  // sentinel is handled directly below. Halt markers / singleton fall
-  // through the direct-lookup branches.
-  const fromEqIds = typeof highlight.fromId === 'number'
-    ? highlightExpand(highlight.fromId, graph)
-    : [];
-  const toEqIds = toId !== null && toId > 0
-    ? highlightExpand(toId, graph)
-    : [];
-
-  // §3 Class application — from side.
-  if (highlight.fromId === 'idle') {
-    ops.addNodeClass('idle', 'mg-highlight-from');
-    if (highlight.strong === 'from') ops.addNodeClass('idle', 'mg-highlight-strong');
-  }
-  for (const id of fromEqIds) {
-    ops.addNodeClass(id, 'mg-highlight-from');
-    if (highlight.strong === 'from') ops.addNodeClass(id, 'mg-highlight-strong');
-  }
-
-  // §3 + §8 Class application — to side. Halt markers (toId < 0) and the
-  // real halt singleton (toId === 0; only possible when §5 didn't retarget)
-  // bypass the equivalence-class expansion via direct lookup.
-  if (toId !== null && toId <= 0) {
-    ops.addNodeClass(toId, 'mg-highlight-to');
-    if (highlight.strong === 'to') ops.addNodeClass(toId, 'mg-highlight-strong');
-  }
-  for (const id of toEqIds) {
-    ops.addNodeClass(id, 'mg-highlight-to');
-    if (highlight.strong === 'to') ops.addNodeClass(id, 'mg-highlight-strong');
-  }
-
-  // Edge highlight: the data-id token form mermaid emits.
-  const fromKey = highlight.fromId === 'idle' ? 'idle' : `s${highlight.fromId}`;
-  const toKey =
-    toId === null ? null
-    : toId < 0 ? `c${-toId}`  // halt marker
-    : `s${toId}`;
-  if (toKey !== null) ops.highlightEdge(fromKey, toKey);
-
-  // §10 Wrapper-entry "call" edge: when to-side expanded to [wrapper, bare],
-  // light up the wrapper→bare connector so the joined pair has a visible link.
-  if (toEqIds.length > 1) {
-    const wrapperId = toEqIds.find((id) => graph.nodes[id]?.isWrapper);
-    const bareId = toEqIds.find((id) => !graph.nodes[id]?.isWrapper);
-    if (wrapperId !== undefined && bareId !== undefined) {
-      ops.highlightEdge(`s${wrapperId}`, `s${bareId}`);
-    }
-  }
-
-  // §6 Source return chain: just-fired transition landed on a frame's
-  // halt marker. Light up the post-pop trajectory before the next iter
-  // moves the strong node.
-  if (toId !== null && toId < 0) {
-    const frameId = -toId;
-    const wrappers = indexes.frameWrappersMap.get(frameId) ?? [];
-    for (const { wrapperId, overrideId } of wrappers) {
-      ops.highlightEdge(`w_${frameId}`, `s${wrapperId}`);
-      ops.addNodeClass(wrapperId, 'mg-highlight-to');
-      if (overrideId !== null) {
-        ops.highlightEdge(`s${wrapperId}`, `s${overrideId}`);
-        ops.addNodeClass(overrideId, 'mg-highlight-to');
-      }
-    }
-  }
-
-  // §7 Destination return chain: paused at a positive toId that's some
-  // wrapper W's override AND fromId is in W's frame — the engine just
-  // popped. The straight bare→override edge doesn't exist in the graph;
-  // light up the actual visible path bare → halt-marker → return →
-  // wrapper → override, plus the frame cluster.
-  if (typeof highlight.fromId === 'number' && toId !== null && toId > 0) {
-    const fromFrameId = indexes.nodeFrameMap.get(highlight.fromId);
-    if (fromFrameId !== undefined) {
-      const wrappers = indexes.frameWrappersMap.get(fromFrameId) ?? [];
-      const matching = wrappers.filter((w) => w.overrideId === toId);
-      if (matching.length > 0) {
-        ops.addNodeClass(-fromFrameId, 'mg-highlight-to');
-        ops.highlightEdge(`s${highlight.fromId}`, `c${fromFrameId}`);
-        for (const { wrapperId } of matching) {
-          ops.highlightEdge(`w_${fromFrameId}`, `s${wrapperId}`);
-          ops.addNodeClass(wrapperId, 'mg-highlight-to');
-          ops.highlightEdge(`s${wrapperId}`, `s${toId}`);
-        }
-        ops.markFrameActive(fromFrameId);
-      }
-    }
-  }
-
-  // §9 Frame-active for the strong node. Wrappers are outside any frame
-  // so canonicalize via bareIdOf so the wrapper-entry pause still lights
-  // up the bare's enclosing cluster.
-  const strongId = highlight.strong === 'from' ? highlight.fromId : highlight.toId;
-  const strongIdCanonical = typeof strongId === 'number'
-    ? bareIdOf(strongId, graph)
-    : strongId;
-  if (typeof strongIdCanonical === 'number') {
-    const frameId = indexes.nodeFrameMap.get(strongIdCanonical);
-    if (frameId !== undefined) ops.markFrameActive(frameId);
-  }
-
-  // §11 Pulse on same-state revisit. Uses RAW strongId — wrapper-pause
-  // and bare-pause are visually distinct positions even though they
-  // share #debugRef; pausing at wrapper then continuing into bare must
-  // not pulse. Idles never pulse and never update prevStrongId.
-  if (
-    highlight.paused
-    && strongId !== null
-    && strongId === prevStrongId
-    && strongId !== undefined
-  ) {
-    ops.pulse(strongId);
-  }
-
-  // Scroll-into-view target: for wrapper-entry pauses, scroll to the
-  // BARE (not the wrapper) so the focus matches the displayed state
-  // name. The worker's `resolveDisplayName` returns the bare's name
-  // for wrapper iters (so the log reads "paused at walkToBlank ..."),
-  // but `toId` is the wrapper's id and `highlightExpand` lights up
-  // both nodes as strong. Without this canonicalization the scroll
-  // lands on the wrapper while the log line and user's mental focus
-  // are on the bare. Halt-related ids (≤ 0) are scrolled to as-is —
-  // `bareIdOf` would collapse them all to the halt singleton, which
-  // is structurally separate from the in-frame halt marker the user
-  // is paused near.
-  if (strongId !== null) {
-    let scrollTarget: NodeKey = strongId;
-    if (typeof strongId === 'number' && strongId > 0) {
-      const node = graph.nodes[strongId];
-      if (node?.isWrapper && node.bareStateId !== null) {
-        scrollTarget = node.bareStateId;
-      }
-    }
-    ops.scrollIntoView(scrollTarget);
-  }
-
-  const nextPrevStrongId = highlight.paused ? strongId : prevStrongId;
-  return { nextPrevStrongId };
-}
-
-/**
- * Pure breakpoint-indicator rule evaluator. For each cached node key,
- * emit `ops.setBreakpoint(key, on)` reflecting whether the node's
- * canonical bare-id is in the `breakpoints` set.
- *
- * The 'idle' string sentinel never carries a breakpoint. All numeric
- * keys are valid BP-class members:
- *   - positive id   → regular state; canonical via bareIdOf (wrappers
- *                     collapse to bare)
- *   - 0             → haltState singleton (engine-wide; canonical = 0)
- *   - negative id   → halt marker (per-frame visualization sentinel;
- *                     bareIdOf maps to 0 — same class as the singleton)
- * Consumers pass their iterable of cached node keys (e.g. `nodeCache.keys()`).
- */
-export function applyIndicator(
-  breakpoints: ReadonlySet<number>,
-  graph: Graph | null,
-  nodeIds: Iterable<NodeKey>,
-  ops: IndicatorOps,
-): void {
-  for (const key of nodeIds) {
-    const on =
-      typeof key === 'number'
-      && graph !== null
-      && breakpoints.has(bareIdOf(key, graph));
-    ops.setBreakpoint(key, on);
-  }
-}

package/src/fixtures/graphs/post-walk-mark.json

@@ -1,108 +0,0 @@
-{
-  "initialId": 6,
-  "alphabets": [
-    [
-      "␣",
-      "•"
-    ]
-  ],
-  "nodes": {
-    "0": {
-      "id": 0,
-      "name": "id:0",
-      "isHalt": true,
-      "isHaltMarker": false,
-      "isWrapper": false,
-      "bareStateId": null,
-      "frameId": null,
-      "transitions": [],
-      "overriddenHaltStateId": null,
-      "tags": []
-    },
-    "6": {
-      "id": 6,
-      "name": "10",
-      "isHalt": false,
-      "isHaltMarker": false,
-      "isWrapper": false,
-      "bareStateId": null,
-      "frameId": null,
-      "transitions": [
-        {
-          "pattern": "'•'",
-          "command": [
-            {
-              "symbol": "K",
-              "movement": "S"
-            }
-          ],
-          "nextStateId": 7,
-          "id": "6.0"
-        },
-        {
-          "pattern": "B",
-          "command": [
-            {
-              "symbol": "K",
-              "movement": "S"
-            }
-          ],
-          "nextStateId": 8,
-          "id": "6.1"
-        }
-      ],
-      "overriddenHaltStateId": null,
-      "tags": [
-        "main"
-      ]
-    },
-    "7": {
-      "id": 7,
-      "name": "20",
-      "isHalt": false,
-      "isHaltMarker": false,
-      "isWrapper": false,
-      "bareStateId": null,
-      "frameId": null,
-      "transitions": [
-        {
-          "pattern": "*",
-          "command": [
-            {
-              "symbol": "K",
-              "movement": "R"
-            }
-          ],
-          "nextStateId": 6,
-          "id": "7.0"
-        }
-      ],
-      "overriddenHaltStateId": null,
-      "tags": []
-    },
-    "8": {
-      "id": 8,
-      "name": "30",
-      "isHalt": false,
-      "isHaltMarker": false,
-      "isWrapper": false,
-      "bareStateId": null,
-      "frameId": null,
-      "transitions": [
-        {
-          "pattern": "*",
-          "command": [
-            {
-              "symbol": "'•'",
-              "movement": "S"
-            }
-          ],
-          "nextStateId": 0,
-          "id": "8.0"
-        }
-      ],
-      "overriddenHaltStateId": null,
-      "tags": []
-    }
-  }
-}