hayao 0.1.0

package/dist/scene/tween.d.ts

@@ -0,0 +1,20 @@
+import { Node } from './node';
+export type Easing = (t: number) => number;
+export declare const EASINGS: Record<string, Easing>;
+/** A node that runs one or more property tweens and reports when they finish. */
+export declare class AnimationPlayer extends Node {
+    readonly type = "AnimationPlayer";
+    private tracks;
+    /**
+     * Animate a value from → to over `duration` seconds via `apply(value)`.
+     * Returns this for chaining.
+     */
+    to(apply: (v: number) => void, from: number, to: number, duration: number, ease?: keyof typeof EASINGS | Easing, opts?: {
+        delay?: number;
+        onDone?: () => void;
+    }): this;
+    get active(): boolean;
+    /** Signal emitted when all tracks complete. */
+    get finished(): import("..").Signal<void>;
+    protected onProcess(dt: number): void;
+}

package/dist/ui/overlay.d.ts

@@ -0,0 +1,25 @@
+export interface MenuAction {
+    label: string;
+    onSelect: () => void;
+    primary?: boolean;
+}
+export interface ScreenSpec {
+    title?: string;
+    /** Subtitle / body text (plain text or HTML string). */
+    body?: string;
+    /** Menu actions, navigable with up/down + Enter. */
+    actions?: MenuAction[];
+    /** Dim the game behind the screen. */
+    dim?: boolean;
+    /** Extra class for theming. */
+    className?: string;
+}
+export interface ScreenHandle {
+    close(): void;
+    readonly element: HTMLElement;
+}
+/** Set the element overlays mount into (defaults to document.body). */
+export declare function setOverlayHost(el: HTMLElement): void;
+/** Show a screen (replaces any current one). Returns a handle. */
+export declare function showScreen(spec: ScreenSpec): ScreenHandle;
+export declare function hideScreen(): void;

package/dist/ui/settings.d.ts

@@ -0,0 +1,23 @@
+export interface Settings {
+    master: number;
+    music: number;
+    sfx: number;
+    muted: boolean;
+    colorblind: boolean;
+    reducedMotion: boolean;
+}
+type Sub = (s: Settings) => void;
+declare class SettingsStore {
+    private state;
+    private subs;
+    constructor();
+    get(): Settings;
+    set(patch: Partial<Settings>): void;
+    subscribe(fn: Sub): () => void;
+    private pushToAudio;
+    private load;
+    private save;
+}
+export declare const settings: SettingsStore;
+export declare function toggleFullscreen(): void;
+export {};

package/dist/ui/shell.d.ts

@@ -0,0 +1,19 @@
+export interface ShellOptions {
+    onRestart?: () => void;
+    onQuit?: () => void;
+    /** Called with true when paused, false when resumed. */
+    onPause?: (paused: boolean) => void;
+    title?: string;
+}
+export declare class Shell {
+    private paused;
+    private opts;
+    private keyHandler;
+    constructor(opts?: ShellOptions);
+    get isPaused(): boolean;
+    toggle(): void;
+    pause(): void;
+    resume(): void;
+    private render;
+    dispose(): void;
+}

package/dist/verify/bot.d.ts

@@ -0,0 +1,21 @@
+export interface BotCtx {
+    /** Frames spent in the current step. */
+    frames: number;
+    /** Free per-step scratch (cleared on step change). */
+    mem: Record<string, unknown>;
+    /** Advance to the next plan step. */
+    next(): void;
+    /** Restart the current step (retry) — clears frames + mem. */
+    retry(): void;
+}
+export type StepExec<Step, Probe> = (step: Step, probe: Probe, out: string[], ctx: BotCtx) => void;
+export interface PlanBot<Probe> {
+    (probe: Probe): string[];
+    stepIndex(): number;
+    done(): boolean;
+}
+export declare function createPlanBot<Step extends {
+    kind: string;
+}, Probe>(plan: Step[], execs: Record<string, StepExec<Step, Probe>>): PlanBot<Probe>;
+/** Shared steering helper: 4/8-way movement toward a point. */
+export declare function steer2D(px: number, py: number, tx: number, ty: number, out: string[], dead?: number): void;

package/dist/verify/capture.d.ts

@@ -0,0 +1,21 @@
+import type { World } from '../world';
+export interface CaptureTarget {
+    readonly world: World;
+    /** Advance one fixed step with the given actions and render. */
+    stepOnce(actions?: string[]): void;
+    /** Current frame as an SVG string (a vector screenshot). */
+    renderSVG(): string;
+    setPaused(paused: boolean): void;
+}
+export interface HayaoCapture {
+    pump(frames: number, actions?: string[]): Record<string, unknown>;
+    probe(): Record<string, unknown>;
+    hash(): string;
+    shot(): string;
+    save(path: string): Promise<boolean>;
+    key(type: 'keydown' | 'keyup', code: string): void;
+    readonly world: World;
+}
+export declare function isCaptureMode(): boolean;
+/** Install window.__hayao for scripted browser verification. */
+export declare function installCapture(target: CaptureTarget): HayaoCapture;

package/dist/verify/determinism.d.ts

@@ -0,0 +1,29 @@
+import type { World } from '../world';
+import type { InputLog } from '../input/actions';
+export type WorldFactory = () => World;
+/** Run a world through an input log, returning the final hash and per-frame hashes. */
+export declare function replay(makeWorld: WorldFactory, log: InputLog): {
+    finalHash: string;
+    hashes: string[];
+};
+export interface DeterminismReport {
+    ok: boolean;
+    frames: number;
+    /** First frame index where the two runs diverged, or -1. */
+    divergedAt: number;
+    finalHash: string;
+}
+/** Run twice and compare every step's hash. */
+export declare function checkDeterministic(makeWorld: WorldFactory, log: InputLog): DeterminismReport;
+/** Assert determinism (throws with the divergence frame). */
+export declare function assertDeterministic(makeWorld: WorldFactory, log: InputLog): DeterminismReport;
+/**
+ * Assert that restoring a snapshot reproduces the exact same continuation —
+ * i.e. save/load is lossless. Runs `warmup` steps, snapshots, runs `tail` more
+ * on both the original and a restored copy, and compares final hashes.
+ */
+export declare function assertSnapshotStable(makeWorld: WorldFactory, log: InputLog, warmup: number): {
+    ok: boolean;
+    hashA: string;
+    hashB: string;
+};

package/dist/verify/driver.d.ts

@@ -0,0 +1,23 @@
+import type { World } from '../world';
+export interface ScriptSegment {
+    /** Actions held down for every frame of this segment. */
+    hold?: string[];
+    /** Actions pressed only on the first frame of this segment (taps). */
+    press?: string[];
+    /** How many fixed steps this segment lasts (default 1). */
+    frames?: number;
+}
+export type InputScript = ScriptSegment[];
+/** Expand a script into per-frame action arrays (an InputLog's frames). */
+export declare function scriptToFrames(script: InputScript): string[][];
+export interface DriveResult {
+    frames: number;
+    /** True if driving stopped early because `until` matched. */
+    matched: boolean;
+}
+/**
+ * Step a world through a script. Pass `until` to stop as soon as a probe
+ * predicate holds (e.g. level solved) — the tail of the script is slack, so
+ * playthrough scripts don't need frame-perfect lengths.
+ */
+export declare function drive(world: World, script: InputScript, until?: (probe: Record<string, unknown>) => boolean): DriveResult;

package/dist/verify/feel.d.ts

@@ -0,0 +1,25 @@
+import type { World } from '../world';
+export type ProbeFrame = Record<string, unknown>;
+/**
+ * Step a world through per-frame action arrays, probing after every step.
+ * Returns frames.length + 1 probes: index 0 is the pre-step state, index i is
+ * the state after frame i. (With the default 60Hz clock, index / 60 = sim
+ * seconds.) For a segment-level timeline use scriptedPlaythrough instead.
+ */
+export declare function recordTimeline(world: World, frames: string[][]): ProbeFrame[];
+/** First timeline index where `pred` holds, or -1 if it never does. */
+export declare function firstFrame(timeline: ProbeFrame[], pred: (p: ProbeFrame) => boolean): number;
+/** The value of one probe key across the timeline. */
+export declare function series(timeline: ProbeFrame[], key: string): unknown[];
+/** Timeline indices where `key`'s value differs from the previous frame — an event cadence. */
+export declare function changeFrames(timeline: ProbeFrame[], key: string): number[];
+/** Monotonic within slack: 'up' means every value ≥ previous − slack. */
+export declare function isMonotonic(values: number[], dir: 'up' | 'down', slack?: number): boolean;
+/**
+ * Fraction of frames carrying at least one action — a crude engagement proxy.
+ * Near 0 the player is waiting; near 1 they are mashing; a tuned game usually
+ * lives somewhere in between (set the window per genre).
+ */
+export declare function inputDensity(frames: string[][]): number;
+/** Largest gap (in frames) between consecutive events — dead-air detector. */
+export declare function longestLull(eventFrames: number[], totalFrames: number): number;

package/dist/verify/filmstrip.d.ts

@@ -0,0 +1,19 @@
+import type { World } from '../world';
+export interface FilmstripOptions {
+    /** The game's view size (defineGame width/height). */
+    width: number;
+    height: number;
+    background?: string;
+    /** How many panels to sample across the run (default 12, min 2). */
+    panels?: number;
+    /** Panels per row (default 4). */
+    cols?: number;
+    /** Rendered width of one panel in px (default 320). */
+    panelWidth?: number;
+}
+/**
+ * Step `world` through per-frame actions, sampling evenly spaced panels
+ * (always including the first and last frame), and return one standalone SVG.
+ * Panel labels are frame numbers plus sim seconds at the 60Hz convention.
+ */
+export declare function renderFilmstrip(world: World, frames: string[][], opts: FilmstripOptions): string;

package/dist/verify/playthrough.d.ts

@@ -0,0 +1,21 @@
+import type { World } from '../world';
+export interface Segment {
+    /** Actions held down for this segment. */
+    actions?: string[];
+    /** Number of fixed steps to run. */
+    frames: number;
+}
+/** Build a segment: hold `actions` for `frames` steps. */
+export declare function hold(actions: string[], frames: number): Segment;
+/** Build an idle segment (no input) for `frames` steps. */
+export declare function wait(frames: number): Segment;
+export interface PlaythroughResult {
+    totalFrames: number;
+    finalHash: string;
+    /** Probe snapshot after each segment. */
+    probes: Record<string, unknown>[];
+}
+/** Run a scripted playthrough; returns a probe after each segment. */
+export declare function scriptedPlaythrough(world: World, script: Segment[]): PlaythroughResult;
+/** Convenience: advance a world N frames with a fixed input set. */
+export declare function pump(world: World, frames: number, actions?: string[]): void;

package/dist/verify/solver.d.ts

@@ -0,0 +1,37 @@
+export interface Puzzle<State, Move> {
+    /** Starting state (optionally per level index). */
+    initial(level?: number): State;
+    /** Legal moves from a state, in deterministic order. */
+    moves(state: State): Move[];
+    /** Apply a player move (may fold in a deterministic opponent response). */
+    apply(state: State, move: Move): State;
+    /** Win test. */
+    isWin(state: State): boolean;
+    /** Optional dead/lost test — pruned from the search. */
+    isDead?(state: State): boolean;
+    /** Canonical key for de-duplication (visited set). */
+    key(state: State): string;
+}
+export interface SolveResult<Move> {
+    solvable: boolean;
+    /** Shortest winning move sequence, if found. */
+    path?: Move[];
+    /** Depth of the shortest solution. */
+    depth?: number;
+    /** Nodes expanded (a difficulty/complexity proxy). */
+    nodes: number;
+    /** True if the search hit a cap before proving/​disproving. */
+    exhausted: boolean;
+}
+export interface SolveOptions {
+    level?: number;
+    maxDepth?: number;
+    nodeCap?: number;
+}
+/** Breadth-first search → the shortest solution and a real winnability proof. */
+export declare function solve<State, Move>(puzzle: Puzzle<State, Move>, options?: SolveOptions): SolveResult<Move>;
+/**
+ * Assert a puzzle level is winnable (throws with detail if not). Use in tests as
+ * the content-balance gate.
+ */
+export declare function assertSolvable<State, Move>(puzzle: Puzzle<State, Move>, options?: SolveOptions): SolveResult<Move>;

package/dist/world.d.ts

@@ -0,0 +1,75 @@
+import { Clock, type ClockConfig } from './core/clock';
+import { EventBus } from './core/events';
+import { Rng } from './core/rng';
+import { InputState } from './input/actions';
+import { Node, type WorldContext } from './scene/node';
+import type { Camera2D } from './scene/nodes';
+import { type Transform } from './core/math';
+import type { DrawCommand } from './render/commands';
+export interface WorldConfig {
+    seed?: number;
+    clock?: ClockConfig;
+    /** Design-space dimensions (default 1280×720). */
+    width?: number;
+    height?: number;
+}
+/** Default engine event map; games extend it with their own keys. */
+export interface CoreEvents {
+    [key: string]: unknown;
+}
+export declare class World implements WorldContext {
+    readonly rng: Rng;
+    readonly clock: Clock;
+    readonly input: InputState;
+    readonly events: EventBus<CoreEvents>;
+    readonly resources: Map<string, unknown>;
+    /**
+     * Canonical game state that lives OUTSIDE the scene tree (pure-sim structs,
+     * controllers). Must be plain JSON-serializable data: it is included in
+     * `hash()` and `snapshot()`, so hidden state here cannot escape determinism
+     * checks the way ad-hoc module variables can.
+     */
+    state: Record<string, unknown>;
+    readonly width: number;
+    readonly height: number;
+    root: Node;
+    activeCamera: Camera2D | null;
+    private seed;
+    private freeQueue;
+    private started;
+    constructor(config?: WorldConfig);
+    get time(): number;
+    get frame(): number;
+    /** Replace the scene root, entering the tree. */
+    setRoot(node: Node): void;
+    requestFree(node: Node): void;
+    private ensureStarted;
+    /**
+     * 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;
+    /** Feed real elapsed ms; runs 0+ fixed steps. Returns steps run. */
+    advance(realMs: number, actionsDown?: Iterable<string>): number;
+    private flushFree;
+    /** The view transform (inverse of the active camera), mapping world → screen. */
+    viewTransform(): Transform;
+    /** Project the whole scene to a display list (already camera-applied). */
+    render(): DrawCommand[];
+    /** Deterministic structural hash of the whole sim state. */
+    hash(): string;
+    /** Compact snapshot for undo/time-travel and saves. */
+    snapshot(): WorldSnapshot;
+    /** Restore a snapshot. Rebuilds the tree from data (behaviors are re-attached by scene code). */
+    restore(snap: WorldSnapshot): void;
+    /** A compact probe snapshot for the verification harness (override-friendly). */
+    probe(): Record<string, unknown>;
+}
+export interface WorldSnapshot {
+    seed: number;
+    rng: ReturnType<Rng['getState']>;
+    clock: ReturnType<Clock['getState']>;
+    input: ReturnType<InputState['getState']>;
+    state: Record<string, unknown>;
+    tree: ReturnType<Node['serialize']>;
+}

package/docs/API.md

@@ -0,0 +1,226 @@
+# hayao.js — Public API digest
+
+> Auto-generated by `npm run api`. Everything importable from `@hayao`.
+> Grep here for the real surface — never guess an API from memory.
+
+**201 exports.**
+
+## classs (22)
+
+- `AnimationPlayer`
+- `AudioBus`
+- `Camera2D`
+- `Canvas2DRenderer`
+- `Clock`
+- `EventBus`
+- `HeadlessRenderer`
+- `InputRecorder`
+- `InputState`
+- `KeyboardSource`
+- `Node`
+- `Particles`
+- `Rng`
+- `Shaker`
+- `Shell`
+- `Signal`
+- `SpatialHash`
+- `Sprite`
+- `SvgRenderer`
+- `Text`
+- `Timer`
+- `World`
+
+## functions (73)
+
+- `applyTransform`: (m: Transform, p: Vec2) => Vec2
+- `asciiEntities`: (rowsAscii: string[], tileSize?: number, chars?: Record<string, TileId>) => { char: string; tx: number; ty: number; x: number; y: number; }[]
+- `assertDeterministic`: (makeWorld: WorldFactory, log: InputLog) => DeterminismReport
+- `assertSnapshotStable`: (makeWorld: WorldFactory, log: InputLog, warmup: number) => { ok: boolean; hashA: string; hashB: string; }
+- `assertSolvable`: <State, Move>(puzzle: Puzzle<State, Move>, options?: SolveOptions) => SolveResult<Move>
+- `blobPath`: (rng: Rng, radius: number, wobble?: number, lobes?: number) => string
+- `changeFrames`: (timeline: ProbeFrame[], key: string) => number[]
+- `checkDeterministic`: (makeWorld: WorldFactory, log: InputLog) => DeterminismReport
+- `commandsToSVGInner`: (commands: DrawCommand[]) => string
+- `composeTransform`: (m: Transform, n: Transform) => Transform
+- `createPlanBot`: <Step extends { kind: string; }, Probe>(plan: Step[], execs: Record<string, StepExec<Step, Probe>>) => PlanBot<Probe>
+- `createPlatformerState`: (x: number, y: number) => PlatformerState
+- `createWorld`: (def: GameDefinition, seedOverride?: number | undefined) => World
+- `dashJumpDistance`: (cfg?: PlatformerConfig) => number
+- `defineGame`: (def: GameDefinition) => Required<Pick<GameDefinition, "width" | "height" | "seed" | "inputMap" | "background">> & GameDefinition
+- `deserializeNode`: (data: SerializedNode) => Node
+- `drive`: (world: World, script: InputScript, until?: ((probe: Record<string, unknown>) => boolean) | undefined) => DriveResult
+- `firstFrame`: (timeline: ProbeFrame[], pred: (p: ProbeFrame) => boolean) => number
+- `frameActions`: (log: InputLog, i: number) => string[]
+- `gameInputMap`: (def: GameDefinition) => InputMap
+- `groundAt`: (map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[], dropThrough?: boolean) => { grounded: boolean; solid: number; }
+- `hashString`: (str: string) => number
+- `hashValue`: (value: unknown) => string
+- `hideScreen`: () => void
+- `hold`: (actions: string[], frames: number) => Segment
+- `inputDensity`: (frames: string[][]) => number
+- `installCapture`: (target: CaptureTarget) => HayaoCapture
+- `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
+- `isMonotonic`: (values: number[], dir: "up" | "down", slack?: number) => boolean
+- `jumpAirtime`: (cfg?: PlatformerConfig) => number
+- `jumpDistance`: (cfg?: PlatformerConfig) => number
+- `jumpHeight`: (cfg?: PlatformerConfig) => number
+- `keysToActions`: (map: InputMap, keysDown: Set<string>) => string[]
+- `lineOfSight`: (map: TilemapData, ax: number, ay: number, bx: number, by: number) => boolean
+- `longestLull`: (eventFrames: number[], totalFrames: number) => number
+- `makeTransform`: (pos: Vec2, rotation: number, scale: Vec2) => Transform
+- `mix`: (a: string, b: string, t: number) => string
+- `moveRect`: (map: TilemapData, rect: Rect, dx: number, dy: number, opts?: MoveOpts) => MoveResult
+- `pump`: (world: World, frames: number, actions?: string[]) => void
+- `raycastTiles`: (map: TilemapData, x0: number, y0: number, x1: number, y1: number) => RayHit
+- `recordTimeline`: (world: World, 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[]
+- `renderFilmstrip`: (world: World, frames: string[][], opts: FilmstripOptions) => string
+- `renderToSVGString`: (commands: DrawCommand[], width: number, height: number, background?: string) => string
+- `replay`: (makeWorld: WorldFactory, log: InputLog) => { finalHash: string; hashes: string[]; }
+- `resetNodeIds`: (start?: number) => void
+- `runBrowser`: (def: GameDefinition, mount: HTMLElement, opts?: RunOptions) => GameHandle
+- `runHeadless`: (def: GameDefinition, inputLog?: InputLog | undefined) => HeadlessResult
+- `scriptedPlaythrough`: (world: World, script: Segment[]) => PlaythroughResult
+- `scriptToFrames`: (script: InputScript) => string[][]
+- `series`: (timeline: ProbeFrame[], key: string) => unknown[]
+- `setOverlayHost`: (el: HTMLElement) => void
+- `showScreen`: (spec: ScreenSpec) => ScreenHandle
+- `smoothClosedPath`: (points: Vec2[], tension?: number) => string
+- `smoothOpenPath`: (points: Vec2[], tension?: number) => string
+- `solve`: <State, Move>(puzzle: Puzzle<State, Move>, options?: SolveOptions) => SolveResult<Move>
+- `sortCommands`: (cmds: DrawCommand[]) => DrawCommand[]
+- `star`: (points: number, outer: number, inner: number, rotation?: number) => number[]
+- `steer2D`: (px: number, py: number, tx: number, ty: number, out: string[], dead?: number) => void
+- `stepPlatformer`: (s: PlatformerState, input: PadInput, dt: number, map: TilemapData, cfg?: PlatformerConfig, platforms?: Platform[]) => PlatformerEvents
+- `tileAt`: (map: TilemapData, tx: number, ty: number) => number
+- `tileAtPoint`: (map: TilemapData, x: number, y: number) => number
+- `tilemapFromAscii`: (rowsAscii: string[], tileSize?: number, chars?: Record<string, TileId>) => TilemapData
+- `toggleFullscreen`: () => void
+- `vnorm`: (a: Vec2) => Vec2
+- `wait`: (frames: number) => Segment
+- `withAlpha`: (hex: string, alpha: number) => string
+
+## interfaces (62)
+
+- `Behavior`
+- `BotCtx`
+- `CameraConfig`
+- `CaptureTarget`
+- `CircleCommand`
+- `ClockConfig`
+- `CoreEvents`
+- `DeterminismReport`
+- `DriveResult`
+- `FilmstripOptions`
+- `GameDefinition`
+- `GameHandle`
+- `HayaoCapture`
+- `HeadlessResult`
+- `ImageCommand`
+- `InputLog`
+- `MenuAction`
+- `MoveOpts`
+- `MoveResult`
+- `NodeConfig`
+- `PadInput`
+- `Paint`
+- `Palette`
+- `ParticleStyle`
+- `PathCommand`
+- `PlanBot`
+- `Platform`
+- `PlatformerConfig`
+- `PlatformerEvents`
+- `PlatformerState`
+- `PlaythroughResult`
+- `PolyCommand`
+- `Puzzle`
+- `RayHit`
+- `Rect`
+- `RectCommand`
+- `Renderer`
+- `RendererConfig`
+- `RngState`
+- `RunOptions`
+- `ScreenHandle`
+- `ScreenSpec`
+- `ScriptSegment`
+- `Segment`
+- `SerializedNode`
+- `Settings`
+- `ShellOptions`
+- `SolidRect`
+- `SolveOptions`
+- `SolveResult`
+- `SpriteConfig`
+- `TextCommand`
+- `TextConfig`
+- `TilemapData`
+- `TimerConfig`
+- `Tone`
+- `Transform`
+- `Vec2`
+- `Volumes`
+- `WorldConfig`
+- `WorldContext`
+- `WorldSnapshot`
+
+## types (12)
+
+- `DrawCommand`
+- `Easing`
+- `InputMap`
+- `InputScript`
+- `Listener`
+- `NodeFactory`
+- `ProbeFrame`
+- `Shape`
+- `StepExec`
+- `TextAlign`
+- `TileId`
+- `WorldFactory`
+
+## consts (31)
+
+- `audio`: AudioBus
+- `clamp`: (v: number, lo: number, hi: number) => number
+- `DEFAULT_INPUT_MAP`: InputMap
+- `DEFAULT_PLATFORMER`: PlatformerConfig
+- `DEFAULT_TILE_CHARS`: Record<string, TileId>
+- `deg2rad`: (d: number) => number
+- `DUSK`: Palette
+- `EASINGS`: Record<string, Easing>
+- `IDENTITY`: Transform
+- `invLerp`: (a: number, b: number, v: number) => number
+- `lerp`: (a: number, b: number, t: number) => number
+- `mapHeight`: (map: TilemapData) => number
+- `mapWidth`: (map: TilemapData) => number
+- `MEADOW`: Palette
+- `PAD_NEUTRAL`: PadInput
+- `PALETTES`: Record<string, Palette>
+- `PAPER`: Palette
+- `PARTICLE_PRESETS`: { readonly dust: (colors?: string[]) => ParticleStyle; readonly burst: (colors?: string[]) => ParticleStyle; readonly hit: (colors?: string[]) => ParticleSty…
+- `rad2deg`: (r: number) => number
+- `remap`: (v: number, a0: number, a1: number, b0: number, b1: number) => number
+- `settings`: SettingsStore
+- `TAU`: number
+- `TILE`: { readonly EMPTY: 0; readonly SOLID: 1; readonly ONEWAY: 2; readonly HAZARD: 3; }
+- `vadd`: (a: Vec2, b: Vec2) => Vec2
+- `vdist`: (a: Vec2, b: Vec2) => number
+- `vdot`: (a: Vec2, b: Vec2) => number
+- `vec2`: (x?: number, y?: number) => Vec2
+- `VERSION`: "0.1.0"
+- `vlen`: (a: Vec2) => number
+- `vscale`: (a: Vec2, s: number) => Vec2
+- `vsub`: (a: Vec2, b: Vec2) => Vec2
+
+## exports (1)
+
+- `Node2D`
+

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "hayao",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "An AI-first game engine: a deterministic, headless-native simulation kernel with a Godot-style scene tree, pluggable renderers (SVG/Canvas/headless), and a built-in verification harness — designed so an LLM can author, test, and prove correct a whole game without ever opening a browser.",
+  "keywords": ["game-engine", "ai-first", "deterministic", "typescript", "svg", "godot-like", "headless", "simulation"],
+  "author": "hellojanpacan",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/hellojanpacan/hayao-js.git" },
+  "homepage": "https://github.com/hellojanpacan/hayao-js#readme",
+  "bugs": { "url": "https://github.com/hellojanpacan/hayao-js/issues" },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "docs/API.md"],
+  "engines": { "node": ">=18" },
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "build:lib": "rm -rf dist && esbuild src/index.ts --bundle --format=esm --platform=neutral --target=es2022 --outfile=dist/index.js --sourcemap && tsc -p tsconfig.build.json",
+    "check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "api": "tsx scripts/api-digest.ts",
+    "invariants": "tsx scripts/invariants.ts",
+    "verify": "tsx scripts/invariants.ts && tsx scripts/verify.ts",
+    "prepublishOnly": "npm run check && npm test && npm run build:lib"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "esbuild": "^0.28.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vite": "^6.0.0",
+    "vitest": "^2.1.0"
+  }
+}