hayao 0.3.0 → 0.4.0

package/dist/world.d.ts

@@ -1,7 +1,7 @@
 import { Clock, type ClockConfig } from './core/clock';
 import { EventBus } from './core/events';
 import { Rng } from './core/rng';
-import { InputState } from './input/actions';
+import { InputState, type AxisFrame } from './input/actions';
 import { Node, type WorldContext } from './scene/node';
 import type { Camera2D } from './scene/nodes';
 import { type Transform, type Vec2 } from './core/math';
@@ -14,12 +14,18 @@ export interface WorldConfig {
     height?: number;
     /** Resolved tuning values (see app/tuning.ts). Sim state: hashed + snapshotted. */
     tuning?: Record<string, number | string>;
+    /**
+     * Dev guard: during each step(), `Math.random`/`Date.now` are wrapped so a
+     * stray call inside the sim warns ONCE (with a stack hint) instead of
+     * silently breaking determinism. Never throws; safe to leave on in tests.
+     */
+    guardDeterminism?: boolean;
 }
 /** Default engine event map; games extend it with their own keys. */
 export interface CoreEvents {
     [key: string]: unknown;
 }
-export declare class World implements WorldContext {
+export declare class World<TState extends Record<string, unknown> = Record<string, unknown>> implements WorldContext {
     readonly rng: Rng;
     readonly clock: Clock;
     readonly input: InputState;
@@ -31,15 +37,32 @@ export declare class World implements WorldContext {
      * `hash()` and `snapshot()`, so hidden state here cannot escape determinism
      * checks the way ad-hoc module variables can.
      */
-    state: Record<string, unknown>;
+    state: TState;
     readonly width: number;
     readonly height: number;
+    /**
+     * Pause switch. While true, only `pauseMode: 'always'` subtrees update —
+     * rendering, input sampling, and the clock keep ticking, so a pause menu
+     * (an 'always' subtree) stays live. Sim state: hashed + snapshotted, but
+     * only when true, so pinned hashes of unpaused games are unchanged.
+     */
+    paused: boolean;
+    /**
+     * Sim-time multiplier: the tree receives `clock.dt * timeScale` (slow-mo /
+     * fast-forward), while `'always'` subtrees get the unscaled dt so UI keeps
+     * realtime feel. The clock itself ticks normally. Hashed/snapshotted only
+     * when ≠ 1.
+     */
+    timeScale: number;
     root: Node;
     activeCamera: Camera2D | null;
     private seed;
     private freeQueue;
     private started;
     private tuningValues;
+    private guardDeterminism;
+    private warnedClamp;
+    private warnedNondet;
     constructor(config?: WorldConfig);
     /**
      * Read a tuning value resolved at world creation (declared default unless
@@ -47,6 +70,12 @@ export declare class World implements WorldContext {
      * silently read `undefined` into the sim.
      */
     tune<T extends number | string = number>(key: string): T;
+    /**
+     * Read a shared resource by key. Throws on a missing key (listing what IS
+     * available) — a typo here would otherwise silently read `undefined` into
+     * the sim, exactly like an undeclared tuning knob.
+     */
+    resource<T>(key: string): T;
     get time(): number;
     get frame(): number;
     /** Replace the scene root, entering the tree. */
@@ -57,7 +86,15 @@ export declare class World implements WorldContext {
      * Advance exactly one fixed step with the given actions held down.
      * This is THE deterministic transition — call it from Node or the browser loop.
      */
-    step(actionsDown?: Iterable<string>): void;
+    step(actionsDown?: Iterable<string>, axes?: AxisFrame): void;
+    /**
+     * Wrap `Math.random`/`Date.now` for the duration of a step so a stray call
+     * inside the sim warns ONCE per world (with a stack hint) — the values still
+     * flow through, so nothing breaks mid-frame. Returns the restore function;
+     * properly nested re-entry (a world stepped inside another's step) is safe
+     * because each install restores exactly what it replaced.
+     */
+    private installGuard;
     /**
      * Feed REAL elapsed ms; runs 0+ fixed steps. Returns steps run. This is the
      * realtime driver entry point — it CLAMPS realMs to the clock's maxFrameMs
@@ -65,14 +102,38 @@ export declare class World implements WorldContext {
      * not 72. For headless tests/harnesses that want to fast-forward an exact
      * number of steps, use `runSteps(n)` or `step()` — never `advance` with a big ms.
      */
-    advance(realMs: number, actionsDown?: Iterable<string>): number;
+    advance(realMs: number, actionsDown?: Iterable<string>, axes?: AxisFrame): number;
     /**
      * Run exactly `n` fixed steps — the deterministic fast-forward for tests and
      * headless drivers (unlike `advance`, no realtime clamp). Pass `actionsFor(i)`
      * to script the input per step; omit it to hold nothing down.
      */
-    runSteps(n: number, actionsFor?: (i: number) => Iterable<string>): void;
-    private flushFree;
+    runSteps(n: number, actionsFor?: (i: number) => Iterable<string>, axesFor?: (i: number) => AxisFrame | undefined): void;
+    /**
+     * Run pending frees NOW instead of at the end of the step. `free()` is
+     * deferred (safe during iteration), which means freed nodes survive until
+     * the step ends — during a scene swap that lets old nodes contaminate the
+     * first frame of the new scene. Pattern: `oldRoot.free(); world.flushFree();
+     * buildNewScene()`. Called automatically at the end of every step.
+     */
+    flushFree(): void;
+    /** Visit every live node depth-first (root first, child-index order). */
+    walk(fn: (node: Node) => void): void;
+    /** Total live nodes in the tree (root included). */
+    get nodeCount(): number;
+    /**
+     * One indented line per node — `name (type) [flags] @x,y` — for quick tree
+     * audits in a REPL or test failure message.
+     */
+    debugTree(): string;
+    /** The active camera's world position + zoom, or null (see WorldContext.camera). */
+    camera(): {
+        pos: {
+            x: number;
+            y: number;
+        };
+        zoom: number;
+    } | null;
     /** The view transform (inverse of the active camera), mapping world → screen. */
     viewTransform(): Transform;
     /**
@@ -108,4 +169,8 @@ export interface WorldSnapshot {
     tree: ReturnType<Node['serialize']>;
     /** Resolved tuning values (absent in pre-tuning saves). */
     tuning?: Record<string, number | string>;
+    /** Pause flag (absent when false — keeps old snapshots byte-identical). */
+    paused?: boolean;
+    /** Sim-time multiplier (absent when 1). */
+    timeScale?: number;
 }

package/docs/API.md

@@ -3,9 +3,9 @@
 > Auto-generated by `npm run api`. Everything importable from `@hayao`.
 > Grep here for the real surface — never guess an API from memory.
 
-**664 exports.**
+**717 exports.**
 
-## classs (52)
+## classs (59)
 
 - `AmbientField`
 - `AnimationPlayer`
@@ -17,13 +17,17 @@
 - `Canvas2DRenderer`
 - `CinematicPlayer`
 - `Clock`
+- `Coroutines`
+- `DepthSort`
 - `EventBus`
 - `FloatingText`
 - `Fsm`
+- `GamepadSource`
 - `HeadlessRenderer`
 - `InputBuffer`
 - `InputRecorder`
 - `InputState`
+- `IsoPrism`
 - `KeyboardSource`
 - `LocalStorageAdapter`
 - `LockstepSession`
@@ -57,10 +61,13 @@
 - `Text`
 - `TextureSprite`
 - `Timer`
+- `TouchControls`
 - `UndoStack`
+- `VerletChain`
+- `WebGL2Renderer`
 - `World`
 
-## functions (291)
+## functions (310)
 
 - `abilitiesOf`: (world: WorldGraphDef, taken: readonly string[]) => Set<string>
 - `addBody`: (rw: RigidWorld, def: RigidBodyDef) => number
@@ -68,7 +75,8 @@
 - `addRevoluteJoint`: (rw: RigidWorld, def: RevoluteJointDef) => number
 - `addTransition`: (parent: Node, config?: TransitionConfig) => ScreenTransition
 - `albumTrack`: (id: string) => AlbumTrack | undefined
-- `analyzePlaytest`: (def: GameDefinition, session: PlaytestSession, opts?: AnalyzeOptions) => PlaytestReport
+- `all`: (...waits: Wait[]) => Wait
+- `analyzePlaytest`: (def: GameDefinition<Record<string, unknown>>, session: PlaytestSession, opts?: AnalyzeOptions) => PlaytestReport
 - `applyImpulse`: (rw: RigidWorld, id: number, ix: number, iy: number, px?: number | undefined, py?: number | undefined) => void
 - `applyReverb`: (buf: StereoBuffer, opts?: ReverbOptions) => void
 - `applyTransform`: (m: Transform, p: Vec2) => Vec2
@@ -88,6 +96,7 @@
 - `blobPath`: (rng: Rng, radius: number, wobble?: number, lobes?: number) => string
 - `bodyAABB`: (b: RigidBody) => Rect
 - `bodyContains`: (b: RigidBody, x: number, y: number) => boolean
+- `bootDom`: (def: GameDefinition<Record<string, unknown>>, mount?: HTMLElement | undefined) => DomHarness
 - `cadenceResolves`: (romans: string[]) => boolean
 - `cameraIssues`: (samples: readonly Vec2[], opts?: CameraOptions) => string[]
 - `canvasGradient`: (ctx: { createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient; createRadialGradient(x0: number, y0: number, r0: number, x1: nu…
@@ -111,7 +120,7 @@
 - `createPlatformerState`: (x: number, y: number) => PlatformerState
 - `createRigidWorld`: (opts?: RigidWorldOpts) => RigidWorld
 - `createStereo`: (durationSec: number, sampleRate?: number) => StereoBuffer
-- `createWorld`: (def: GameDefinition, opts?: number | CreateWorldOptions | undefined) => World
+- `createWorld`: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition<TState>, opts?: number | CreateWorldOptions | undefined) => World<...>
 - `crestFactorDb`: (sig: Samples) => number
 - `dashJumpDistance`: (cfg?: PlatformerConfig) => number
 - `datan`: (x: number) => number
@@ -123,18 +132,19 @@
 - `decodeMessage`: (data: string) => NetMessage | null
 - `decodeRLE`: (runs: readonly number[], width: number, height: number) => PixelBuffer
 - `defaultStorage`: (prefix?: string | undefined) => StorageAdapter
-- `defineGame`: (def: GameDefinition) => Required<Pick<GameDefinition, "seed" | "width" | "height" | "inputMap" | "background">> & GameDefinition
+- `defineGame`: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition<TState>) => Required<Pick<GameDefinition<TState>, "seed" | "width" | "…
 - `defineLevel`: (spec: LevelSpec) => LevelData
 - `deserializeNode`: (data: SerializedNode) => Node
 - `dexp`: (x: number) => number
 - `dexp2`: (x: number) => number
 - `dhypot`: (x: number, y: number) => number
+- `diamondPoints`: (w: number, h: number) => number[]
 - `diatonicChord`: (tonic: number, mode: "major" | "minor" | "harmonicMinor" | "melodicMinor" | "dorian" | "phrygian" | "lydian" | "mixolydian" | "locrian" | "majorPentatonic" …
 - `diffLevels`: (a: LevelData, b: LevelData) => LevelChange[]
 - `distanceGain`: (model: DistanceModel, distance: number, refDistance?: number, maxDistance?: number, rolloff?: number) => number
 - `dlog`: (x: number) => number
 - `dpow`: (base: number, exp: number) => number
-- `drive`: (world: World, script: InputScript, until?: ((probe: Record<string, unknown>) => boolean) | undefined) => DriveResult
+- `drive`: (world: World<Record<string, unknown>>, script: InputScript, until?: ((probe: Record<string, unknown>) => boolean) | undefined) => DriveResult
 - `dropShadow`: (color: string, blur: number, dx?: number, dy?: number) => Shadow
 - `dsin`: (x: number) => number
 - `duckGain`: (active: boolean, amountDb?: number) => number
@@ -149,12 +159,14 @@
 - `fft`: (re: Float32Array<ArrayBufferLike>, im: Float32Array<ArrayBufferLike>) => void
 - `findSoftlocks`: (world: WorldGraphDef, mode?: CompletionMode) => SoftlockReport
 - `firstFrame`: (timeline: ProbeFrame[], pred: (p: ProbeFrame) => boolean) => number
+- `fitViewport`: (rect: { width: number; height: number; }, width: number, height: number) => Viewport
 - `floodFill`: (start: Cell, passable: Passable, opts: { cols: number; rows: number; diagonal?: boolean | undefined; }) => Cell[]
 - `fluxEnvelope`: (sig: Samples, frameSize?: number, hop?: number) => Float32Array<ArrayBufferLike>
 - `forgivenessIssues`: (spec: ForgivenessSpec, opts?: ForgivenessOptions) => string[]
 - `fractalNoise`: (x: number, y: number, seed?: number, opts?: FractalOptions) => number
 - `frameActions`: (log: InputLog, i: number) => string[]
-- `gameInputMap`: (def: GameDefinition) => InputMap
+- `frameAxes`: (log: InputLog, i: number) => AxisFrame | undefined
+- `gameInputMap`: (def: GameDefinition<Record<string, unknown>>) => Readonly<Record<string, readonly string[]>>
 - `generateCave`: (rng: Rng, opts: CaveOptions) => Grid
 - `generateDungeon`: (rng: Rng, opts: DungeonOptions) => Dungeon
 - `generateLevels`: <State, Move>(factory: (rng: Rng) => Puzzle<State, Move>, opts: GenerateOptions<State, Move>) => GeneratedLevel<State, Move>[]
@@ -171,6 +183,7 @@
 - `gridSet`: (g: Grid, x: number, y: number, v: number) => void
 - `gridToTilemap`: (g: Grid, tileSize?: number) => TilemapData
 - `groundAt`: (map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[], dropThrough?: boolean) => { grounded: boolean; solid: number; }
+- `hashNoise`: (...values: number[]) => number
 - `hashString`: (str: string) => number
 - `hashValue`: (value: unknown) => string
 - `hexToHsl`: (hex: string) => HSL
@@ -182,17 +195,19 @@
 - `initDirector`: (waves: readonly WaveDef[]) => DirectorState
 - `inputDensity`: (frames: string[][]) => number
 - `installCapture`: (target: CaptureTarget) => HayaoCapture
+- `invalidCommandReason`: (c: DrawCommand) => string | null
 - `invertTransform`: (m: Transform) => Transform
 - `inVisionCone`: (map: TilemapData, ex: number, ey: number, faceX: number, faceY: number, fov: number, range: number, tx: number, ty: number) => boolean
 - `isCaptureMode`: () => boolean
 - `isGround`: (col: number, row: number, opts: TerrainOptions) => boolean
 - `isMonotonic`: (values: number[], dir: "up" | "down", slack?: number) => boolean
+- `iso`: (cfg: IsoConfig) => IsoProjection
 - `joinRoom`: (opts: RoomClientOptions) => Promise<NetGame>
 - `jumpAirtime`: (cfg?: PlatformerConfig) => number
 - `jumpDistance`: (cfg?: PlatformerConfig) => number
 - `jumpHeight`: (cfg?: PlatformerConfig) => number
 - `keyMentions`: (code: string) => string[]
-- `keysToActions`: (map: InputMap, keysDown: Set<string>) => string[]
+- `keysToActions`: (map: Readonly<Record<string, readonly string[]>>, keysDown: Set<string>) => string[]
 - `layerGains`: (layers: MusicLayer[], intensity: number) => Record<string, number>
 - `layoutIssues`: (commands: DrawCommand[], opts?: LayoutOptions) => string[]
 - `layoutText`: (font: BitmapFont, input: string | readonly RichChar[], options?: TextLayoutOptions) => TextLayout
@@ -219,13 +234,14 @@
 - `mergePlayerFrames`: (players: readonly string[], inputs: ReadonlyMap<string, readonly string[]>) => string[]
 - `midiToFreq`: (midi: number, a4?: number) => number
 - `midiToName`: (midi: number) => string
-- `missingControlHints`: (world: World, inputMap: InputMap) => string[]
+- `missingControlHints`: (world: World<Record<string, unknown>>, inputMap: Readonly<Record<string, readonly string[]>>) => string[]
 - `mix`: (a: string, b: string, t: number) => string
 - `mixLinear`: (a: string, b: string, t: number) => string
 - `mixMono`: (bus: StereoBuffer, sig: Samples, startSample: number, gain?: number, pan?: number) => void
 - `moveRect`: (map: TilemapData, rect: Rect, dx: number, dy: number, opts?: MoveOpts) => MoveResult
 - `mutateColor`: (rng: Rng, hex: string, amounts?: DriftAmounts) => string
 - `netMessage`: <T extends Omit<NetMessage, "v">>(msg: T) => T & { v: number; }
+- `nextStep`: () => Wait
 - `nineSlice`: (rect: Rect, style: NineSliceStyle, z?: number, transform?: Transform) => DrawCommand[]
 - `normalize`: (buf: StereoBuffer, target?: number) => void
 - `noteToMidi`: (name: string) => number
@@ -251,7 +267,9 @@
 - `progressionPuzzle`: (world: WorldGraphDef, mode?: CompletionMode) => Puzzle<ProgressState, ProgressMove>
 - `proveCompletable`: (world: WorldGraphDef) => SolveResult<ProgressMove>
 - `proveFullCompletion`: (world: WorldGraphDef) => SolveResult<ProgressMove>
-- `pump`: (world: World, frames: number, actions?: string[]) => void
+- `pump`: (world: World<Record<string, unknown>>, frames: number, actions?: string[]) => void
+- `quantizeAngle`: (radians: number, buckets: number) => number
+- `race`: (...waits: Wait[]) => Wait
 - `radialGradient`: (stops: readonly StopInput[], opts?: { cx?: number | undefined; cy?: number | undefined; r?: number | undefined; }) => RadialGradient
 - `rampIssues`: (difficulty: readonly number[], opts?: RampOptions) => string[]
 - `rampStats`: (difficulty: readonly number[]) => RampStats
@@ -259,23 +277,25 @@
 - `raycastTiles`: (map: TilemapData, x0: number, y0: number, x1: number, y1: number) => RayHit
 - `reachableRegions`: (world: WorldGraphDef, abilities: Iterable<string>) => string[]
 - `reconstructPath`: <N>(cameFrom: Map<string, N>, key: NodeKey<N>, start: N, goal: N) => N[]
-- `recordTimeline`: (world: World, frames: string[][]) => ProbeFrame[]
+- `recordTimeline`: (world: World<Record<string, unknown>>, frames: string[][]) => ProbeFrame[]
 - `rectBlocked`: (map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[]) => boolean
 - `rectContains`: (r: Rect, p: Vec2) => boolean
 - `rectsOverlap`: (a: Rect, b: Rect) => boolean
 - `registerNode`: (type: string, factory: NodeFactory) => void
 - `regularPolygon`: (sides: number, radius: number, rotation?: number) => number[]
+- `regularPolyPoints`: (sides: number, r: number, rotation?: number) => number[]
 - `relLuminance`: (hex: string) => number
 - `removeBody`: (rw: RigidWorld, id: number) => void
 - `removeJoint`: (rw: RigidWorld, id: number) => void
 - `renderAudioFilmstrip`: (buf: StereoBuffer, opts?: AudioFilmstripOptions) => string
-- `renderFilmstrip`: (world: World, frames: string[][], opts: FilmstripOptions) => string
+- `renderFilmstrip`: (world: World<Record<string, unknown>>, frames: string[][], opts: FilmstripOptions) => string
 - `renderSong`: (song: Song, opts?: { sampleRate?: number | undefined; normalizePeak?: number | undefined; }) => StereoBuffer
 - `renderSound`: (spec: SoundSpec, opts?: { rng?: Rng | undefined; sampleRate?: number | undefined; }) => Samples
 - `renderToSVGString`: (commands: DrawCommand[], width: number, height: number, background?: string) => string
 - `replay`: (makeWorld: WorldFactory, log: InputLog) => { finalHash: string; hashes: string[]; }
-- `replaySession`: (def: GameDefinition, session: PlaytestSession, opts?: number | ReplayOptions | undefined) => World
+- `replaySession`: (def: GameDefinition<Record<string, unknown>>, session: PlaytestSession, opts?: number | ReplayOptions | undefined) => World<...>
 - `resetNodeIds`: (start?: number) => void
+- `resetZzfxWarnings`: () => void
 - `resolveTuning`: (spec: TuningSpec | undefined, overrides?: TuningValues | undefined) => TuningValues
 - `rigidStep`: (rw: RigidWorld, dt: number) => ContactEvent[]
 - `rleDecode`: (input: string) => string
@@ -283,11 +303,11 @@
 - `rms`: (sig: Samples) => number
 - `roomCenter`: (r: Room) => { x: number; y: number; }
 - `rootless`: (chord: number[], targetMidi?: number | undefined) => number[]
-- `runBrowser`: (def: GameDefinition, mount: HTMLElement, opts?: RunOptions) => GameHandle
-- `runBrowserNet`: (def: GameDefinition, mount: HTMLElement, opts: NetRunOptions) => NetGameHandle
+- `runBrowser`: (def: GameDefinition<Record<string, unknown>>, mount: HTMLElement, opts?: RunOptions) => GameHandle
+- `runBrowserNet`: (def: GameDefinition<Record<string, unknown>>, mount: HTMLElement, opts: NetRunOptions) => NetGameHandle
 - `runFeelGates`: (spec: FeelSpec, ctx?: FeelContext) => FeelReport
-- `runHeadless`: (def: GameDefinition, inputLog?: InputLog | undefined) => HeadlessResult
-- `runStudio`: (baseDef: GameDefinition, mount: HTMLElement, opts?: StudioOptions) => StudioHandle
+- `runHeadless`: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition<TState>, inputLog?: InputLog | undefined) => HeadlessResult<TState>
+- `runStudio`: (baseDef: GameDefinition<Record<string, unknown>>, mount: HTMLElement, opts?: StudioOptions) => StudioHandle
 - `salienceIssues`: (commands: DrawCommand[], avatarFill: string, background: string, opts?: SalienceOptions) => string[]
 - `sampleGradient`: (stops: readonly string[], t: number) => string
 - `scaleMidis`: (tonic: number, mode?: "major" | "minor" | "harmonicMinor" | "melodicMinor" | "dorian" | "phrygian" | "lydian" | "mixolydian" | "locrian" | "majorPentatonic"…
@@ -295,20 +315,23 @@
 - `scatter`: (x: number, y: number, probability: number, seed?: number) => boolean
 - `scatterCells`: (x0: number, y0: number, cols: number, rows: number, probability: number, seed?: number) => { x: number; y: number; }[]
 - `scoreTrack`: (buf: StereoBuffer, profile: GenreProfile) => QualityScore
-- `scriptedPlaythrough`: (world: World, script: Segment[]) => PlaythroughResult
+- `scriptedPlaythrough`: (world: World<Record<string, unknown>>, script: Segment[]) => PlaythroughResult
 - `scriptToFrames`: (script: InputScript) => string[][]
-- `scrubTo`: (world: World, def: GameDefinition, ring: SnapshotRing, inputFrames: readonly string[][], axesLog: readonly (readonly [number, string, number])[], knobEvents…
+- `scrubTo`: (world: World<Record<string, unknown>>, def: GameDefinition<Record<string, unknown>>, ring: SnapshotRing, inputFrames: readonly string[][], axesLog: readonly…
 - `serializeSnapshot`: (snap: WorldSnapshot) => string
 - `series`: (timeline: ProbeFrame[], key: string) => unknown[]
 - `setOverlayHost`: (el: HTMLElement) => void
 - `setScreenObserver`: (cb: ((kind: "show" | "hide", title?: string | undefined) => void) | null) => void
+- `shadeHex`: (hex: string, f: number) => string
 - `shadowDef`: (s: Shadow, id: string) => string
 - `shapeBBox`: (c: DrawCommand) => BBox | null
 - `shapeBox`: (cmd: DrawCommand) => { x: number; y: number; w: number; h: number; } | null
 - `showScreen`: (spec: ScreenSpec) => ScreenHandle
 - `signalHash`: (sig: Samples) => number
+- `sleep`: (seconds: number) => Wait
 - `smoothClosedPath`: (points: Vec2[], tension?: number) => string
 - `smoothOpenPath`: (points: Vec2[], tension?: number) => string
+- `snapAxis`: (value: number, buckets: number, min?: number, max?: number) => number
 - `softClip`: (x: number) => number
 - `softClipInPlace`: (buf: StereoBuffer) => void
 - `solidNeighbours`: (g: Grid, x: number, y: number) => number
@@ -318,6 +341,7 @@
 - `songDuration`: (song: Song) => number
 - `sortCommands`: (cmds: DrawCommand[]) => DrawCommand[]
 - `spatialMix`: (dx: number, dy: number, hearing?: number, rolloff?: number) => SpatialMix
+- `specFromZzfx`: (p: readonly (number | undefined)[]) => SoundSpec
 - `spectralCentroid`: (sig: Samples, sampleRate?: number) => number
 - `springStep`: (s: SpringState, target: number, omega: number, dt: number) => SpringState
 - `star`: (points: number, outer: number, inner: number, rotation?: number) => number[]
@@ -344,8 +368,10 @@
 - `vnorm`: (a: Vec2) => Vec2
 - `voiceLead`: (chords: number[][]) => number[][]
 - `wait`: (frames: number) => Segment
+- `waitFor`: (cond: () => boolean) => Wait
 - `wakeBody`: (b: RigidBody) => void
 - `wangTile`: (mask: number) => WangTile
+- `warnCommandOnce`: (kind: string, reason: string, detail?: unknown) => void
 - `weatherEnvelope`: (t: number, keys: readonly WeatherKey[]) => number
 - `weightedIndex`: (rng: Rng, weights: readonly number[]) => number
 - `weightedPick`: <T>(rng: Rng, items: readonly T[], weights: readonly number[]) => T
@@ -354,7 +380,7 @@
 - `worldPoints`: (b: RigidBody) => number[]
 - `zcr`: (sig: Samples, sampleRate?: number) => number
 
-## interfaces (222)
+## interfaces (240)
 
 - `AcceptedProof`
 - `ActBounds`
@@ -364,6 +390,7 @@
 - `AnalyzeOptions`
 - `Annotation`
 - `AnnotationContext`
+- `ArcCommand`
 - `AudioAssertion`
 - `AudioExpectation`
 - `AudioFeatures`
@@ -396,18 +423,22 @@
 - `ContourOptions`
 - `ContourSegment`
 - `CoreEvents`
+- `CoroutineHandle`
 - `CreateWorldOptions`
 - `DeathCluster`
+- `DepthSortConfig`
 - `DesyncInfo`
 - `DeterminismReport`
 - `DifficultyBand`
 - `DirectorState`
 - `DistanceJoint`
 - `DistanceJointDef`
+- `DomHarness`
 - `DriftAmounts`
 - `DriveResult`
 - `Dungeon`
 - `DungeonOptions`
+- `EllipseCommand`
 - `FeatureDelta`
 - `FeedbackOptions`
 - `FeedbackResponse`
@@ -422,6 +453,7 @@
 - `FutileVerb`
 - `GameDefinition`
 - `GameHandle`
+- `GamepadSourceOptions`
 - `GeneratedLevel`
 - `GenerateOptions`
 - `GenerateReport`
@@ -436,6 +468,10 @@
 - `HSL`
 - `ImageCommand`
 - `InputLog`
+- `InputSource`
+- `IsoConfig`
+- `IsoPrismConfig`
+- `IsoProjection`
 - `JointScratch`
 - `KnobEvent`
 - `LayoutOptions`
@@ -480,8 +516,10 @@
 - `PlaytestSession`
 - `PlaythroughResult`
 - `PointerReadout`
+- `PointerSourceOptions`
 - `PointerTarget`
 - `PolyCommand`
+- `PostProcessPass`
 - `ProgressState`
 - `Puzzle`
 - `QualityScore`
@@ -552,6 +590,9 @@
 - `TimelineEntry`
 - `TimerConfig`
 - `Tone`
+- `TouchButton`
+- `TouchControlsLayout`
+- `TouchStick`
 - `Track`
 - `Transform`
 - `Transition`
@@ -563,11 +604,14 @@
 - `Variant`
 - `VariantRef`
 - `Vec2`
+- `VerletChainConfig`
+- `Viewport`
 - `Volumes`
 - `WallClockMark`
 - `WangTile`
 - `WaveDef`
 - `WeatherKey`
+- `WebGLRendererConfig`
 - `WeightedEdge`
 - `WeightedEntry`
 - `WipeOptions`
@@ -579,8 +623,9 @@
 - `WorldRegion`
 - `WorldSnapshot`
 
-## types (41)
+## types (46)
 
+- `AxisFrame`
 - `BodyKind`
 - `BoolGrid`
 - `CompletionMode`
@@ -592,6 +637,7 @@
 - `EndReason`
 - `FeedbackChannel`
 - `FeedbackContract`
+- `GamepadMap`
 - `Gradient`
 - `InputMap`
 - `InputScript`
@@ -603,6 +649,7 @@
 - `NodeFactory`
 - `NodeKey`
 - `Passable`
+- `PauseMode`
 - `Pitch`
 - `PlayerId`
 - `ProbeFrame`
@@ -617,19 +664,23 @@
 - `TileId`
 - `TuningValue`
 - `TuningValues`
+- `UniformValue`
+- `Wait`
 - `WangFrame`
 - `Wave`
 - `WeightedNeighbours`
 - `WipeKind`
 - `WorldFactory`
 
-## consts (57)
+## consts (61)
 
 - `ALBUM`: { title: string; subtitle: string; concept: string; tracks: AlbumTrack[]; }
 - `AMBIENT_PRESETS`: { readonly snow: (colors?: string[]) => AmbientStyle; readonly rain: (colors?: string[]) => AmbientStyle; readonly ash: (colors?: string[]) => AmbientStyle; }
 - `audio`: AudioBus
+- `BLOOM_PIPELINE`: PostProcessPass[]
 - `clamp`: (v: number, lo: number, hi: number) => number
-- `DEFAULT_INPUT_MAP`: InputMap
+- `DEFAULT_GAMEPAD_MAP`: GamepadMap
+- `DEFAULT_INPUT_MAP`: Readonly<Record<string, readonly string[]>>
 - `DEFAULT_PLATFORMER`: PlatformerConfig
 - `DEFAULT_SESSION_CONFIG`: NetSessionConfig
 - `DEFAULT_TILE_CHARS`: Record<string, TileId>
@@ -652,6 +703,7 @@
 - `mapHeight`: (map: TilemapData) => number
 - `mapWidth`: (map: TilemapData) => number
 - `MEADOW`: Palette
+- `MOUSE_ACTIONS`: readonly ["mouse.left", "mouse.right", "mouse.middle"]
 - `NEIGHBORS_4`: readonly Cell[]
 - `NEIGHBORS_8`: readonly Cell[]
 - `NET_PROTOCOL_VERSION`: 1
@@ -661,7 +713,7 @@
 - `PAPER`: Palette
 - `PARTICLE_PRESETS`: { readonly dust: (colors?: string[]) => ParticleStyle; readonly burst: (colors?: string[]) => ParticleStyle; readonly hit: (colors?: string[]) => ParticleSty…
 - `playerAction`: (player: string, action: string) => string
-- `playerInput`: (world: World, player: string) => PlayerInput
+- `playerInput`: (world: World<Record<string, unknown>>, player: string) => PlayerInput
 - `rad2deg`: (r: number) => number
 - `remap`: (v: number, a0: number, a1: number, b0: number, b1: number) => number
 - `SAMPLE_RATE`: 44100
@@ -678,10 +730,11 @@
 - `vdist`: (a: Vec2, b: Vec2) => number
 - `vdot`: (a: Vec2, b: Vec2) => number
 - `vec2`: (x?: number, y?: number) => Vec2
-- `VERSION`: "0.3.0"
+- `VERSION`: "0.4.0"
 - `vlen`: (a: Vec2) => number
 - `vscale`: (a: Vec2, s: number) => Vec2
 - `vsub`: (a: Vec2, b: Vec2) => Vec2
+- `WEBGL_EFFECTS`: { readonly passthrough: "#version 300 es\nprecision mediump float;\nin vec2 v_uv;\nuniform sampler2D u_scene;\nuniform sampler2D u_prev;\nout vec4 fragColor;…
 
 ## exports (1)