hayao 0.1.0

package/dist/input/source.d.ts

@@ -0,0 +1,25 @@
+import { type InputMap } from './actions';
+export declare class KeyboardSource {
+    private keysDown;
+    /** Virtual action taps (from DOM buttons etc.) pending consumption by a step. */
+    private pressed;
+    private map;
+    private target;
+    private onDown;
+    private onUp;
+    private onBlur;
+    constructor(map: InputMap, target?: Document | HTMLElement);
+    /** The actions currently held down, as a stable sorted array. */
+    currentActions(): string[];
+    /**
+     * Virtually tap an action (DOM button, touch control). The tap is held until
+     * at least one fixed step has sampled it — the driver calls clearPressed()
+     * after a successful advance — so UI clicks enter the SAME deterministic
+     * input log as keys, and record/replay covers them.
+     */
+    press(action: string): void;
+    /** Consume pending virtual taps (driver-called after ≥1 step ran). */
+    clearPressed(): void;
+    setMap(map: InputMap): void;
+    dispose(): void;
+}

package/dist/physics/aabb.d.ts

@@ -0,0 +1,38 @@
+import type { Rect } from '../core/math';
+import { type TilemapData } from './tilemap';
+/** An extra solid the body collides with (moving platform, door, crate…). */
+export interface SolidRect extends Rect {
+    /** Solid only when landing on its top (jump-through platform). */
+    oneway?: boolean;
+}
+export interface MoveResult {
+    x: number;
+    y: number;
+    hitX: boolean;
+    hitY: boolean;
+    onFloor: boolean;
+    onCeiling: boolean;
+    onWallLeft: boolean;
+    onWallRight: boolean;
+    /** Final rect overlaps a HAZARD tile (with a small forgiveness inset). */
+    hazard: boolean;
+    /** Index into `solids` of the rect the body stands on, or -1. */
+    floorSolid: number;
+}
+export interface MoveOpts {
+    solids?: SolidRect[];
+    /** Pass true while the player holds "down" to drop through one-way platforms. */
+    dropThrough?: boolean;
+}
+/** Would a rect at (x, y) overlap any solid geometry? (Used for corner-correction probes.) */
+export declare function rectBlocked(map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[]): boolean;
+/**
+ * Move a rect by (dx, dy) with axis-separated collision: X first, then Y.
+ * One-way surfaces block only downward motion that starts at-or-above their top.
+ */
+export declare function moveRect(map: TilemapData, rect: Rect, dx: number, dy: number, opts?: MoveOpts): MoveResult;
+/** Is there support directly under the rect (within 1px)? */
+export declare function groundAt(map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[], dropThrough?: boolean): {
+    grounded: boolean;
+    solid: number;
+};

package/dist/physics/platformer.d.ts

@@ -0,0 +1,112 @@
+import { type SolidRect } from './aabb';
+import type { TilemapData } from './tilemap';
+export interface PlatformerConfig {
+    width: number;
+    height: number;
+    /** Ground run speed (px/s) and accelerations (px/s²). */
+    runSpeed: number;
+    groundAccel: number;
+    groundFriction: number;
+    airAccel: number;
+    /**
+     * Horizontal decel with no input while airborne (px/s²). Keep LOW: inherited
+     * momentum (lift jumps, wall kicks) must survive flight to feel right.
+     */
+    airFriction: number;
+    /** Gravity (px/s²), terminal fall speed, and the apex modifier. */
+    gravity: number;
+    maxFall: number;
+    /** |vy| below this counts as the jump apex… */
+    apexThreshold: number;
+    /** …where gravity is multiplied by this while jump is held (the floaty peak). */
+    apexGravityMult: number;
+    /** Initial jump velocity (px/s, upward) and early-release cut multiplier. */
+    jumpVelocity: number;
+    jumpCutMult: number;
+    /** Grace timers (seconds). */
+    coyoteTime: number;
+    jumpBuffer: number;
+    /** Max px the body is nudged sideways to slip past a ceiling corner when jumping. */
+    jumpCornerNudge: number;
+    /** Max px the body is nudged vertically to slip past a corner while dashing. */
+    dashCornerNudge: number;
+    /** Mid-air jumps (0 = none, 1 = double jump…), refilled on landing/wall. */
+    airJumps: number;
+    /** Air-jump velocity as a fraction of jumpVelocity. */
+    airJumpMult: number;
+    /** Dash: speed (px/s), duration (s), cooldown (s), charges refilled on landing. */
+    dashSpeed: number;
+    dashTime: number;
+    dashCooldown: number;
+    dashCharges: number;
+    /** Wall interaction. */
+    wallSlideMaxFall: number;
+    wallJumpVelX: number;
+    wallJumpVelY: number;
+    /** Seconds after a wall jump during which input can't cancel the outward velocity. */
+    wallJumpLock: number;
+}
+/** Tuned for 32px tiles at 60Hz in the 1280×720 design space. */
+export declare const DEFAULT_PLATFORMER: PlatformerConfig;
+/** Per-step intent, sampled from actions by the game (never raw keys). */
+export interface PadInput {
+    moveX: number;
+    moveY: number;
+    jumpHeld: boolean;
+    jumpPressed: boolean;
+    dashPressed: boolean;
+}
+export declare const PAD_NEUTRAL: PadInput;
+/** A moving platform: its current rect, plus its velocity this step (px/s). */
+export interface Platform extends SolidRect {
+    vx: number;
+    vy: number;
+}
+/** Plain serializable controller state — put it in `world.state` so it hashes. */
+export interface PlatformerState {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    facing: number;
+    onGround: boolean;
+    onWall: number;
+    coyote: number;
+    buffer: number;
+    jumping: boolean;
+    wallLock: number;
+    airJumpsLeft: number;
+    dashing: number;
+    dashCd: number;
+    dashesLeft: number;
+    dashVx: number;
+    dashVy: number;
+    /** Velocity inherited from the platform we stand on (lift momentum storage). */
+    carryVx: number;
+    carryVy: number;
+    dead: boolean;
+}
+export declare function createPlatformerState(x: number, y: number): PlatformerState;
+/** Feel events emitted by a step — hooks for SFX / particles / screen shake. */
+export interface PlatformerEvents {
+    jumped: boolean;
+    wallJumped: boolean;
+    airJumped: boolean;
+    dashed: boolean;
+    landed: boolean;
+    died: boolean;
+}
+/**
+ * Advance the controller one fixed step. Mutates `s`; returns feel events.
+ * `platforms` should already be at their post-move positions for this step,
+ * with `vx/vy` set to their velocity, so the body is carried exactly.
+ */
+export declare function stepPlatformer(s: PlatformerState, input: PadInput, dt: number, map: TilemapData, cfg?: PlatformerConfig, platforms?: Platform[]): PlatformerEvents;
+/** Max rise of a full jump (px). */
+export declare function jumpHeight(cfg?: PlatformerConfig): number;
+/** Full-jump airtime returning to takeoff height (s). */
+export declare function jumpAirtime(cfg?: PlatformerConfig): number;
+/** Max horizontal gap clearable by a running jump (px, flat-to-flat). */
+export declare function jumpDistance(cfg?: PlatformerConfig): number;
+/** Max gap clearable by jump + one apex dash (px, flat-to-flat, horizontal dash). */
+export declare function dashJumpDistance(cfg?: PlatformerConfig): number;

package/dist/physics/raycast.d.ts

@@ -0,0 +1,22 @@
+import { type TilemapData } from './tilemap';
+export interface RayHit {
+    /** True if a solid tile stopped the ray before reaching (x1, y1). */
+    blocked: boolean;
+    /** Where the ray stopped (the hit point, or the target if unblocked). */
+    x: number;
+    y: number;
+    /** Distance travelled. */
+    dist: number;
+}
+/**
+ * March a ray from (x0,y0) toward (x1,y1) through the tile grid (DDA — exact,
+ * no step-size tuning). SOLID tiles block; everything else passes.
+ */
+export declare function raycastTiles(map: TilemapData, x0: number, y0: number, x1: number, y1: number): RayHit;
+/** Can a see b with no solid tile between? */
+export declare function lineOfSight(map: TilemapData, ax: number, ay: number, bx: number, by: number): boolean;
+/**
+ * Is the target inside a vision cone AND visible? (facing is a unit vector;
+ * fov is the FULL cone angle in radians.)
+ */
+export declare function inVisionCone(map: TilemapData, ex: number, ey: number, faceX: number, faceY: number, fov: number, range: number, tx: number, ty: number): boolean;

package/dist/physics/spatialHash.d.ts

@@ -0,0 +1,15 @@
+import type { Rect } from '../core/math';
+export declare class SpatialHash<T> {
+    private cells;
+    private bounds;
+    private readonly cellSize;
+    constructor(cellSize?: number);
+    clear(): void;
+    get size(): number;
+    private key;
+    insert(item: T, rect: Rect): void;
+    /** All items whose rects overlap the query rect (deduplicated, deterministic order). */
+    query(rect: Rect): T[];
+    /** All items within `radius` of a point (circle vs rect-center test on bounds). */
+    queryCircle(x: number, y: number, radius: number): T[];
+}

package/dist/physics/tilemap.d.ts

@@ -0,0 +1,38 @@
+export declare const TILE: {
+    readonly EMPTY: 0;
+    readonly SOLID: 1;
+    /** Passable from below/sides; solid only when landing on its top edge. */
+    readonly ONEWAY: 2;
+    readonly HAZARD: 3;
+};
+export type TileId = (typeof TILE)[keyof typeof TILE];
+export interface TilemapData {
+    /** Size in tiles. */
+    cols: number;
+    rows: number;
+    /** Tile edge in design-space px. */
+    tileSize: number;
+    /** Row-major tile ids, length cols*rows. */
+    tiles: number[];
+}
+/** Default ASCII vocabulary: `#` solid, `-` one-way, `^` hazard, else empty. */
+export declare const DEFAULT_TILE_CHARS: Record<string, TileId>;
+/**
+ * Build a tilemap from ASCII rows. Unknown characters are EMPTY, so level
+ * strings can carry entity markers (`@` spawn, `*` shard…) for game code to
+ * read separately via `asciiEntities`.
+ */
+export declare function tilemapFromAscii(rowsAscii: string[], tileSize?: number, chars?: Record<string, TileId>): TilemapData;
+/** Extract entity markers (any char not in the tile vocabulary, not space/dot). */
+export declare function asciiEntities(rowsAscii: string[], tileSize?: number, chars?: Record<string, TileId>): {
+    char: string;
+    tx: number;
+    ty: number;
+    x: number;
+    y: number;
+}[];
+/** Tile id at tile coords; out-of-bounds reads as SOLID (levels are sealed). */
+export declare function tileAt(map: TilemapData, tx: number, ty: number): number;
+export declare function tileAtPoint(map: TilemapData, x: number, y: number): number;
+export declare const mapWidth: (map: TilemapData) => number;
+export declare const mapHeight: (map: TilemapData) => number;

package/dist/render/canvas.d.ts

@@ -0,0 +1,19 @@
+import { type DrawCommand } from './commands';
+import type { Renderer, RendererConfig } from './renderer';
+export declare class Canvas2DRenderer implements Renderer {
+    readonly width: number;
+    readonly height: number;
+    private background;
+    private canvas;
+    private ctx;
+    private dpr;
+    constructor(config: RendererConfig);
+    mount(parent: HTMLElement): void;
+    private resize;
+    draw(commands: DrawCommand[]): void;
+    private stroke;
+    private paint;
+    private roundRect;
+    get element(): HTMLCanvasElement;
+    dispose(): void;
+}

package/dist/render/commands.d.ts

@@ -0,0 +1,65 @@
+import type { Transform } from '../core/math';
+export interface Paint {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+    /** Round line joins/caps for organic shapes. */
+    round?: boolean;
+}
+export type TextAlign = 'left' | 'center' | 'right';
+interface Base extends Paint {
+    /** World transform (design-space). */
+    transform: Transform;
+    /** Painter's-order key; ties broken by tree order. Default 0. */
+    z: number;
+}
+export interface RectCommand extends Base {
+    kind: 'rect';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Corner radius. */
+    r?: number;
+}
+export interface CircleCommand extends Base {
+    kind: 'circle';
+    cx: number;
+    cy: number;
+    radius: number;
+}
+export interface PolyCommand extends Base {
+    kind: 'poly';
+    /** Flat [x0,y0,x1,y1,…] in local space. */
+    points: number[];
+    closed: boolean;
+}
+export interface PathCommand extends Base {
+    kind: 'path';
+    /** SVG path data in local space. */
+    d: string;
+}
+export interface TextCommand extends Base {
+    kind: 'text';
+    text: string;
+    x: number;
+    y: number;
+    size: number;
+    font?: string;
+    align?: TextAlign;
+    weight?: number;
+}
+export interface ImageCommand extends Base {
+    kind: 'image';
+    /** data: URI or path. */
+    href: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export type DrawCommand = RectCommand | CircleCommand | PolyCommand | PathCommand | TextCommand | ImageCommand;
+/** Stable painter's sort: by z, then original index (tree order) as tiebreak. */
+export declare function sortCommands(cmds: DrawCommand[]): DrawCommand[];
+export {};

package/dist/render/headless.d.ts

@@ -0,0 +1,17 @@
+import type { DrawCommand } from './commands';
+import type { Renderer, RendererConfig } from './renderer';
+export declare class HeadlessRenderer implements Renderer {
+    readonly width: number;
+    readonly height: number;
+    private background;
+    private last;
+    frameCount: number;
+    constructor(config: RendererConfig);
+    draw(commands: DrawCommand[]): void;
+    /** The most recently drawn display list. */
+    get commands(): DrawCommand[];
+    /** Count commands of a given kind (handy for assertions). */
+    count(kind: DrawCommand['kind']): number;
+    /** A vector screenshot of the last frame. */
+    toSVGString(): string;
+}

package/dist/render/renderer.d.ts

@@ -0,0 +1,16 @@
+import type { DrawCommand } from './commands';
+/** A backend that paints a display list into a host (DOM, canvas, or nothing). */
+export interface Renderer {
+    readonly width: number;
+    readonly height: number;
+    /** Paint one frame. */
+    draw(commands: DrawCommand[]): void;
+    /** Attach to a DOM parent (browser backends). */
+    mount?(parent: HTMLElement): void;
+    dispose?(): void;
+}
+export interface RendererConfig {
+    width: number;
+    height: number;
+    background?: string;
+}

package/dist/render/svg.d.ts

@@ -0,0 +1,16 @@
+import type { DrawCommand } from './commands';
+import type { Renderer, RendererConfig } from './renderer';
+export declare class SvgRenderer implements Renderer {
+    readonly width: number;
+    readonly height: number;
+    private background;
+    private svg;
+    private bg;
+    private layer;
+    constructor(config: RendererConfig);
+    mount(parent: HTMLElement): void;
+    draw(commands: DrawCommand[]): void;
+    setBackground(color: string): void;
+    get element(): SVGSVGElement;
+    dispose(): void;
+}

package/dist/render/svgString.d.ts

@@ -0,0 +1,5 @@
+import { type DrawCommand } from './commands';
+/** Inner SVG markup for a display list (no wrapping <svg>). */
+export declare function commandsToSVGInner(commands: DrawCommand[]): string;
+/** A complete, standalone SVG document string for a frame — a headless screenshot. */
+export declare function renderToSVGString(commands: DrawCommand[], width: number, height: number, background?: string): string;

package/dist/scene/node.d.ts

@@ -0,0 +1,100 @@
+import type { Rng } from '../core/rng';
+import type { Clock } from '../core/clock';
+import { Signal } from '../core/events';
+import { type Transform, type Vec2 } from '../core/math';
+import type { DrawCommand } from '../render/commands';
+/** What a live node can see of its host world. The World implements this. */
+export interface WorldContext {
+    readonly rng: Rng;
+    readonly clock: Clock;
+    /** Queue a node to be freed at the end of the current step (safe during iteration). */
+    requestFree(node: Node): void;
+    /** Seconds elapsed in sim time. */
+    readonly time: number;
+}
+/** A composable update unit attached to a node (favour over deep inheritance). */
+export interface Behavior {
+    ready?(node: Node): void;
+    update?(node: Node, dt: number): void;
+    exit?(node: Node): void;
+    /** Optional tag for lookup/serialization. */
+    readonly kind?: string;
+}
+/** Deterministic id source — reset by the World on load so ids are reproducible. */
+export declare function resetNodeIds(start?: number): void;
+export interface NodeConfig {
+    name?: string;
+    pos?: Vec2;
+    rotation?: number;
+    scale?: Vec2;
+    z?: number;
+    visible?: boolean;
+}
+export declare class Node {
+    readonly id: string;
+    name: string;
+    /** Type tag for serialization; subclasses override. */
+    readonly type: string;
+    pos: Vec2;
+    rotation: number;
+    scale: Vec2;
+    z: number;
+    visible: boolean;
+    /**
+     * Cosmetic nodes are pure *view* (derived from game state, rebuildable) and are
+     * excluded from serialize()/snapshot()/hash(). Mark a container cosmetic when it
+     * only renders state that lives elsewhere — so transient display (move counters,
+     * particles, tweened positions) never pollutes the canonical, verifiable state.
+     */
+    cosmetic: boolean;
+    parent: Node | null;
+    readonly children: Node[];
+    world: WorldContext | null;
+    /** Optional inline update without subclassing: node.onUpdate = (n, dt) => {…}. */
+    onUpdate?: (node: Node, dt: number) => void;
+    private behaviors;
+    private signals;
+    private _ready;
+    private _freed;
+    constructor(config?: NodeConfig);
+    addChild<T extends Node>(child: T): T;
+    removeChild(child: Node): void;
+    /** Deferred free: runs exit hooks and detaches at the end of the step. */
+    free(): void;
+    /** Depth-first find by name. */
+    find(name: string): Node | null;
+    /** All descendants (and self) of a given type tag. */
+    query(type: string, out?: Node[]): Node[];
+    addBehavior(b: Behavior): this;
+    signal<T = void>(name: string): Signal<T>;
+    emit<T>(name: string, payload: T): void;
+    enterTree(world: WorldContext): void;
+    updateTree(dt: number): void;
+    exitTree(): void;
+    get isFreed(): boolean;
+    localTransform(): Transform;
+    worldTransform(): Transform;
+    /** Walk the subtree, appending draw commands with computed world transforms. */
+    collectDraw(out: DrawCommand[], parentWorld?: Transform): void;
+    /** Subclasses emit their own commands here. Base draws nothing. */
+    protected draw(_out: DrawCommand[], _world: Transform): void;
+    protected onReady(): void;
+    protected onProcess(_dt: number): void;
+    protected onExit(): void;
+    serialize(): SerializedNode;
+    /** Subclasses persist their own fields here. */
+    protected serializeProps(): Record<string, unknown>;
+    /** Subclasses restore their own fields here. */
+    applyProps(_props: Record<string, unknown>): void;
+}
+export interface SerializedNode {
+    type: string;
+    name: string;
+    pos: Vec2;
+    rotation: number;
+    scale: Vec2;
+    z: number;
+    visible: boolean;
+    props: Record<string, unknown>;
+    children: SerializedNode[];
+}

package/dist/scene/nodes.d.ts

@@ -0,0 +1,90 @@
+import type { Transform } from '../core/math';
+import type { DrawCommand, Paint, TextAlign } from '../render/commands';
+import { Node, type NodeConfig } from './node';
+export type Shape = {
+    kind: 'rect';
+    w: number;
+    h: number;
+    r?: number;
+} | {
+    kind: 'circle';
+    radius: number;
+} | {
+    kind: 'poly';
+    points: number[];
+    closed?: boolean;
+} | {
+    kind: 'path';
+    d: string;
+} | {
+    kind: 'glyph';
+    char: string;
+    size: number;
+};
+export interface SpriteConfig extends NodeConfig, Paint {
+    shape: Shape;
+}
+export declare class Sprite extends Node {
+    readonly type = "Sprite";
+    shape: Shape;
+    paint: Paint;
+    constructor(config: SpriteConfig);
+    protected draw(out: DrawCommand[], world: Transform): void;
+    protected serializeProps(): Record<string, unknown>;
+    applyProps(props: Record<string, unknown>): void;
+}
+export interface TextConfig extends NodeConfig, Paint {
+    text: string;
+    size?: number;
+    font?: string;
+    align?: TextAlign;
+    weight?: number;
+}
+export declare class Text extends Node {
+    readonly type = "Text";
+    text: string;
+    size: number;
+    font?: string;
+    align: TextAlign;
+    weight?: number;
+    paint: Paint;
+    constructor(config: TextConfig);
+    protected draw(out: DrawCommand[], world: Transform): void;
+    protected serializeProps(): Record<string, unknown>;
+    applyProps(props: Record<string, unknown>): void;
+}
+export interface CameraConfig extends NodeConfig {
+    zoom?: number;
+    /** Make this the active camera on ready. */
+    current?: boolean;
+}
+export declare class Camera2D extends Node {
+    readonly type = "Camera2D";
+    zoom: number;
+    current: boolean;
+    constructor(config?: CameraConfig);
+    protected onReady(): void;
+    protected serializeProps(): Record<string, unknown>;
+    applyProps(props: Record<string, unknown>): void;
+}
+export interface TimerConfig extends NodeConfig {
+    duration: number;
+    autostart?: boolean;
+    oneShot?: boolean;
+}
+export declare class Timer extends Node {
+    readonly type = "Timer";
+    duration: number;
+    oneShot: boolean;
+    private remaining;
+    private running;
+    constructor(config: TimerConfig);
+    start(duration?: number): void;
+    stop(): void;
+    get timeLeft(): number;
+    protected onProcess(dt: number): void;
+    /** Signal emitted when the countdown reaches zero. */
+    get timeout(): import("..").Signal<void>;
+    protected serializeProps(): Record<string, unknown>;
+    applyProps(props: Record<string, unknown>): void;
+}

package/dist/scene/particles.d.ts

@@ -0,0 +1,78 @@
+import { type Transform, type Vec2 } from '../core/math';
+import type { DrawCommand } from '../render/commands';
+import { Node, type NodeConfig } from './node';
+export interface ParticleStyle {
+    /** Colors drawn from at random per particle. */
+    colors: string[];
+    /** Particle radius range (px). */
+    sizeMin: number;
+    sizeMax: number;
+    /** Initial speed range (px/s). */
+    speedMin: number;
+    speedMax: number;
+    /** Emission arc: center angle + spread (radians). Default: full circle. */
+    angle?: number;
+    spread?: number;
+    /** Lifetime range (s). */
+    lifeMin: number;
+    lifeMax: number;
+    /** Gravity applied to particles (px/s², +y is down). */
+    gravity?: number;
+    /** Velocity damping per second (0 = none, 5 = strong). */
+    drag?: number;
+    /** Shrink to zero over life (default true; also fades opacity). */
+    shrink?: boolean;
+}
+/**
+ * A pooled particle emitter node. Call `burst(n, at, style)` from game code in
+ * response to feel events. Always cosmetic; safe to add anywhere in the tree.
+ */
+export declare class Particles extends Node {
+    readonly type: string;
+    private pool;
+    private rng;
+    /** Cap on live particles (oldest are recycled first). */
+    maxParticles: number;
+    constructor(config?: NodeConfig & {
+        seed?: number;
+        maxParticles?: number;
+    });
+    /** Emit a burst at a position (in this node's local space). */
+    burst(count: number, at: Vec2, style: ParticleStyle): void;
+    private gravity;
+    private drag;
+    private shrink;
+    protected onProcess(dt: number): void;
+    protected draw(out: DrawCommand[], world: Transform): void;
+    get liveCount(): number;
+}
+/** Ready-made styles for the common feel moments. */
+export declare const PARTICLE_PRESETS: {
+    readonly dust: (colors?: string[]) => ParticleStyle;
+    readonly burst: (colors?: string[]) => ParticleStyle;
+    readonly hit: (colors?: string[]) => ParticleStyle;
+    readonly sparkle: (colors?: string[]) => ParticleStyle;
+};
+/**
+ * Screen shake as a cosmetic camera offset with its own Rng and exponential
+ * decay. Attach to whatever node the camera follows and read `offset` into the
+ * camera's position AFTER canonical follow logic — or simpler, add the shaker
+ * as the camera's parent so the offset composes for free.
+ */
+export declare class Shaker extends Node {
+    readonly type: string;
+    private rng;
+    private trauma;
+    /** Max offset in px at full trauma. */
+    amplitude: number;
+    /** Trauma decay per second. */
+    decay: number;
+    constructor(config?: NodeConfig & {
+        seed?: number;
+        amplitude?: number;
+        decay?: number;
+    });
+    /** Add shake (0..1). Stacks, clamped to 1. Quadratic falloff feels right. */
+    addTrauma(amount: number): void;
+    protected onProcess(dt: number): void;
+}

package/dist/scene/registry.d.ts

@@ -0,0 +1,5 @@
+import { Node, type SerializedNode } from './node';
+export type NodeFactory = () => Node;
+export declare function registerNode(type: string, factory: NodeFactory): void;
+/** Rebuild a live node tree from serialized data. */
+export declare function deserializeNode(data: SerializedNode): Node;