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

package/src/highlightOps.ts

@@ -1,94 +0,0 @@
-/**
- * Contract between the pure highlight logic (`applyHighlight`,
- * `applyIndicator`) and any consumer that actually renders the graph
- * (Svelte component, vanilla embed, server-side snapshot, etc.).
- *
- * The pure functions decide *what* should happen (which node gets a class,
- * which edge lights up, where to pulse); the consumer's `HighlightOps`
- * implementation decides *how* (DOM mutation, recording for tests, etc.).
- *
- * See `docs/graph-highlight-and-breakpoints.md` for the rules each
- * implementation must respect.
- */
-
-export type NodeKey = number | 'idle';
-
-/** Classes the apply-highlight pass may add to a `g.node` element. */
-export type HighlightClass =
-  | 'mg-highlight-from'
-  | 'mg-highlight-to'
-  | 'mg-highlight-strong';
-
-/**
- * Operations the highlight logic invokes on the rendered graph. Purely
- * additive — the consumer is expected to clear previous highlight state
- * (classes, marker swaps) BEFORE invoking `applyHighlight`. The pure
- * function never reads back from the consumer; it just emits ops.
- *
- * Edge keys follow mermaid's data-id token form: `'idle'` for the
- * synthetic entry sentinel, `'s${id}'` for regular/wrapper/bare states,
- * `'c${id}'` for halt markers (id = `-frameId`), `'w_${id}'` for callable-
- * subtree subgraph clusters. Mermaid emits `L_${from}_${to}_${ix}` per
- * edge; ix-resolution is the consumer's concern (multiple edges between
- * the same pair are rare; the consumer typically picks the first match).
- */
-export interface HighlightOps {
-  /** Add a highlight class to the node identified by `id`. */
-  addNodeClass(id: NodeKey, cls: HighlightClass): void;
-
-  /** Highlight the edge whose data-id matches `L_${fromKey}_${toKey}_*`. */
-  highlightEdge(fromKey: string, toKey: string): void;
-
-  /** Mark the callable-subtree cluster for `frameId` as active. */
-  markFrameActive(frameId: number): void;
-
-  /** Fire a one-shot pulse animation on the given node. */
-  pulse(id: NodeKey): void;
-
-  /** Scroll the given node into the visible area of its container. */
-  scrollIntoView(id: NodeKey): void;
-}
-
-/** Operations the indicator (breakpoint dot) pass invokes. */
-export interface IndicatorOps {
-  /** Set or clear the breakpoint indicator on the given node. */
-  setBreakpoint(id: NodeKey, on: boolean): void;
-}
-
-/** A single recorded op — serializable, suitable for snapshot tests. */
-export type RecordedOp =
-  | { op: 'addNodeClass'; id: NodeKey; cls: HighlightClass }
-  | { op: 'highlightEdge'; fromKey: string; toKey: string }
-  | { op: 'markFrameActive'; frameId: number }
-  | { op: 'pulse'; id: NodeKey }
-  | { op: 'scrollIntoView'; id: NodeKey }
-  | { op: 'setBreakpoint'; id: NodeKey; on: boolean };
-
-/**
- * Build a recording `HighlightOps` + `IndicatorOps` pair plus the shared
- * `record` array of calls in invocation order. Used by tests to assert
- * what the pure logic would have done without running a real DOM.
- *
- * Snapshot-friendly: the record contains only plain JSON-serializable
- * values (no DOM nodes, no function refs).
- */
-export function recordingOps(): {
-  highlight: HighlightOps;
-  indicator: IndicatorOps;
-  record: RecordedOp[];
-} {
-  const record: RecordedOp[] = [];
-  return {
-    record,
-    highlight: {
-      addNodeClass(id, cls) { record.push({ op: 'addNodeClass', id, cls }); },
-      highlightEdge(fromKey, toKey) { record.push({ op: 'highlightEdge', fromKey, toKey }); },
-      markFrameActive(frameId) { record.push({ op: 'markFrameActive', frameId }); },
-      pulse(id) { record.push({ op: 'pulse', id }); },
-      scrollIntoView(id) { record.push({ op: 'scrollIntoView', id }); },
-    },
-    indicator: {
-      setBreakpoint(id, on) { record.push({ op: 'setBreakpoint', id, on }); },
-    },
-  };
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-// Public API — extracted modules + Snippet recording surface.
-export type { NodeKey, HighlightClass, HighlightOps, IndicatorOps, RecordedOp } from './highlightOps';
-export { recordingOps } from './highlightOps';
-export { bareIdOf, highlightExpand, equivalentIds } from './graphUtils';
-export type { GraphIndexes } from './graphIndexes';
-export { indexGraph } from './graphIndexes';
-export type { GraphHighlight, TapeSnapshot, Frame, Snippet } from './types';
-export { applyHighlight, applyIndicator } from './applyHighlight';
-export { formatCommand, formatStep } from './format';
-export { recordSnippet, type RecordSnippetOptions } from './recordSnippet';

package/src/recordSnippet.spec.ts

@@ -1,275 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  Alphabet,
-  State,
-  Tape,
-  TapeBlock,
-  TuringMachine,
-  haltState,
-  ifOtherSymbol,
-  movements,
-  symbolCommands,
-} from '@turing-machine-js/machine';
-import { recordSnippet } from './recordSnippet';
-
-/** Build a machine that converts each 'a' → 'b' (move right) until blank (halt). */
-function buildTwoAMachine() {
-  const alphabet = new Alphabet([' ', 'a', 'b']);
-  const tape = new Tape({ alphabet, symbols: ['a', 'a'] });
-  const tapeBlock = TapeBlock.fromTapes([tape]);
-  const machine = new TuringMachine({ tapeBlock });
-
-  const initialState = new State({
-    [tapeBlock.symbol(['a'])]: {
-      command: [{ symbol: 'b', movement: movements.right }],
-    },
-    [ifOtherSymbol]: {
-      nextState: haltState,
-    },
-  });
-
-  const graph = State.toGraph(initialState, tapeBlock);
-  const alphabets = [alphabet.symbols.filter((s) => s !== alphabet.blankSymbol).concat(alphabet.blankSymbol)];
-
-  return { machine, initialState, graph, alphabets, alphabet };
-}
-
-describe('recordSnippet', () => {
-  describe('frame 0 (initial state)', () => {
-    it('step is 0', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames[0].step).toBe(0);
-    });
-
-    it('commands is undefined', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames[0].commands).toBeUndefined();
-    });
-
-    it('highlight is null', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames[0].highlight).toBeNull();
-    });
-
-    it('tape reflects initial state (position 0, contains "a")', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      const frame0Tape = snippet.frames[0].tape[0];
-      expect(frame0Tape.position).toBe(0);
-      expect(frame0Tape.symbols).toContain('a');
-    });
-  });
-
-  describe('frame count', () => {
-    it('2 "a"s + halt iter = 3 iters → 4 frames (frame 0 + 3)', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      // iter 1: read 'a', write 'b', move R
-      // iter 2: read 'a', write 'b', move R
-      // iter 3: read blank, nextState = haltState
-      expect(snippet.frames).toHaveLength(4);
-    });
-  });
-
-  describe('per-iter frame commands', () => {
-    it('frame 1: read "a", write "b", move R', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames[1].commands).toEqual([{ movement: 'R', read: 'a', write: 'b' }]);
-    });
-
-    it('frame 2: read "a", write "b", move R', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames[2].commands).toEqual([{ movement: 'R', read: 'a', write: 'b' }]);
-    });
-
-    it('frame 3 (halt iter): read===write (keep), movement S (stay)', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      // halt-bound transition has default command: keep + stay; blank cell read+written
-      const blank = snippet.frames[3].commands![0].read;
-      expect(snippet.frames[3].commands).toEqual([{ movement: 'S', read: blank, write: blank }]);
-    });
-  });
-
-  describe('per-iter frame tape (post-command snapshots)', () => {
-    it('frame 1 tape: "b" written at position 0, head at position 1', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      const tape = snippet.frames[1].tape[0];
-      expect(tape.symbols[0]).toBe('b');
-      expect(tape.position).toBe(1);
-    });
-
-    it('frame 2 tape: both cells "b", head at position 2', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      const tape = snippet.frames[2].tape[0];
-      expect(tape.symbols[0]).toBe('b');
-      expect(tape.symbols[1]).toBe('b');
-      expect(tape.position).toBe(2);
-    });
-  });
-
-  describe('snippet metadata', () => {
-    it('version is 1', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.version).toBe(1);
-    });
-
-    it('graph is the passed-in graph (referential equality)', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.graph).toBe(graph);
-    });
-
-    it('alphabets is the passed-in alphabets (referential equality)', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.alphabets).toBe(alphabets);
-    });
-
-    it('name is set when provided', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets, name: 'test snippet' });
-      expect(snippet.name).toBe('test snippet');
-    });
-
-    it('name is absent when not provided', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect('name' in snippet).toBe(false);
-    });
-  });
-
-  describe('log option', () => {
-    it('attaches log to non-frame-0 frames when log returns a string', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({
-        machine,
-        initialState,
-        graph,
-        alphabets,
-        log: () => 'step line',
-      });
-      // frame 0 has no log
-      expect(snippet.frames[0].log).toBeUndefined();
-      // frames 1-3 all have log
-      for (let i = 1; i < snippet.frames.length; i++) {
-        expect(snippet.frames[i].log).toBe('step line');
-      }
-    });
-
-    it('omits log when log returns undefined', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({
-        machine,
-        initialState,
-        graph,
-        alphabets,
-        log: () => undefined,
-      });
-      for (const frame of snippet.frames) {
-        expect('log' in frame).toBe(false);
-      }
-    });
-
-    it('passes current and previous MachineState to log', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const calls: [unknown, unknown][] = [];
-      recordSnippet({
-        machine,
-        initialState,
-        graph,
-        alphabets,
-        log: (m, prev) => { calls.push([m.step, prev ? prev.step : null]); return undefined; },
-      });
-      // 3 iters → 3 log calls
-      expect(calls).toHaveLength(3);
-      expect(calls[0]).toEqual([1, null]);
-      expect(calls[1]).toEqual([2, 1]);
-      expect(calls[2]).toEqual([3, 2]);
-    });
-  });
-
-  describe('maxSteps truncation', () => {
-    it('with maxSteps: 1 → 2 frames (frame 0 + frame 1)', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets, maxSteps: 1 });
-      expect(snippet.frames).toHaveLength(2);
-    });
-
-    it('with maxSteps: 1, frame 1 tape reflects the first command applied', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets, maxSteps: 1 });
-      const tape = snippet.frames[1].tape[0];
-      // 'a' was written to 'b', head moved right
-      expect(tape.symbols[0]).toBe('b');
-      expect(tape.position).toBe(1);
-    });
-  });
-
-  describe('highlight', () => {
-    it('non-frame-0 frames have a non-null highlight with strong: "from" and paused: false', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      for (let i = 1; i < snippet.frames.length; i++) {
-        const h = snippet.frames[i].highlight;
-        expect(h).not.toBeNull();
-        expect(h!.strong).toBe('from');
-        expect(h!.paused).toBe(false);
-      }
-    });
-
-    it('halt-iter frame highlight has toId: 0 (haltState)', () => {
-      const { machine, initialState, graph, alphabets } = buildTwoAMachine();
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      const lastFrame = snippet.frames[snippet.frames.length - 1];
-      expect(lastFrame.highlight!.toId).toBe(0);
-    });
-  });
-
-  describe('single-step machine (halts immediately)', () => {
-    it('produces 2 frames when machine halts on step 1', () => {
-      const alphabet = new Alphabet([' ', 'x']);
-      const tape = new Tape({ alphabet, symbols: ['x'] });
-      const tapeBlock = TapeBlock.fromTapes([tape]);
-      const machine = new TuringMachine({ tapeBlock });
-      const initialState = new State({
-        [ifOtherSymbol]: { nextState: haltState },
-      });
-      const graph = State.toGraph(initialState, tapeBlock);
-      const alphabets = [['x', ' ']];
-
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames).toHaveLength(2);
-      expect(snippet.frames[0].commands).toBeUndefined();
-      expect(snippet.frames[1].commands).toBeDefined();
-    });
-  });
-
-  describe('keep command → read === write', () => {
-    it('a keep+stay command yields read === write in commands', () => {
-      const alphabet = new Alphabet([' ', 'a']);
-      const tape = new Tape({ alphabet, symbols: ['a'] });
-      const tapeBlock = TapeBlock.fromTapes([tape]);
-      const machine = new TuringMachine({ tapeBlock });
-      const initialState = new State({
-        [tapeBlock.symbol(['a'])]: {
-          command: [{ symbol: symbolCommands.keep, movement: movements.stay }],
-          nextState: haltState,
-        },
-      });
-      const graph = State.toGraph(initialState, tapeBlock);
-      const alphabets = [['a', ' ']];
-
-      const snippet = recordSnippet({ machine, initialState, graph, alphabets });
-      expect(snippet.frames[1].commands![0]).toEqual({ movement: 'S', read: 'a', write: 'a' });
-    });
-  });
-});

package/src/recordSnippet.ts

@@ -1,141 +0,0 @@
-import {
-  haltState,
-  type Graph,
-  type MachineState,
-  type State,
-  type TuringMachine,
-} from '@turing-machine-js/machine';
-import { MOVEMENT_LETTER } from './format';
-import { bareIdOf } from './graphUtils';
-import type { Frame, GraphHighlight, Snippet, TapeSnapshot } from './types';
-
-export type RecordSnippetOptions = {
-  machine: TuringMachine;
-  initialState: State;
-  graph: Graph;
-  alphabets: string[][];
-  name?: string;
-  /**
-   * Maximum number of iteration steps to record. Defaults to 1000.
-   * If the machine hasn't halted after `maxSteps` iters, recording stops
-   * and the snippet contains `maxSteps + 1` frames (frame 0 plus one per iter).
-   */
-  maxSteps?: number;
-  /**
-   * Optional per-frame log formatter. Called with the current and previous
-   * `MachineState`; return a string to attach as `frame.log`, or `undefined`
-   * to omit. Not called for frame 0 (initial state — no transition has fired).
-   */
-  log?: (m: MachineState, prev: MachineState | null) => string | undefined;
-};
-
-const DEFAULT_MAX_STEPS = 1000;
-
-function snapshotTapes(machine: TuringMachine): TapeSnapshot[] {
-  return machine.tapeBlock.tapes.map((t) => ({
-    symbols: [...t.symbols],
-    position: t.position,
-  }));
-}
-
-function deriveCommands(
-  m: MachineState,
-): NonNullable<Frame['commands']> {
-  return m.movements.map((mv, i) => ({
-    movement: MOVEMENT_LETTER.get(mv) ?? 'S',
-    read: m.currentSymbols[i],
-    // nextSymbols is already resolved (keep → current symbol, erase → blank);
-    // when write === read the command was a keep (UI suppresses the flash).
-    write: m.nextSymbols[i],
-  }));
-}
-
-function deriveHighlight(m: MachineState, graph: Graph): GraphHighlight {
-  return {
-    fromId: bareIdOf(m.state.id, graph),
-    toId: m.nextState === haltState ? 0 : m.nextState.id,
-    strong: 'from',
-    paused: false,
-  };
-}
-
-/**
- * Record a full machine run into a `Snippet` — a self-contained playback
- * artifact suitable for embeds, articles, or landing-page panels.
- *
- * The returned snippet contains one frame per iteration plus a frame-0
- * initial-state snapshot. Recording stops when the machine halts or when
- * `maxSteps` iterations have been consumed (default 1000).
- *
- * Tape-timing note: `runStepByStep` yields BEFORE applying its command
- * (the command is applied after the yield resumes). The recorder uses a
- * one-step-delayed snapshot so each frame's `tape` reflects the
- * post-command state for that frame's iter.
- */
-export function recordSnippet(opts: RecordSnippetOptions): Snippet {
-  const {
-    machine,
-    initialState,
-    graph,
-    alphabets,
-    name,
-    maxSteps = DEFAULT_MAX_STEPS,
-    log,
-  } = opts;
-
-  const frames: Frame[] = [
-    { step: 0, tape: snapshotTapes(machine), highlight: null },
-  ];
-
-  // pending holds everything for the frame whose tape snapshot is not yet
-  // available (because applyCommand hasn't fired yet). It is flushed at the
-  // start of the NEXT iter (when the tape reflects the previous command) and
-  // after the loop (when the final command has been applied).
-  let pending: Omit<Frame, 'tape'> | null = null;
-  let prev: MachineState | null = null;
-
-  try {
-    for (const m of machine.runStepByStep({ initialState, stepsLimit: maxSteps })) {
-      // At this point applyCommand for the PREVIOUS iter has already run
-      // (the generator called applyCommand before looping back to yield).
-      // So the current tape state = post-command of the previous iter.
-      if (pending !== null) {
-        frames.push({ ...pending, tape: snapshotTapes(machine) });
-      }
-
-      const commands = deriveCommands(m);
-      const highlight = deriveHighlight(m, graph);
-      const logLine = log ? log(m, prev) : undefined;
-
-      pending = {
-        step: m.step,
-        commands,
-        highlight,
-        ...(logLine !== undefined ? { log: logLine } : {}),
-      };
-
-      prev = m;
-    }
-  } catch (e) {
-    // runStepByStep throws 'Long execution' when stepsLimit is hit.
-    // At that point applyCommand for the last yielded iter has run, so the
-    // tape is in the post-command state we want for the pending frame.
-    if (!(e instanceof Error) || e.message !== 'Long execution') {
-      throw e;
-    }
-  }
-
-  // Flush the last pending frame. After the loop (or after the catch), the
-  // tape reflects the post-command state of the final yielded iter.
-  if (pending !== null) {
-    frames.push({ ...pending, tape: snapshotTapes(machine) });
-  }
-
-  return {
-    version: 1,
-    ...(name !== undefined ? { name } : {}),
-    graph,
-    alphabets,
-    frames,
-  };
-}

package/src/types.ts

@@ -1,96 +0,0 @@
-import type { Graph } from '@turing-machine-js/machine';
-
-/**
- * State-graph highlight descriptor (machines-demo#10). MachineView derives it
- * from `executionMode` + the latest pause-response data; MachineGraph reads
- * it to light up the `from → edge → to` triple in the rendered SVG.
- *
- * - `fromId: 'idle'` represents the synthetic `idle([idle])` sentinel that
- *   `toMermaid` emits at the entry point. Used in IDLE mode to mark "where
- *   execution would start".
- * - `fromId: number` is an engine `GraphNode.id` — the source state.
- * - `toId: number | null` is the destination state's id (or `null` at halt).
- * - `strong` selects which end of the triple gets the bolder/stronger
- *   accent. Per the (B) rule: `from` strong at `before` pause; `to` strong
- *   at `after` / iter-end pause / IDLE (destination feels current).
- */
-export type GraphHighlight = {
-  fromId: number | 'idle';
-  toId: number | null;
-  strong: 'from' | 'to';
-  /**
-   * True when this highlight reflects a paused-event apply (RUNNING_PAUSED),
-   * false for per-iter idle applies (RUNNING_AUTO). MachineGraph uses this
-   * to detect cross-pause same-state revisits — pulsing the strong node when
-   * the current paused apply lands on the same state as the previous paused
-   * apply, even when intermediate idle applies pointed elsewhere
-   * (e.g., stateA breakpoint → continue → run through stateB/C → stateA
-   * breakpoint fires again). The simpler "previous apply's strong matches"
-   * check already covers AUTO self-loops; this flag drives the second pulse
-   * trigger.
-   */
-  paused: boolean;
-};
-
-/**
- * Per-tape snapshot: the cells visible/usable plus the head's index into them.
- * Same shape as machines-demo's TapeSnapshot. Pure data — no library handles.
- */
-export type TapeSnapshot = {
-  symbols: string[];
-  position: number;
-};
-
-/**
- * One frame of a recorded snippet — the state of the machine at iter `step`.
- * Frame 0 = initial state (before any transition); frame N = state after iter N's transition.
- *
- * `tape` is per-tape (single-tape machines: length 1). `highlight` describes
- * what to render on the state graph at this moment (null when no highlight).
- * `log` is optional pre-formatted text — a caption / status line consumers can render.
- */
-export type Frame = {
-  step: number;
-  tape: TapeSnapshot[];
-  /**
-   * Per-tape engine command for the iter that produced this frame. Carries
-   * both sides of the cell so players can step bi-directionally without
-   * recomputing from neighbouring frames:
-   *
-   * - `movement` — `'L' | 'R' | 'S'`. Forward step slides the tape this way;
-   *   backward step slides the opposite.
-   * - `read` — symbol on the head's cell BEFORE this iter (what the engine
-   *   matched). Backward step writes this back.
-   * - `write` — symbol on the cell AFTER this iter (=== `read` if no write
-   *   happened). Forward step writes this; UI triggers the per-cell flash
-   *   iff `write !== read`.
-   *
-   * Undefined on frame 0 (initial state — no transition has fired yet).
-   */
-  commands?: {
-    movement: 'L' | 'R' | 'S';
-    read: string;
-    write: string;
-  }[];
-  highlight: GraphHighlight | null;
-  log?: string;
-};
-
-/**
- * Recorded run of a machine — playback artifact for embeds, articles,
- * landing-page panels. Engine-agnostic (no `engine` field; identity lives
- * at the caller bucket level).
- *
- * - `version: 1` — schema integer. Additive fields don't bump it;
- *   shape-breaking changes do.
- * - `graph` — engine `State.toGraph` output captured at recording time.
- * - `alphabets` — per-tape alphabet list (single-tape: length 1).
- * - `frames` — length === `stepsApplied + 1`; frame 0 is the initial state.
- */
-export type Snippet = {
-  version: 1;
-  name?: string;
-  graph: Graph;
-  alphabets: string[][];
-  frames: Frame[];
-};

package/tsconfig.build.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "composite": true
-  },
-  "references": [
-    { "path": "../machine/tsconfig.build.json" }
-  ],
-  "exclude": ["**/*.spec.ts", "dist"]
-}