@sphynxoid/stepwise 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { P as PlayerEngine, a as TourStepInput, T as TourDriver, C as Chapter, S as StepTone, b as ShortcutItem } from './types-CPf9ZD_Z.js';
-export { c as PlayerEngineApi, d as PlayerEngineHandle, e as StepwiseStep, f as TourContext } from './types-CPf9ZD_Z.js';
+import { P as PlayerEngine, S as StepwiseStep, a as StepTone, V as VerdictStatus, b as Verdict, E as Evaluator, c as TourStepInput, T as TourDriver, C as Chapter, d as ShortcutItem } from './types-CNMxISXe.js';
+export { e as EvaluatorResult, f as PlayerEngineApi, g as PlayerEngineHandle, h as TourContext, i as fail, p as pass, j as pending, t as toVerdict } from './types-CNMxISXe.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
 
@@ -53,7 +53,8 @@ interface StepPlayerOptions {
     engine?: PlayerEngine;
     /**
      * Deep-link the current frame into the URL hash (`#<key>=<index>`), opt-in.
-     * The initial hash is honored once on mount.
+     * The initial hash is honored once on mount. Only this key is written —
+     * other `&`-separated hash parts (anchors, other players' keys) are kept.
      */
     syncHash?: string;
     /**
@@ -62,6 +63,30 @@ interface StepPlayerOptions {
      * reset/new timeline) — the next full playthrough fires it again.
      */
     onEnd?: () => void;
+    /**
+     * Honor `prefers-reduced-motion: reduce` by not auto-advancing: with
+     * `autoPlay`, the player still lands on frame 0 but stays paused until the
+     * user presses play. Default true.
+     */
+    respectReducedMotion?: boolean;
+    /**
+     * Checkpoints: when it returns true for the frame playback just reached,
+     * the built-in timer pauses there and reports `held` until `release()` —
+     * "stop and predict what happens next". Manual stepping and seeks are never
+     * held (the reader keeps control). Ignored when a custom `engine` drives
+     * playback. Each checkpoint holds once per playthrough.
+     */
+    holdAt?: (frame: number) => boolean;
+    /**
+     * Follow the live edge of a growing timeline (a stream, a log, a game's
+     * move history). When frames are appended while the reader is live
+     * (playing, or parked on the last frame), playback continues through them
+     * at the normal pace. A reader who scrubbed back or paused mid-trace stays
+     * put — `live` turns false and `goLive()` returns them. With `autoPlay`, a
+     * player that mounts empty starts on the first frames. Checkpoints still
+     * hold; a custom `engine` owns its own timing and ignores this.
+     */
+    follow?: boolean;
 }
 interface StepPlayer {
     /** Total frames in the current timeline. */
@@ -80,6 +105,28 @@ interface StepPlayer {
      * not set it — `toggle()` at `ended` replays from frame 0.
      */
     ended: boolean;
+    /**
+     * The checkpoint frame playback is paused on (see `holdAt`), or null.
+     * Cleared by `release()` or any cursor movement.
+     */
+    held: number | null;
+    /** Release the current checkpoint and resume playing. No-op when not held. */
+    release: () => void;
+    /**
+     * Move the cursor without touching playback state: playing stays playing,
+     * completion and checkpoints are kept. For re-anchoring after the timeline
+     * changes underneath (`useTrace` with keyed steps) — user-facing moves
+     * should use `seek`.
+     */
+    jump: (frame: number) => void;
+    /**
+     * With `follow`: the reader is at the live edge (playing toward it, parked
+     * on the last frame, or waiting to start), so appended frames will play.
+     * Always false without `follow`.
+     */
+    live: boolean;
+    /** Move to the last frame (paused, so new frames play from there with `follow`). */
+    goLive: () => void;
     /** Jump to frame 0 and play. */
     start: () => void;
     /** Clear the player (frame = -1, paused). */
@@ -94,7 +141,358 @@ interface StepPlayer {
     setPlaying: (playing: boolean) => void;
     setSpeed: (speed: number) => void;
 }
-declare function useStepPlayer({ total, baseDelayMs, autoPlay, engine, syncHash, onEnd }: StepPlayerOptions): StepPlayer;
+declare function useStepPlayer({ total, baseDelayMs, autoPlay, engine, syncHash, onEnd, respectReducedMotion, holdAt, follow, }: StepPlayerOptions): StepPlayer;
+/** Value of `key` in the hash, or null when absent. */
+declare function readHashParam(hash: string, key: string): string | null;
+/** The hash with `key` set to `value` — replaced in place, else appended. */
+declare function writeHashParam(hash: string, key: string, value: string): string;
+
+interface TraceOptions<S extends StepwiseStep> extends Omit<StepPlayerOptions, "total" | "holdAt"> {
+    /**
+     * Checkpoints (see `StepPlayerOptions.holdAt`), with the step at hand:
+     * `holdAt: (_, step) => step?.kind === "compare"`. Always sees the current
+     * trace, also after it's recomputed.
+     */
+    holdAt?: (frame: number, step: S | undefined) => boolean;
+    /**
+     * Step identity used to keep the playhead in place when `steps` changes
+     * (see `reanchor`). Defaults to each step's `key` field. Traces without
+     * keys keep the old behavior: the same index, clamped.
+     */
+    keyOf?: (step: S, index: number) => string | undefined;
+}
+interface TracePlayer<S extends StepwiseStep> {
+    /** The underlying player — pass it to PlayerBar. */
+    player: StepPlayer;
+    /**
+     * The frame to render. Never undefined for a non-empty trace: before the
+     * player starts (`player.index === -1`) this is frame 0, not the last one.
+     */
+    step: S | undefined;
+    /** Index of `step` in the trace (0 before start; -1 for an empty trace). */
+    frame: number;
+    /** Stable `toneAt` for PlayerBar / StepScrubber. */
+    toneAt: (i: number) => StepTone;
+    /** Stable `titleAt` for PlayerBar / StepScrubber. */
+    titleAt: (i: number) => string;
+}
+/**
+ * A player bound to a concrete trace: the steps array is the timeline, and
+ * the hook resolves the frame to render (frame 0 before start — invariant
+ * "index -1 means not started"), plus scrubber accessors that read the
+ * latest steps through a ref. Replaces the per-page
+ * `player.index >= 0 ? … : 0` boilerplate.
+ *
+ *   const trace = useTrace(STEPS, { autoPlay: true });
+ *   <Viz arr={trace.step.arr} />
+ *   <PlayerBar player={trace.player} toneAt={trace.toneAt} titleAt={trace.titleAt} />
+ *
+ * `steps` may change (new input, new seed — see `useSimulation`). Keyed
+ * steps re-anchor: the playhead stays on the same logical step, and playback
+ * state is untouched.
+ */
+declare function useTrace<S extends StepwiseStep>(steps: readonly S[], opts?: TraceOptions<S>): TracePlayer<S>;
+
+/**
+ * Where should the playhead go when the trace changes underneath it?
+ *
+ * Walk back from the old position to the most recent step whose key still
+ * exists in the new trace, and land on that step there. So editing an input
+ * keeps you on "the same moment" of the algorithm when it still happens, and
+ * otherwise on the last moment both runs share — never somewhere unrelated.
+ * With no shared key at all, the playhead returns to frame 0.
+ *
+ * Pure: `useTrace` calls it during render, and it's exported for custom
+ * players. Keys come from `keyOf`, by default each step's `key` field; a
+ * step without a key never matches.
+ */
+declare function reanchor<A, B>(oldSteps: readonly A[], oldIndex: number, newSteps: readonly B[], keyOf: (step: A | B, index: number) => string | undefined): number;
+
+/** Deterministic pseudo-random source (mulberry32). */
+interface Rng {
+    /** The seed this generator was created from (numbers pass through; strings are hashed). */
+    readonly seed: number;
+    /** Uniform float in [0, 1). */
+    next(): number;
+    /** Uniform integer in [min, max], both inclusive. */
+    int(min: number, max: number): number;
+    /** A uniformly chosen element. Throws on an empty array. */
+    pick<T>(items: readonly T[]): T;
+    /** A shuffled copy (Fisher-Yates); the input is not modified. */
+    shuffle<T>(items: readonly T[]): T[];
+}
+declare function createRng(seed?: number | string): Rng;
+interface SimulationContext {
+    /** Seeded randomness. Use it instead of Math.random to keep runs replayable. */
+    rng: Rng;
+}
+/**
+ * A simulation turns an input into a trace. Write it as a generator that
+ * yields one step per moment worth showing (or return an array):
+ *
+ *   function* bubble(input: number[]): Generator<SortStep> {
+ *     const arr = [...input];
+ *     for (let pass = 0; …) {
+ *       yield { key: `p${pass}:j${j}`, tone: "neutral", label: "compare", arr: [...arr] };
+ *     }
+ *   }
+ *
+ * Yield snapshots (copies), not live references: every step is kept.
+ * Give steps a `key` so the playhead stays put when the input changes.
+ */
+type Simulation<Input, S extends StepwiseStep> = (input: Input, ctx: SimulationContext) => Iterable<S>;
+interface SimulationRunOptions {
+    /** Seed for `ctx.rng`. Default 0. */
+    seed?: number | string;
+    /**
+     * Safety cap: stop collecting after this many steps and report
+     * `truncated` (a non-terminating simulation shouldn't hang the page).
+     * Default 10 000.
+     */
+    maxSteps?: number;
+}
+interface SimulationResult<S> {
+    steps: S[];
+    /** True when `maxSteps` cut the run short. */
+    truncated: boolean;
+    /** What the simulation threw, if it did; `steps` holds what it yielded before. */
+    error: unknown;
+    /** The numeric seed actually used (strings are hashed). */
+    seed: number;
+}
+/** Run a simulation to completion (or the cap). Pure; safe at module scope and on the server. */
+declare function runSimulation<Input, S extends StepwiseStep>(simulation: Simulation<Input, S>, input: Input, opts?: SimulationRunOptions): SimulationResult<S>;
+
+interface SimulationOptions<S extends StepwiseStep> extends TraceOptions<S>, SimulationRunOptions {
+}
+interface SimulationPlayer<S extends StepwiseStep> extends TracePlayer<S> {
+    /** The computed trace. */
+    steps: readonly S[];
+    /** True when `maxSteps` cut the run short. */
+    truncated: boolean;
+    /** What the simulation threw, if anything (the trace holds the steps before it). */
+    error: unknown;
+    /** The numeric seed used for this run. */
+    seed: number;
+}
+/**
+ * A live trace: run `simulation` on `input` and play the result. Change the
+ * input (or the seed) and the trace is recomputed; keyed steps keep the
+ * playhead on the same logical moment, and a playing player keeps playing.
+ *
+ *   const [input, setInput] = useState([5, 2, 8, 1]);
+ *   const sim = useSimulation(bubbleSort, input, { autoPlay: true, syncHash: "frame" });
+ *   <Bars arr={sim.step!.arr} />
+ *   <PlayerBar player={sim.player} toneAt={sim.toneAt} titleAt={sim.titleAt} />
+ *
+ * The trace is recomputed when `simulation`, `input`, `seed` or `maxSteps`
+ * change identity: define the simulation at module scope, and keep object
+ * inputs in state (or memoize them) rather than rebuilding them per render.
+ */
+declare function useSimulation<Input, S extends StepwiseStep>(simulation: Simulation<Input, S>, input: Input, opts?: SimulationOptions<S>): SimulationPlayer<S>;
+
+interface TraceBuilder<Data extends object> {
+    /** Append one frame. Returns the builder, so calls chain. */
+    step(step: StepwiseStep<Data>): TraceBuilder<Data>;
+    /** Frames appended so far. */
+    readonly length: number;
+    /** The most recently appended frame (handy for "carry the state forward"). */
+    last(): StepwiseStep<Data> | undefined;
+    /** Snapshot the trace. A fresh array each call — the builder stays usable. */
+    build(): StepwiseStep<Data>[];
+}
+/**
+ * Typed trace builder. Authors run their algorithm at module scope and record
+ * frames as they go — no IIFE, no pre-declared `const STEPS = []` that a
+ * component might read before it is filled (invariant 6):
+ *
+ *   const t = createTrace<{ arr: number[] }>();
+ *   for (…) t.step({ tone: "write", label: "swap", arr: [...arr] });
+ *   export const STEPS = t.build();
+ *
+ * Pure data — no React, safe on the server.
+ */
+declare function createTrace<Data extends object = Record<never, never>>(): TraceBuilder<Data>;
+
+/** Named traces to play side by side: `{ bubble: stepsA, insertion: stepsB }`. */
+type Tracks = Record<string, readonly StepwiseStep<object>[]>;
+/**
+ * Sync-point key for a step. Steps with the same key in two or more tracks
+ * land on the same aligned frame; `null`/`undefined` marks a free step. The
+ * n-th occurrence of a key in one track pairs with the n-th in another.
+ */
+type TrackKeyFn<T extends Tracks = Tracks> = (step: T[keyof T][number], index: number, track: keyof T & string) => string | null | undefined;
+/** One track's slot in one aligned frame. */
+interface AlignedCell {
+    /** Index into the track's own steps; -1 only for an empty track. */
+    index: number;
+    /**
+     * The track did not advance on this frame: it is holding its last frame
+     * (finished, or waiting for a sync point), or waiting at frame 0 for its
+     * first sync point.
+     */
+    held: boolean;
+}
+type AlignedRow<K extends string = string> = Record<K, AlignedCell>;
+/**
+ * Align several traces into one timeline. Pure — use it directly for server
+ * rendering or tests; `useSyncedTracks` memoizes it per track identity.
+ *
+ * - No `key` (hold): frame i shows step i of every track; a shorter track
+ *   holds its last frame once it runs out. Length = the longest track.
+ * - With `key`: tracks advance together frame by frame, but a track whose
+ *   next step is a sync point holds until every other track that shares the
+ *   point has reached it, so matching steps share a frame. Keys must occur
+ *   in the same relative order across tracks; where they conflict, that
+ *   frame degrades to lockstep instead of deadlocking.
+ */
+declare function alignTracks<T extends Tracks>(tracks: T, key?: TrackKeyFn<T>): AlignedRow<keyof T & string>[];
+interface TrackView<S> {
+    /** The step to render for this track (undefined only for an empty track). */
+    step: S | undefined;
+    /** Index into the track's own steps; -1 for an empty track. */
+    index: number;
+    /** The track did not advance on this frame (see `AlignedCell.held`). */
+    held: boolean;
+    /** The track is on its final step. */
+    done: boolean;
+    /** Length of the track's own trace. */
+    length: number;
+}
+interface SyncedTracksOptions<T extends Tracks = Tracks> extends Omit<StepPlayerOptions, "total"> {
+    /**
+     * Sync-point alignment (see `alignTracks`). Omit to hold shorter tracks on
+     * their last frame. Read when the tracks change — pass the same tracks to
+     * keep the alignment memoized; an inline function is fine.
+     */
+    key?: TrackKeyFn<T>;
+}
+interface SyncedTracks<T extends Tracks> {
+    /** One player over the aligned timeline — pass it to PlayerBar. */
+    player: StepPlayer;
+    /** Aligned frame to render: 0 before the player starts, -1 when all tracks are empty. */
+    frame: number;
+    /** Number of aligned frames. */
+    total: number;
+    /** Per-track view of `frame`. */
+    tracks: {
+        [K in keyof T]: TrackView<T[K][number]>;
+    };
+    /** The full alignment table (stable while the tracks are). */
+    rows: readonly AlignedRow<keyof T & string>[];
+    /** Stable scrubber accessors: the most severe tone among tracks that moved. */
+    toneAt: (i: number) => StepTone;
+    /** Stable scrubber accessor: `track: label` for every track that moved. */
+    titleAt: (i: number) => string;
+}
+/**
+ * Comparison mode: several traces of the same input (two engines, two
+ * algorithms) under ONE player. The cursor walks the aligned timeline from
+ * `alignTracks`; each track resolves its own step, so payload types stay
+ * per-track. Like `useTrace`, frame 0 renders before playback starts.
+ *
+ *   const cmp = useSyncedTracks({ bubble: BUBBLE, insertion: INSERTION }, { autoPlay: true });
+ *   <Lane step={cmp.tracks.bubble.step} held={cmp.tracks.bubble.held} />
+ *   <PlayerBar player={cmp.player} toneAt={cmp.toneAt} titleAt={cmp.titleAt} />
+ */
+declare function useSyncedTracks<T extends Tracks>(tracks: T, opts?: SyncedTracksOptions<T>): SyncedTracks<T>;
+
+interface LessonStreamOptions {
+    /** Lesson to open on (deep link). Clamped. Default 0. */
+    seed?: number;
+    /** Lessons mounted on each side of the seed initially. Default 1. */
+    radius?: number;
+    /** Load the next lesson when the last mounted one's bottom is within this many px below the viewport. Default 600. */
+    approachBelow?: number;
+    /** Load the previous lesson when the first mounted one's top is below `-approachAbove`. Default 300. */
+    approachAbove?: number;
+    /** Scroll the seed lesson into view before first paint (seed > 0). Default true. */
+    scrollToSeed?: boolean;
+    /**
+     * Fired when the scroll-tracked active lesson changes (not on mount) — sync
+     * the URL / document title here. Read through a ref; inline is fine.
+     */
+    onActiveChange?: (index: number) => void;
+}
+interface LessonStream {
+    /** Lesson containing the viewport center (the seed until the first measure). */
+    active: number;
+    /** The seed lesson — SSR'd visible; every other block should fade in. */
+    seed: number;
+    /** Indices to render, in order (the mounted window). */
+    mounted: number[];
+    /** The window reaches the last lesson — render an end-of-stream footer. */
+    complete: boolean;
+    /** Stable callback ref for lesson `i`'s block element (cached per index). */
+    refFor: (index: number) => (el: HTMLElement | null) => void;
+    /** Mount through lesson `i` (if needed) and scroll to it. */
+    goTo: (index: number) => void;
+    next: () => void;
+    prev: () => void;
+    reducedMotion: boolean;
+}
+/**
+ * Continuous reader for a sequence of lessons (a notebook): renders a growing
+ * window of lessons around the seed instead of all of them, and tracks the
+ * active one by viewport-center containment (invariant 1).
+ *
+ * - The lesson after the window mounts as the reader approaches its place;
+ *   the one before mounts near the top, and a layout effect compensates the
+ *   scroll so prepended content never shoves the reader down.
+ * - Navigation (`goTo`) expansions are NOT compensated — their scrollIntoView
+ *   is absolute, and compensating them displaced the landing.
+ * - The cursor is a useSteps core, so it composes with ChapterNav
+ *   (`active` + `goTo`) and LessonPager (`prev`/`next`).
+ *
+ * Headless: the consumer renders `mounted.map(i => <Block ref={refFor(i)} />)`
+ * and owns the content; pair blocks with `useFadeIn(i === seed)`.
+ */
+declare function useLessonStream(count: number, opts?: LessonStreamOptions): LessonStream;
+/**
+ * Mount fade for streamed blocks: `false` on the first client render, `true`
+ * a frame later (immediately with reduced motion). Pass `initiallyVisible`
+ * for server-rendered blocks (the stream's seed) so they never flash.
+ */
+declare function useFadeIn(initiallyVisible?: boolean): boolean;
+
+interface EvaluatorOptions {
+    /**
+     * "auto" (default) re-judges whenever `ctx` changes: a gate that opens the
+     * moment the reader does the thing. "manual" judges only on `check()`: a
+     * quiz with a Check button; changing `ctx` afterwards clears the verdict.
+     */
+    mode?: "auto" | "manual";
+}
+interface EvaluatorState {
+    /** "idle" until the first verdict (manual mode, or after `reset`). */
+    status: VerdictStatus | "idle";
+    feedback: ReactNode;
+    /** status === "pass". */
+    passed: boolean;
+    /** How many times `check()` ran, for "show a hint after two tries". */
+    attempts: number;
+    /** What the evaluator threw (the verdict is then "fail"). */
+    error: unknown;
+    /** Judge the current context now. Resolves with the verdict, or null if superseded. */
+    check: () => Promise<Verdict | null>;
+    /** Back to "idle", attempts to 0, any running check abandoned. */
+    reset: () => void;
+}
+/**
+ * Run an evaluator against a context and keep its verdict as state. Async
+ * evaluators report "pending" while they run; a newer check (or a context
+ * change) aborts the older one and drops its late result, so the verdict
+ * always describes the latest context. `check` and `reset` are
+ * referentially stable.
+ *
+ *   const answer = useEvaluator(
+ *     (guess: string | null) => (guess === truth ? pass("Right!") : fail("Look at the pivot again.")),
+ *     guess,
+ *     { mode: "manual" }
+ *   );
+ *   <button onClick={answer.check}>Check</button> {answer.feedback}
+ */
+declare function useEvaluator<Ctx>(evaluator: Evaluator<Ctx>, ctx: Ctx, opts?: EvaluatorOptions): EvaluatorState;
 
 interface GuidedTour {
     /** Active step index, or null when the tour is not running. */
@@ -107,6 +505,11 @@ interface GuidedTour {
      * the waitHint) so the user knows what is being waited on.
      */
     blocked: boolean;
+    /**
+     * The active step's gate feedback, when its gate returns a `Verdict` with
+     * one ("Stage at least one file"). Pass it to `TourCard`'s `feedback`.
+     */
+    feedback: ReactNode;
     start: () => void;
     end: () => void;
     next: () => void;
@@ -124,19 +527,6 @@ interface GuidedTourOptions {
      */
     driver?: TourDriver;
 }
-/**
- * Tour state whose steps are effects over app state: `onEnter` fires whenever
- * the active step changes, reading the latest `steps` via ref so closures stay
- * fresh without re-triggering the effect on every render. Composed on
- * useSteps — a tour is a step sequence whose `next` past the end exits.
- *
- * On top of the linear cursor, steps may declare `when` (skip on arrival),
- * `gate` (block `next` until true), and `next` (edge override by step id) —
- * a small state machine where states are steps, edges are `next` functions,
- * and guards are gates. The cursor itself stays a cursor: skipped steps are
- * never landed on, and skipped/gated behavior is evaluated at transition
- * time, not on every render.
- */
 declare function useGuidedTour(steps: TourStepInput[], opts?: GuidedTourOptions): GuidedTour;
 
 interface FlatChapter {
@@ -350,7 +740,7 @@ declare function StepScrubber({ count, index, toneAt, titleAt, onSeek, emptyHint
      */
     groupOf?: (i: number) => number;
 }): react.JSX.Element;
-declare function PlayerBar({ player, toneAt, titleAt, leading, onEmpty, emptyHint, className, theme, groupOf, labels, }: {
+declare function PlayerBar({ player, toneAt, titleAt, leading, onEmpty, emptyHint, className, theme, groupOf, labels, live, }: {
     player: {
         total: number;
         index: number;
@@ -360,10 +750,18 @@ declare function PlayerBar({ player, toneAt, titleAt, leading, onEmpty, emptyHin
         prev: () => void;
         toggle: (onEmpty?: () => void) => void;
         seek: (frame: number) => void;
+        live?: boolean;
+        goLive?: () => void;
     };
     toneAt?: (i: number) => StepTone;
     titleAt?: (i: number) => string;
     leading?: ReactNode;
+    /**
+     * Show the live-edge badge for a following player (`follow` option):
+     * "Live" at the edge, "Go live" with the frame count when the reader is
+     * behind.
+     */
+    live?: boolean;
     /** Fired when the user plays/steps with no timeline loaded. */
     onEmpty?: () => void;
     emptyHint?: string;
@@ -380,6 +778,8 @@ declare function PlayerBar({ player, toneAt, titleAt, leading, onEmpty, emptyHin
         pause?: string;
         replay?: string;
         next?: string;
+        live?: string;
+        goLive?: string;
     };
 }): react.JSX.Element;
 declare function ChapterNav({ chapters, active, onNavigate, hint, className, theme, }: {
@@ -410,7 +810,7 @@ declare function TourSpotlight({ target, theme, }: {
     target: string | null;
     theme?: StepwiseTheme;
 }): react.JSX.Element | null;
-declare function TourCard({ step, index, total, onNext, onBack, onEnd, labels, className, theme, nextDisabled, }: {
+declare function TourCard({ step, index, total, onNext, onBack, onEnd, labels, className, theme, nextDisabled, feedback, }: {
     step: TourStepInput;
     index: number;
     total: number;
@@ -428,6 +828,8 @@ declare function TourCard({ step, index, total, onNext, onBack, onEnd, labels, c
     theme?: StepwiseTheme;
     /** Disable the primary (Next/Finish) button — pair with tour.blocked. */
     nextDisabled?: boolean;
+    /** Gate feedback ("Stage a file first") — pair with tour.feedback. Announced politely. */
+    feedback?: ReactNode;
 }): react.JSX.Element;
 declare function ShortcutsDialog({ open, onClose, items, title, className, theme, }: {
     open: boolean;
@@ -438,4 +840,4 @@ declare function ShortcutsDialog({ open, onClose, items, title, className, theme
     theme?: StepwiseTheme;
 }): react.ReactPortal | null;
 
-export { Chapter, ChapterNav, type ChaptersApi, CodeBlock, type Discoveries, type DiscoveriesOptions, type DiscoveryStore, type FlatChapter, type GlobalKeysOptions, GlossaryAppendix, type GlossaryEntry, GlossaryProvider, type GuidedTour, type GuidedTourOptions, type KeyMap, LessonPager, PlayerBar, PlayerEngine, ShortcutItem, ShortcutsDialog, type StepPlayer, type StepPlayerOptions, StepScrubber, StepTone, type StepsCore, type StepwiseTheme, TONE_CHIP_CLASS, TONE_SEGMENT_CLASS, Term, TourCard, TourDriver, TourSpotlight, TourStepInput, type UseStepsOptions, cookieStore, defaultTheme, flattenChapters, localStorageStore, memoryStore, useChapters, useDiscoveries, useFocusTrap, useGlobalKeys, useGuidedTour, usePrefersReducedMotion, useStepPlayer, useSteps };
+export { type AlignedCell, type AlignedRow, Chapter, ChapterNav, type ChaptersApi, CodeBlock, type Discoveries, type DiscoveriesOptions, type DiscoveryStore, Evaluator, type EvaluatorOptions, type EvaluatorState, type FlatChapter, type GlobalKeysOptions, GlossaryAppendix, type GlossaryEntry, GlossaryProvider, type GuidedTour, type GuidedTourOptions, type KeyMap, LessonPager, type LessonStream, type LessonStreamOptions, PlayerBar, PlayerEngine, type Rng, ShortcutItem, ShortcutsDialog, type Simulation, type SimulationContext, type SimulationOptions, type SimulationPlayer, type SimulationResult, type SimulationRunOptions, type StepPlayer, type StepPlayerOptions, StepScrubber, StepTone, type StepsCore, StepwiseStep, type StepwiseTheme, type SyncedTracks, type SyncedTracksOptions, TONE_CHIP_CLASS, TONE_SEGMENT_CLASS, Term, TourCard, TourDriver, TourSpotlight, TourStepInput, type TraceBuilder, type TraceOptions, type TracePlayer, type TrackKeyFn, type TrackView, type Tracks, type UseStepsOptions, Verdict, VerdictStatus, alignTracks, cookieStore, createRng, createTrace, defaultTheme, flattenChapters, localStorageStore, memoryStore, readHashParam, reanchor, runSimulation, useChapters, useDiscoveries, useEvaluator, useFadeIn, useFocusTrap, useGlobalKeys, useGuidedTour, useLessonStream, usePrefersReducedMotion, useSimulation, useStepPlayer, useSteps, useSyncedTracks, useTrace, writeHashParam };