hayao 0.1.0 → 0.2.0

package/dist/logic/fsm.d.ts

@@ -0,0 +1,85 @@
+/** Per-state lifecycle hooks. All optional; all pure over the shared context. */
+export interface StateHandlers<C> {
+    /** Ran once when the machine enters this state. */
+    onEnter?(ctx: C): void;
+    /** Ran every `update(dt)` while in this state. */
+    onUpdate?(ctx: C, dt: number): void;
+    /** Ran once when the machine leaves this state. */
+    onLeave?(ctx: C): void;
+}
+/**
+ * A guarded edge. `from` is a source state or `'*'` (any). Edges are evaluated
+ * in table order every tick; the first whose `when` returns true fires. Keep
+ * the table ordered — order IS the tie-break, so the machine stays hash-stable.
+ */
+export interface Transition<S extends string, C> {
+    from: S | '*';
+    to: S;
+    when(ctx: C): boolean;
+}
+export declare class Fsm<S extends string, C> {
+    private readonly states;
+    private readonly transitions;
+    private readonly ctx;
+    /** The active state key — this is the whole serializable state. */
+    current: S;
+    constructor(states: Record<S, StateHandlers<C>>, transitions: readonly Transition<S, C>[], initial: S, ctx: C);
+    /**
+     * Advance one fixed step: fire the first satisfied transition (if any), then
+     * run the current state's `onUpdate`. A transition runs its target's
+     * `onUpdate` this same tick, so entering and acting aren't a frame apart.
+     */
+    update(dt: number): void;
+    /** Force a transition (fires onLeave/onEnter). No-op if already there. */
+    go(to: S): void;
+    /** True when in one of the given states. */
+    is(...states: S[]): boolean;
+    /** Serialize (games persist this in `world.state`; the handlers are code). */
+    getState(): S;
+    /** Restore without firing enter/leave (it's a resume, not a transition). */
+    setState(state: S): void;
+}
+/** Eased progress curve `[0,1] → [0,1]`. Identity by default. */
+export type Ease = (t: number) => number;
+/** A timed phase: how long it lasts and (optionally) what follows it. */
+export interface PhaseDef {
+    /** Duration in seconds (same units as the `dt` you feed `update`). */
+    duration: number;
+    /** Successor phase when this one elapses. Omit for a terminal phase. */
+    next?: string;
+}
+/**
+ * A phase with a countdown and an eased progress readout. Drives discrete
+ * logical steps (each phase = one settled move) while exposing `progress()` for
+ * the view to interpolate between the old and new position — so animation
+ * timing rides on the same deterministic clock as the logic.
+ */
+export declare class PhaseClock {
+    private readonly defs;
+    /** Current phase key — serializable with `elapsed`. */
+    phase: string;
+    /** Seconds spent in the current phase so far. */
+    elapsed: number;
+    constructor(defs: Record<string, PhaseDef>, initial: string);
+    private get duration();
+    /** Eased fraction 0→1 through the current phase (clamped). For cosmetic interp. */
+    progress(ease?: Ease): number;
+    /** True once the current phase's duration has fully elapsed. */
+    get done(): boolean;
+    /**
+     * Advance by `dt`. When a phase completes and has a `next`, roll into it
+     * (carrying any overshoot so long phases don't drift). Returns true on the
+     * tick a new phase begins — the game's cue to commit the next logical step.
+     */
+    update(dt: number): boolean;
+    /** Jump to a phase and reset its timer (fresh `onEnter`-style restart). */
+    to(phase: string): void;
+    getState(): {
+        phase: string;
+        elapsed: number;
+    };
+    setState(state: {
+        phase: string;
+        elapsed: number;
+    }): void;
+}

package/dist/logic/graph.d.ts

@@ -0,0 +1,88 @@
+import { type TilemapData } from '../physics/tilemap';
+/** Neighbours of a node, in deterministic order. */
+export type Neighbours<N> = (node: N) => N[];
+/** Stable string identity for a node (visited-set + path keys). */
+export type NodeKey<N> = (node: N) => string;
+export interface BfsResult<N> {
+    /** Nodes in expansion order (breadth-first). */
+    order: N[];
+    /** key → the node it was first reached from (for path reconstruction). */
+    cameFrom: Map<string, N>;
+    /** key → steps from the start (start = 0). */
+    dist: Map<string, number>;
+}
+/**
+ * Breadth-first search from `start`. Explores the whole reachable component
+ * unless `goal` short-circuits it. `maxNodes` caps work on huge/open graphs.
+ */
+export declare function bfs<N>(start: N, neighbours: Neighbours<N>, key: NodeKey<N>, opts?: {
+    goal?: (n: N) => boolean;
+    maxNodes?: number;
+}): BfsResult<N>;
+/** Reconstruct the path start→goal from a `cameFrom` map, or [] if unreachable. */
+export declare function reconstructPath<N>(cameFrom: Map<string, N>, key: NodeKey<N>, start: N, goal: N): N[];
+/** A neighbour with the step cost to reach it (must be ≥ 0). */
+export interface WeightedEdge<N> {
+    node: N;
+    cost: number;
+}
+export type WeightedNeighbours<N> = (node: N) => WeightedEdge<N>[];
+/**
+ * A* (Dijkstra when `heuristic` is omitted/zero) over a weighted adjacency
+ * function. Returns the least-cost path start→goal (inclusive) or null.
+ * Tie-broken by insertion order via a monotonic counter → identical path on
+ * every engine.
+ */
+export declare function astar<N>(start: N, isGoal: (n: N) => boolean, neighbours: WeightedNeighbours<N>, key: NodeKey<N>, opts?: {
+    heuristic?: (n: N) => number;
+    maxNodes?: number;
+}): {
+    path: N[];
+    cost: number;
+} | null;
+export interface Cell {
+    x: number;
+    y: number;
+}
+/** 4-neighbour offsets (N, E, S, W), in a fixed order. */
+export declare const NEIGHBORS_4: readonly Cell[];
+/** 8-neighbour offsets (orthogonals then diagonals), in a fixed order. */
+export declare const NEIGHBORS_8: readonly Cell[];
+/** Is a cell walkable? Called for in-bounds cells only. */
+export type Passable = (x: number, y: number) => boolean;
+/**
+ * Flood-fill from a seed cell over `passable`, returning every reachable cell
+ * in breadth-first (deterministic) order. The classic bucket-fill / region-grab.
+ */
+export declare function floodFill(start: Cell, passable: Passable, opts: {
+    cols: number;
+    rows: number;
+    diagonal?: boolean;
+}): Cell[];
+export interface Components {
+    /** Row-major label per cell: -1 for impassable, else a component id ≥ 0. */
+    labels: number[];
+    /** Cells of each component, indexed by id, each in row-major order. */
+    cells: Cell[][];
+}
+/**
+ * Label connected regions of passable cells. Scans row-major and flood-fills
+ * each unlabeled passable cell, so component ids are assigned deterministically
+ * (top-left region first). Region/cluster detection for match-3, territory, etc.
+ */
+export declare function connectedComponents(cols: number, rows: number, passable: Passable, diagonal?: boolean): Components;
+/**
+ * Grid A* / Dijkstra. Returns the least-cost cell path start→goal (inclusive)
+ * or null if unreachable. Default step cost is 1 (orthogonal) / √2 (diagonal);
+ * pass `cost(x,y)` to weight terrain. Heuristic defaults to Manhattan (4-dir)
+ * or octile (8-dir) — admissible, integer-stable, so paths reproduce exactly.
+ */
+export declare function astarGrid(start: Cell, goal: Cell, passable: Passable, opts: {
+    cols: number;
+    rows: number;
+    diagonal?: boolean;
+    cost?: (x: number, y: number) => number;
+    maxNodes?: number;
+}): Cell[] | null;
+/** Build a `Passable` from a tilemap: everything but SOLID/out-of-bounds walks. */
+export declare function passableFromTilemap(map: TilemapData): Passable;

package/dist/logic/history.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A memento stack for undo/redo over snapshots of pure state. Call `record()`
+ * after every committed move; `undo()`/`redo()` walk the cursor. States are
+ * cloned in and out so callers can freely mutate what they get back. Capacity is
+ * bounded — the oldest entry is dropped once `limit` is exceeded (undo has a
+ * horizon, memory doesn't grow without bound).
+ */
+export declare class UndoStack<S> {
+    private history;
+    private cursor;
+    private readonly limit;
+    private readonly clone;
+    constructor(opts?: {
+        limit?: number;
+        clone?: (s: S) => S;
+    });
+    /** Push a new state as the present, discarding any redo branch ahead of it. */
+    record(state: S): void;
+    /** Step back one state and return a clone of it (undefined if nothing to undo). */
+    undo(): S | undefined;
+    /** Step forward one state and return a clone of it (undefined if nothing to redo). */
+    redo(): S | undefined;
+    /** A clone of the current state, or undefined if empty. */
+    current(): S | undefined;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** Number of recorded states retained. */
+    get size(): number;
+    clear(): void;
+}
+/**
+ * A fixed-capacity ring buffer — the ghost/echo trail. Push a pose (or any value)
+ * each frame; when full, the oldest is overwritten. `toArray()` returns
+ * oldest→newest, which is exactly the order a trail renderer wants (tail first,
+ * head last). Pure and O(1) per push.
+ */
+export declare class RingBuffer<T> {
+    readonly capacity: number;
+    private readonly buf;
+    private start;
+    private count;
+    constructor(capacity: number);
+    push(item: T): void;
+    /** Number of items currently held (≤ capacity). */
+    get length(): number;
+    get isFull(): boolean;
+    /** Item by age index: 0 = oldest, length-1 = newest. Undefined if out of range. */
+    at(i: number): T | undefined;
+    /** The most recently pushed item, or undefined if empty. */
+    latest(): T | undefined;
+    /** Contents oldest→newest. */
+    toArray(): T[];
+    clear(): void;
+}

package/dist/logic/random.d.ts

@@ -0,0 +1,32 @@
+import type { Rng } from '../core/rng';
+/** One weighted option: a value and its relative weight (≥ 0). */
+export interface WeightedEntry<T> {
+    value: T;
+    weight: number;
+}
+/**
+ * Pick an index in [0, weights.length) with probability ∝ weights[i]. Draws
+ * exactly one `rng.float()` and walks the weights in order, so the choice is a
+ * pure function of the RNG state. Throws if no weight is positive.
+ */
+export declare function weightedIndex(rng: Rng, weights: readonly number[]): number;
+/** Pick `items[i]` with probability ∝ `weights[i]` (parallel arrays). */
+export declare function weightedPick<T>(rng: Rng, items: readonly T[], weights: readonly number[]): T;
+/** Pick the value of one weighted entry. */
+export declare function pickEntry<T>(rng: Rng, entries: readonly WeightedEntry<T>[]): T;
+/**
+ * A reusable loot/spawn table. Precomputes cumulative weights once so repeated
+ * rolls are cheap; every draw still comes from the passed `Rng`, keeping the
+ * table itself stateless and the randomness owned by `world.rng`.
+ */
+export declare class LootTable<T> {
+    private readonly values;
+    /** Cumulative (prefix-sum) weights; last element is the total. */
+    private readonly cumulative;
+    readonly total: number;
+    constructor(entries: readonly WeightedEntry<T>[]);
+    /** One draw with replacement. */
+    roll(rng: Rng): T;
+    /** `n` independent draws with replacement, in order. */
+    rollMany(rng: Rng, n: number): T[];
+}

package/dist/net/browser.d.ts

@@ -0,0 +1,37 @@
+import type { GameDefinition } from '../app/game';
+import { KeyboardSource } from '../input/source';
+import type { World } from '../world';
+import type { Transport } from './transport';
+import type { NetSessionConfig } from './protocol';
+import type { NetGame, RoomCallbacks } from './room';
+import type { PlayerId } from './players';
+export interface NetRunOptions extends RoomCallbacks {
+    transport: Transport;
+    /** 'host' owns the lobby (first tab); 'join' connects to it. */
+    role: 'host' | 'join';
+    seed?: number;
+    config?: Partial<NetSessionConfig>;
+    maxPlayers?: number;
+    /** Re-attach behaviors after any restore (rollback / late join). */
+    attach?: (world: World) => void;
+    renderer?: 'svg' | 'canvas';
+    /** Lobby feedback ("waiting for players…", "connected as p2"). */
+    onStatus?: (status: string) => void;
+}
+export interface NetGameHandle {
+    /** Host only: freeze the lobby and start the game. No-op for joiners. */
+    start(): void;
+    /** The live game once running (null while in the lobby). */
+    readonly game: NetGame | null;
+    readonly localPlayer: PlayerId | null;
+    readonly roster: PlayerId[];
+    input: KeyboardSource;
+    stop(): void;
+}
+/**
+ * Run a game as a networked session. Host flow: call, wait for peers
+ * (onPlayerJoin fires), then `handle.start()`. Join flow: call — the render
+ * loop begins automatically when the host starts (or immediately mid-game
+ * via snapshot late join).
+ */
+export declare function runBrowserNet(def: GameDefinition, mount: HTMLElement, opts: NetRunOptions): NetGameHandle;

package/dist/net/inputBuffer.d.ts

@@ -0,0 +1,27 @@
+import type { PlayerId } from './players';
+export declare class InputBuffer {
+    /** player → frame → actions (sorted). */
+    private frames;
+    /** player → highest contiguous frame received (for prediction + confirm). */
+    private contiguous;
+    addPlayer(player: PlayerId): void;
+    removePlayer(player: PlayerId): void;
+    players(): PlayerId[];
+    /**
+     * Record a player's actions for a frame. Returns true if this was new
+     * information (first write for that slot).
+     */
+    set(player: PlayerId, frame: number, actions: readonly string[]): boolean;
+    has(player: PlayerId, frame: number): boolean;
+    get(player: PlayerId, frame: number): string[] | undefined;
+    /** The last actions at or before `frame` — the rollback predictor's guess. */
+    latestAt(player: PlayerId, frame: number): string[];
+    /** Highest frame such that this player's inputs 0..frame are all known. */
+    contiguousThrough(player: PlayerId): number;
+    /** Highest frame with ALL players' inputs known contiguously. */
+    confirmedFrame(): number;
+    /** Forget a player's frames at/after `frame` (leave cutoff). */
+    clearFrom(player: PlayerId, frame: number): void;
+    /** Drop history strictly before `frame` (memory hygiene on long sessions). */
+    prune(frame: number): void;
+}

package/dist/net/lockstep.d.ts

@@ -0,0 +1,79 @@
+import type { World } from '../world';
+import type { InputLog } from '../input/actions';
+import { type PlayerId } from './players';
+import { type NetSessionConfig } from './protocol';
+import type { Transport } from './transport';
+export interface DesyncInfo {
+    frame: number;
+    player: PlayerId;
+    localHash: string;
+    remoteHash: string;
+    /** Merged frames from this session's startFrame — replay fodder. */
+    log: InputLog;
+    startFrame: number;
+}
+export interface LockstepOptions {
+    world: World;
+    transport: Transport;
+    localPlayer: PlayerId;
+    /** Roster at startFrame, in canonical order. */
+    players: PlayerId[];
+    /** Frame this session begins at (0 for a fresh game, >0 for a late joiner). */
+    startFrame?: number;
+    config?: Partial<NetSessionConfig>;
+    onDesync?: (info: DesyncInfo) => void;
+    /** Fired when a step is blocked waiting on a player's input. */
+    onStall?: (player: PlayerId, frame: number) => void;
+}
+export declare class LockstepSession {
+    readonly world: World;
+    readonly localPlayer: PlayerId;
+    readonly config: NetSessionConfig;
+    readonly startFrame: number;
+    private readonly transport;
+    private readonly buffer;
+    private roster;
+    private mergedLog;
+    private localHashes;
+    private pendingRemoteHashes;
+    private sentThrough;
+    private stallCount;
+    private desynced;
+    private afterStepListeners;
+    private unsubscribe;
+    private readonly onDesync?;
+    private readonly onStall?;
+    constructor(opts: LockstepOptions);
+    activePlayers(frame: number): PlayerId[];
+    /** All peers must call this with the SAME atFrame (the room layer's job). */
+    addPlayer(player: PlayerId, atFrame: number): void;
+    /** All peers must call this with the SAME atFrame. */
+    removePlayer(player: PlayerId, atFrame: number): void;
+    get frame(): number;
+    /** Highest frame every currently-active player's input is known for. */
+    get confirmedFrame(): number;
+    get stalls(): number;
+    /**
+     * Try to advance exactly one frame with the local player's current actions.
+     * Returns 1 if the world stepped, 0 if blocked waiting for a remote input.
+     */
+    tick(localActions?: readonly string[]): number;
+    /**
+     * Feed real elapsed ms (the browser loop's dt). Runs the fixed steps the
+     * clock grants — stalling drops time (the sim slows rather than desyncs) —
+     * then catches up if we're measurably behind the other peers.
+     */
+    advance(realMs: number, localActions?: readonly string[]): number;
+    /** The merged input log from startFrame — replayable when startFrame is 0. */
+    inputLog(): InputLog;
+    dispose(): void;
+    /** Feed a raw transport message that arrived before this session existed. */
+    deliver(data: string): void;
+    /** Subscribe to "the world just reached frame N" (room layer uses this). */
+    onAfterStep(cb: (frame: number) => void): () => void;
+    private scheduleLocal;
+    private afterStep;
+    private receive;
+    private checkPendingHashes;
+    private remoteFrameEstimate;
+}

package/dist/net/players.d.ts

@@ -0,0 +1,27 @@
+import type { World } from '../world';
+/** A player identity: 'p1', 'p2', … (any short string without ':' works). */
+export type PlayerId = string;
+/** The canonical roster for n players: ['p1', …, 'pn']. */
+export declare function playerIds(count: number): PlayerId[];
+/** Namespace one action for a player: ('p2', 'left') → 'p2:left'. */
+export declare const playerAction: (player: PlayerId, action: string) => string;
+/**
+ * Merge per-player action sets into one flat, sorted frame for `world.step()`.
+ * Deterministic: players are processed in roster order and the result is sorted,
+ * so every peer computes the identical frame from the same inputs.
+ */
+export declare function mergePlayerFrames(players: readonly PlayerId[], inputs: ReadonlyMap<PlayerId, readonly string[]>): string[];
+/**
+ * A per-player view over the world's input state. Game logic asks
+ * `player.isDown('left')` and never sees the namespacing.
+ */
+export declare class PlayerInput {
+    private readonly world;
+    readonly player: PlayerId;
+    constructor(world: World, player: PlayerId);
+    isDown(action: string): boolean;
+    justPressed(action: string): boolean;
+    justReleased(action: string): boolean;
+}
+/** Convenience: the input view for one player. */
+export declare const playerInput: (world: World, player: PlayerId) => PlayerInput;

package/dist/net/protocol.d.ts

@@ -0,0 +1,100 @@
+import type { WorldSnapshot } from '../world';
+import type { PlayerId } from './players';
+export declare const NET_PROTOCOL_VERSION = 1;
+/** Session tuning shared by every peer (the host dictates it in `welcome`). */
+export interface NetSessionConfig {
+    mode: 'lockstep' | 'rollback';
+    /** Frames of input delay (lockstep) — hides transport latency. */
+    inputDelay: number;
+    /** Exchange a state hash every N frames to catch desyncs early. */
+    hashInterval: number;
+    /** Rollback: how many frames of history can be rewound. */
+    maxRollback: number;
+    /** How many recent frames each input message re-sends (loss tolerance). */
+    redundancy: number;
+}
+export declare const DEFAULT_SESSION_CONFIG: NetSessionConfig;
+export type NetMessage = 
+/** A new endpoint asks to join. `uid` is its transport-unique id. */
+{
+    v: number;
+    t: 'hello';
+    uid: string;
+    name?: string;
+}
+/** Host → one endpoint: your player id + everything needed to start/join. */
+ | {
+    v: number;
+    t: 'welcome';
+    to: string;
+    player: PlayerId;
+    players: PlayerId[];
+    seed: number;
+    config: NetSessionConfig;
+    /** Frame the joiner starts at (0 for a fresh game). */
+    startFrame: number;
+    /** Mid-game join: the world state at `startFrame`. */
+    snapshot?: WorldSnapshot;
+    /** Other joins announced but not yet live (their bootstrap frames). */
+    joins?: Array<{
+        player: PlayerId;
+        atFrame: number;
+    }>;
+}
+/** Host → all: a player will exist from `atFrame` on (late join). */
+ | {
+    v: number;
+    t: 'join';
+    player: PlayerId;
+    atFrame: number;
+}
+/** Host → all: a player's inputs end at `atFrame` (disconnect/quit). */
+ | {
+    v: number;
+    t: 'leave';
+    player: PlayerId;
+    atFrame: number;
+}
+/** Host → all: begin simulating from frame 0 with this final roster. */
+ | {
+    v: number;
+    t: 'start';
+    players: PlayerId[];
+}
+/** Any endpoint → host: polite disconnect. */
+ | {
+    v: number;
+    t: 'bye';
+    uid: string;
+}
+/** Host → one endpoint: join refused (room full, mode without late join…). */
+ | {
+    v: number;
+    t: 'deny';
+    to: string;
+    reason: string;
+}
+/** Player inputs for frames [from, from+frames.length). Re-sends a small
+ *  window so a dropped message doesn't stall anyone. */
+ | {
+    v: number;
+    t: 'input';
+    player: PlayerId;
+    from: number;
+    frames: string[][];
+}
+/** Structural world hash at a frame — cross-checked by every peer. */
+ | {
+    v: number;
+    t: 'hash';
+    player: PlayerId;
+    frame: number;
+    hash: string;
+};
+export declare function encodeMessage(msg: NetMessage): string;
+/** Decode + shallow-validate. Returns null for junk or version mismatch. */
+export declare function decodeMessage(data: string): NetMessage | null;
+/** Build a message with the protocol version stamped in. */
+export declare function netMessage<T extends Omit<NetMessage, 'v'>>(msg: T): T & {
+    v: number;
+};

package/dist/net/rollback.d.ts

@@ -0,0 +1,89 @@
+import type { World } from '../world';
+import type { InputLog } from '../input/actions';
+import { type PlayerId } from './players';
+import { type NetSessionConfig } from './protocol';
+import type { Transport } from './transport';
+import type { DesyncInfo } from './lockstep';
+export interface RollbackOptions {
+    world: World;
+    transport: Transport;
+    localPlayer: PlayerId;
+    players: PlayerId[];
+    config?: Partial<NetSessionConfig>;
+    /** Re-attach behaviors/controllers after every restore (save/load hook). */
+    attach?: (world: World) => void;
+    onDesync?: (info: DesyncInfo) => void;
+    /** A correction arrived deeper than maxRollback — unrecoverable. */
+    onRollbackOverflow?: (frame: number) => void;
+}
+export declare class RollbackSession {
+    readonly world: World;
+    readonly localPlayer: PlayerId;
+    readonly config: NetSessionConfig;
+    private readonly transport;
+    private readonly players;
+    private readonly buffer;
+    private readonly attach?;
+    private readonly onDesync?;
+    private readonly onRollbackOverflow?;
+    /** Snapshot AT frame f (state before stepping f), keyed f % ring length. */
+    private ring;
+    /** What we actually fed `step()` per frame — prediction bookkeeping. */
+    private usedInputs;
+    private earliestBad;
+    private rollbackCount;
+    private resimulatedFrames;
+    private localHashes;
+    /** player → cutoff frame: their inputs are [] from there on (departed). */
+    private dropped;
+    private pendingRemoteHashes;
+    private hashedThrough;
+    private desynced;
+    private overflowed;
+    private unsubscribe;
+    constructor(opts: RollbackOptions);
+    get frame(): number;
+    /** Highest frame all players' real inputs are known for (inclusive). */
+    get confirmedFrame(): number;
+    /** Highest contiguous frame received from `player` — the drop-cutoff basis. */
+    lastKnownFrame(player: PlayerId): number;
+    /**
+     * A player left (or vanished): their inputs are [] from `atFrame` on, so the
+     * session stops waiting on them. All peers must apply the SAME atFrame (the
+     * room layer broadcasts it). Frames already simulated with a non-empty
+     * prediction for the departed player roll back and re-simulate as usual.
+     */
+    removePlayer(player: PlayerId, atFrame: number): void;
+    get stats(): {
+        rollbacks: number;
+        resimulatedFrames: number;
+    };
+    /**
+     * Advance one frame: publish local input, apply any pending correction,
+     * then step with confirmed-or-predicted inputs. Returns 1 unless the sim
+     * has outrun its rollback window (backpressure) or is desynced.
+     */
+    tick(localActions?: readonly string[]): number;
+    /** Feed real elapsed ms; runs the fixed steps the clock grants. */
+    advance(realMs: number, localActions?: readonly string[]): number;
+    /** Merged CONFIRMED input log from frame 0 — replayable ground truth. */
+    inputLog(): InputLog;
+    dispose(): void;
+    /** Feed a raw transport message that arrived before this session existed. */
+    deliver(data: string): void;
+    private publishLocal;
+    private inputsFor;
+    private stepFrame;
+    /** Apply pending corrections. False = overflow (fatal). */
+    private resolveCorrections;
+    private storeSnapshot;
+    private receive;
+    /**
+     * Hash exchange runs on CONFIRMED frames only (predicted state is
+     * provisional by design). A snapshot has exactly the shape `world.hash()`
+     * hashes, so ring entries give us hashes of past frames for free.
+     */
+    private settleHashes;
+    private compareHashes;
+    private pruneOld;
+}