hayao 0.1.0 → 0.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 [![ci](https://github.com/hellojanpacan/hayao-js/actions/workflows/ci.yml/badge.svg)](https://github.com/hellojanpacan/hayao-js/actions/workflows/ci.yml)
 
+**Play the 26 machine-verified example games at [hayao.dev](https://hayao.dev/).**
+
 **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
@@ -52,15 +54,23 @@ public surface is greppable in one file (`src/index.ts`).
 | **app/** | `runBrowser` (rAF loop) · `runHeadless` | plugs the kernel into a host |
 | **ui/** | DOM overlays: menus, HUD, pause/settings shell | observer (never mutates sim) |
 | **render/** | display list → `SvgRenderer` \| `Canvas2DRenderer` \| `HeadlessRenderer` | observer (projection → paint) |
+| **art/** | code-as-art: palettes, shapes, textures, bitmap fonts, autotile | observer (paints, never hashed) |
 | **audio/** | procedural Web Audio bus (no-op in Node) | observer |
-| **verify/** | probes · replay · `assertDeterministic` · solver | the AI-first harness |
+| **verify/** | probes · replay · `assertDeterministic` · solver · bots · filmstrips | the AI-first harness |
 | **scene/** | `Node`, `Node2D`, `Sprite`, `Text`, `Camera2D`, `Timer`, `AnimationPlayer`, behaviors | **THE STATE** |
+| **physics/** | tilemap + kinematic AABB · character controllers · deterministic rigid-body dynamics | deterministic |
+| **procgen/** | seeded grids, caves, terrain, rooms, stateless scatter | deterministic |
+| **logic/** | pure primitives: FSM, weighted tables, graph search, history | deterministic |
+| **content/** | data-driven wave/spawn directors + upgrade trees | deterministic |
+| **net/** | deterministic multiplayer: lockstep + rollback over a pluggable transport | deterministic |
+| **persist/** | save/load over a pluggable storage adapter + compact codecs | deterministic |
 | **input/** | action map · per-step sampling · record / replay | deterministic |
 | **core/** | `Rng` · `Clock` · `EventBus` · `World` · state hash | **THE KERNEL** (headless, pure) |
 
-`core + scene + input` are **deterministic and run in Node**. `render + audio +
-ui + app` are the browser-only observer shell. Break that boundary and the
-verification harness stops being able to prove anything.
+`core + scene + input + physics + procgen + logic + content + net + persist` are
+**deterministic and run in Node**. `render + art + audio + ui + app` are the
+browser-only observer shell. Break that boundary and the verification harness
+stops being able to prove anything.
 
 ## Why not Godot or a raw canvas engine?
 
@@ -84,14 +94,21 @@ reasoning in [docs/ENGINE.md](docs/ENGINE.md).
 
 ## Status
 
-**v0.1 — complete and verified.** All layers are implemented and tested:
-`core/`, `scene/`, `input/`, `render/` (SVG + Canvas2D + headless backends),
-`audio/`, `ui/`, `verify/`, and `app/`. The flagship **Sokoban** example
-(`examples/sokoban/`) is solver-proven winnable on every level and plays in the
-browser. 40 tests pass; `npm run check`, `npm run verify`, and `npm run build`
-are all green. Roadmap: more node types (physics bodies, particles), an ECS
-option for large entity counts, additional example genres, and asset-free audio
-tracks. Contributions welcome.
+**v0.2 — the 20-genre campaign is complete, plus the waves it triggered.**
+Twenty-six games live under `examples/`. The core twenty-one cover the most
+popular 2D indie genres (platformer, metroidvania, Zelda-like, stealth, horde
+survival, bullet hell, tower defense, RTS, roguelike, deckbuilder, tactics,
+match-3, idle, farming, horror, city builder, rhythm, physics arcade, racing,
+narrative — plus the original Sokoban). On top of those sit two js13k-benchmark
+reproductions (Seamfold, Gravewell), a deterministic rigid-body physics wave
+(Rookspire demolition, Brasswick pinball), and a netplay showcase (Fernclash —
+lockstep + rollback across tabs). Every one ships a `verify.ts` suite that
+machine-proves its truth: solver-proven puzzles, bot-beaten levels, duel-proven
+counter systems, win-rate-tuned balance, fairness gates for procgen,
+frame-exact timing windows, bit-for-bit peer agreement, golden replay hashes.
+400+ tests; `npm run verify` runs the whole portfolio. The campaign's findings — what each
+genre demanded of the engine and what generalized — live in
+[docs/BUILDLOG.md](docs/BUILDLOG.md).
 
 ## License
 

package/dist/art/autotile.d.ts

@@ -0,0 +1,77 @@
+import { type Transform } from '../core/math';
+import type { PolyCommand, RectCommand } from '../render/commands';
+export type BoolGrid = readonly (readonly boolean[])[];
+/** Build a grid from rows of text; a cell is solid when its char is in `solid`. */
+export declare function gridFromRows(rows: readonly string[], solid?: string): boolean[][];
+export declare const Edge: {
+    readonly N: 1;
+    readonly E: 2;
+    readonly S: 4;
+    readonly W: 8;
+};
+export type Edge = (typeof Edge)[keyof typeof Edge];
+/** 4-bit edge mask of solid neighbours around a cell. */
+export declare function mask4(grid: BoolGrid, x: number, y: number): number;
+/** 8-bit neighbour mask, bit order N,NE,E,SE,S,SW,W,NW (1,2,4,…,128). */
+export declare function mask8(grid: BoolGrid, x: number, y: number): number;
+/** Base tile shapes an edge mask resolves to (rotate `frame` by `rotation`×90° CW). */
+export declare const WangFrame: {
+    readonly Isolated: 0;
+    readonly Cap: 1;
+    readonly Straight: 2;
+    readonly Bend: 3;
+    readonly Tee: 4;
+    readonly Cross: 5;
+};
+export type WangFrame = (typeof WangFrame)[keyof typeof WangFrame];
+export interface WangTile {
+    mask: number;
+    frame: WangFrame;
+    /** Quarter turns clockwise applied to the base frame (0–3). */
+    rotation: number;
+}
+/** Resolve an edge mask (0–15) to its base frame + rotation. */
+export declare function wangTile(mask: number): WangTile;
+/** Classify every solid cell into a {frame, rotation}; empty cells are `null`. */
+export declare function autotile4(grid: BoolGrid): (WangTile | null)[][];
+/** Per-dual-cell case index (0–15) over the grid corners; size (h-1)×(w-1). */
+export declare function marchingSquaresCases(grid: BoolGrid): number[][];
+export interface ContourSegment {
+    a: {
+        x: number;
+        y: number;
+    };
+    b: {
+        x: number;
+        y: number;
+    };
+}
+export interface ContourOptions {
+    /** Cell size in design units. Default 1. */
+    cell?: number;
+    x?: number;
+    y?: number;
+}
+/** Iso-contour line segments tracing the solid/empty boundary (design units). */
+export declare function marchingSquaresContours(grid: BoolGrid, options?: ContourOptions): ContourSegment[];
+export interface AutotileDrawOptions {
+    /** Tile size in design units. Default 8. */
+    tile?: number;
+    x?: number;
+    y?: number;
+    z?: number;
+    transform?: Transform;
+    /** Fill colour of solid tiles. */
+    fill?: string;
+    /** Stroke colour drawn only on sides exposed to empty (the seam). */
+    edge?: string;
+    edgeWidth?: number;
+}
+/**
+ * Draw a boolean grid as seamless tiles: a fill per solid cell plus an edge
+ * stroke only on sides facing empty (derived from `mask4`). Pure draw data for
+ * a `cosmetic` node.
+ */
+export declare function autotileToCommands(grid: BoolGrid, options?: AutotileDrawOptions): (RectCommand | PolyCommand)[];
+/** Draw the marching-squares iso-contour as open polylines (cosmetic draw data). */
+export declare function contourToCommands(grid: BoolGrid, options?: AutotileDrawOptions): PolyCommand[];

package/dist/art/bitmapFont.d.ts

@@ -0,0 +1,113 @@
+import { type Transform } from '../core/math';
+import type { DrawCommand, RectCommand, TextAlign } from '../render/commands';
+import { Node, type NodeConfig } from '../scene/node';
+import { type BitmapFont } from './font5';
+/** One source character with an optional colour and its index in the source string. */
+export interface RichChar {
+    ch: string;
+    color?: string;
+    i: number;
+}
+/**
+ * Parse inline colour markup into per-character colours. `{name}` pushes a
+ * colour, `{/}` pops it (a stack, so nesting works); `{{` is a literal `{`.
+ * A tag resolves through `colorMap`, or is used literally if it starts with `#`
+ * or is not in the map. Text outside any tag has no colour (caller default).
+ */
+export declare function parseRich(markup: string, colorMap?: Record<string, string>): RichChar[];
+/** Width in font-pixels of a run of already-resolved chars on one line. */
+export declare function measureLine(font: BitmapFont, chars: readonly RichChar[]): number;
+/** Width in font-pixels of a plain string (no wrapping). */
+export declare function measureText(font: BitmapFont, text: string): number;
+export interface PlacedGlyph {
+    ch: string;
+    color?: string;
+    /** Source-string index (for typewriter reveal). */
+    i: number;
+    /** Top-left in font-pixel units. */
+    x: number;
+    y: number;
+    w: number;
+}
+export interface TextLayout {
+    glyphs: PlacedGlyph[];
+    /** Bounding size in font-pixel units. */
+    width: number;
+    height: number;
+    lines: number;
+}
+export interface TextLayoutOptions {
+    /** Wrap width in font-pixels. Omit for no wrapping. */
+    maxWidth?: number;
+    /** Extra blank rows between lines. Default 1. */
+    lineSpacing?: number;
+    /** Horizontal alignment within `maxWidth` (or the widest line). Default 'left'. */
+    align?: TextAlign;
+}
+/**
+ * Lay out text into placed glyphs (font-pixel coords), word-wrapping on spaces
+ * and breaking on `\n`. Accepts a plain string or a `RichChar[]` from
+ * `parseRich`. Pure and deterministic.
+ */
+export declare function layoutText(font: BitmapFont, input: string | readonly RichChar[], options?: TextLayoutOptions): TextLayout;
+/** Typewriter: how many source characters are revealed after `elapsed` seconds. */
+export declare function typewriterCount(total: number, elapsedSec: number, charsPerSec: number): number;
+export interface TextDrawOptions {
+    /** Font-pixel cell size in design units. Default 2. */
+    cell?: number;
+    /** Top-left origin in local space. Default 0,0. */
+    x?: number;
+    y?: number;
+    z?: number;
+    /** Default fill for glyphs without an inline colour. Default '#000'. */
+    color?: string;
+    transform?: Transform;
+    /** Draw only glyphs whose source index is `< reveal` (typewriter). */
+    reveal?: number;
+}
+/**
+ * Project a laid-out text to run-merged `rect` commands — one rect per
+ * horizontal span of lit pixels. Pure; the commands belong under a `cosmetic`
+ * node.
+ */
+export declare function textToCommands(font: BitmapFont, layout: TextLayout, options?: TextDrawOptions): RectCommand[];
+export interface BitmapTextConfig extends NodeConfig {
+    text: string;
+    font?: BitmapFont;
+    cell?: number;
+    color?: string;
+    /** Resolve `{tag}` markup names to colours. */
+    colorMap?: Record<string, string>;
+    /** Wrap width in font-pixels. */
+    maxWidth?: number;
+    lineSpacing?: number;
+    align?: TextAlign;
+    /** Typewriter speed in chars/sec (clock-driven). Omit to show all at once. */
+    charsPerSec?: number;
+    /** Center the block on the node origin instead of top-left. Default false. */
+    center?: boolean;
+}
+/**
+ * A scene node that renders bitmap text with optional inline colour and a
+ * clock-driven typewriter reveal. Pure view → `cosmetic = true` (never hashed).
+ */
+export declare class BitmapText extends Node {
+    readonly type = "BitmapText";
+    text: string;
+    font: BitmapFont;
+    cell: number;
+    color: string;
+    colorMap: Record<string, string>;
+    maxWidth?: number;
+    lineSpacing: number;
+    align: TextAlign;
+    charsPerSec?: number;
+    center: boolean;
+    private startTime;
+    constructor(config: BitmapTextConfig);
+    protected onReady(): void;
+    /** Restart the typewriter from the current sim time. */
+    restartReveal(): void;
+    private buildLayout;
+    protected draw(out: DrawCommand[], world: Transform): void;
+}

package/dist/art/font5.d.ts

@@ -0,0 +1,11 @@
+/** A font: named glyph bitmaps plus vertical/spacing metrics. */
+export interface BitmapFont {
+    readonly height: number;
+    /** Blank columns between glyphs. */
+    readonly tracking: number;
+    /** Width of a space character (advance only, no pixels). */
+    readonly spaceWidth: number;
+    readonly glyphs: Readonly<Record<string, readonly string[]>>;
+}
+/** The default built-in font: 5px tall, proportional, uppercase + digits + punctuation. */
+export declare const FONT_5: BitmapFont;

package/dist/art/palette.d.ts

@@ -1,3 +1,4 @@
+import type { Rng } from '../core/rng';
 export interface Palette {
     name: string;
     bg: string;
@@ -18,3 +19,40 @@ export declare const PALETTES: Record<string, Palette>;
 /** Blend two hex colors (t in [0,1]). Deterministic, no allocations of note. */
 export declare function mix(a: string, b: string, t: number): string;
 export declare function withAlpha(hex: string, alpha: number): string;
+export interface HSL {
+    /** Hue in degrees [0,360). */
+    h: number;
+    /** Saturation [0,1]. */
+    s: number;
+    /** Lightness [0,1]. */
+    l: number;
+}
+/** HSL → hex. h in degrees (wraps), s/l in [0,1]. */
+export declare function hsl(h: number, s: number, l: number): string;
+/** HSV/HSB → hex. h in degrees (wraps), s/v in [0,1]. */
+export declare function hsv(h: number, s: number, v: number): string;
+/** Decompose a hex color into HSL. Inverse of `hsl()`. */
+export declare function hexToHsl(hex: string): HSL;
+export interface DriftAmounts {
+    /** Max hue drift ± degrees. */
+    hue?: number;
+    /** Max saturation drift ± (absolute, [0,1]). */
+    sat?: number;
+    /** Max lightness drift ± (absolute, [0,1]). */
+    light?: number;
+}
+/**
+ * Drift a color in HSL space by random amounts from `world.rng` (space-huggers'
+ * `mutate`). Deterministic given rng state; hue wraps, s/l clamp. Cosmetic, but
+ * because it consumes rng draws, call it in a stable order.
+ */
+export declare function mutateColor(rng: Rng, hex: string, amounts?: DriftAmounts): string;
+/** Blend two hex colors in linear light (gamma-correct). t in [0,1]. */
+export declare function mixLinear(a: string, b: string, t: number): string;
+/**
+ * Sample a multi-stop gradient at t in [0,1], blending in linear light. Stops
+ * are evenly spaced hex colors (≥ 1). Great for procedural sky/heat/health ramps.
+ */
+export declare function sampleGradient(stops: readonly string[], t: number): string;
+/** Materialize an n-color ramp from gradient stops (linear-light interpolation). */
+export declare function gradient(stops: readonly string[], n: number): string[];

package/dist/art/texture.d.ts

@@ -0,0 +1,78 @@
+import { type Transform } from '../core/math';
+import type { DrawCommand, RectCommand } from '../render/commands';
+import { Node, type NodeConfig } from '../scene/node';
+/** A palette entry; `null` (or a missing index) renders transparent. */
+export type Swatch = string | null;
+/** A small indexed bitmap: `data[y * width + x]` is a palette index. */
+export declare class PixelBuffer {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+    constructor(width: number, height: number, data?: Uint8Array);
+    get(x: number, y: number): number;
+    set(x: number, y: number, index: number): void;
+    /** Build from a rows-of-strings grid, mapping each character to an index. */
+    static fromRows(rows: readonly string[], charToIndex: Record<string, number>): PixelBuffer;
+    /** A copy with every index passed through `lut` (2-bit → palette remap). */
+    remap(lut: readonly number[]): PixelBuffer;
+}
+/**
+ * Decode a 1-bit-per-pixel bitmap packed MSB-first into a BigInt/hex string
+ * (the super-castle-style trick). Pixel `i` reads bit `(w*h-1-i)`, so a hex
+ * literal reads left-to-right, top-to-bottom. Produces indices 0 or 1.
+ */
+export declare function decodeBits(source: bigint | string, width: number, height: number): PixelBuffer;
+/**
+ * Decode a 2-bit-per-pixel bitmap (indices 0–3) packed MSB-first, matching the
+ * dying-dreams "2-bit source → palette LUT" pipeline. Pass the result through
+ * `PixelBuffer.remap(lut)` to lift the 2-bit indices into a wider palette.
+ */
+export declare function decode2bit(source: bigint | string, width: number, height: number): PixelBuffer;
+/**
+ * Decode a run-length-encoded index stream (witchcat-style). `runs` is a flat
+ * list of `[count, index, count, index, …]` filled row-major. A short encoding
+ * for sprites dominated by flat colour.
+ */
+export declare function decodeRLE(runs: readonly number[], width: number, height: number): PixelBuffer;
+/** Encode a PixelBuffer back to RLE run pairs — the inverse of `decodeRLE`. */
+export declare function encodeRLE(buf: PixelBuffer): number[];
+export interface PixelDrawOptions {
+    /** Size of one pixel cell in design units. Default 1. */
+    cell?: number;
+    /** Top-left origin in local space. Default 0,0. */
+    x?: number;
+    y?: number;
+    /** Painter z. Default 0. */
+    z?: number;
+    /** World transform for the emitted commands. Default identity. */
+    transform?: Transform;
+}
+/**
+ * Project a PixelBuffer to `rect` draw commands, run-merging horizontal spans
+ * of the same colour so a 16×16 sprite is a handful of rects, not 256. Palette
+ * entries that are `null`/undefined render transparent (skipped). Pure — the
+ * commands carry no state and belong under a `cosmetic` node.
+ */
+export declare function pixelsToCommands(buf: PixelBuffer, palette: readonly Swatch[], options?: PixelDrawOptions): RectCommand[];
+export interface TextureSpriteConfig extends NodeConfig {
+    buffer: PixelBuffer;
+    palette: readonly Swatch[];
+    /** Pixel cell size in design units. Default 1. */
+    cell?: number;
+    /** Draw centered on the node origin instead of top-left. Default true. */
+    center?: boolean;
+}
+/**
+ * A scene node that renders a decoded PixelBuffer. It is pure view over
+ * constant art data, so it is `cosmetic = true` by default — excluded from
+ * `serialize()`/`hash()`/snapshot. Position/scale it like any other node.
+ */
+export declare class TextureSprite extends Node {
+    readonly type = "TextureSprite";
+    buffer: PixelBuffer;
+    palette: readonly Swatch[];
+    cell: number;
+    center: boolean;
+    constructor(config: TextureSpriteConfig);
+    protected draw(out: DrawCommand[], world: Transform): void;
+}

package/dist/audio/audio.d.ts

@@ -11,6 +11,8 @@ export interface Tone {
     type?: OscillatorType;
     gain?: number;
     delay?: number;
+    /** Stereo position -1 (left) … 1 (right) — the spatial-audio hook. */
+    pan?: number;
 }
 export declare class AudioBus {
     private ctx;
@@ -28,6 +30,11 @@ export declare class AudioBus {
     private applyVolumes;
     /** Play a single tone (no-op if audio unstarted). */
     tone(spec: Tone): void;
+    /**
+     * A positional cue: gain falls with distance, pan follows the horizontal
+     * offset. dx/dist in design-space px; hearing range sets the falloff.
+     */
+    spatial(freq: number, dx: number, dist: number, hearing?: number, duration?: number, type?: OscillatorType): void;
     /** Play a sequence of tones as an arpeggio/chord. */
     play(tones: Tone[]): void;
     /** Convenience SFX. */

package/dist/content/dsl.d.ts

@@ -0,0 +1,61 @@
+import type { Rng } from '../core/rng';
+import { type WeightedEntry } from '../logic/random';
+/**
+ * One declarative wave. Fires `count` of `spawn` at time `time` (sim seconds).
+ * When `every` is set it repeats on that interval until `end` (exclusive),
+ * modelling a continuous spawn stream. `spawn` may be a single id or a weighted
+ * table, in which case each firing rolls the table via `world.rng`.
+ */
+export interface WaveDef {
+    /** First fire time, in fixed sim seconds (compare against `world.time`). */
+    time: number;
+    /** What to spawn: a fixed id, or a weighted set rolled per firing. */
+    spawn: string | WeightedEntry<string>[];
+    /** How many per firing (default 1). */
+    count?: number;
+    /** Repeat interval in seconds; omit for a one-shot wave. */
+    every?: number;
+    /** Repeats stop once the next fire time reaches this (seconds). */
+    end?: number;
+}
+/** Mutable director cursor — plain JSON, keep it in `world.state`. */
+export interface DirectorState {
+    /** Next fire time per wave index; Infinity once a wave is exhausted. */
+    next: number[];
+}
+/** One resolved spawn instruction emitted by the director. */
+export interface SpawnEvent {
+    /** Concrete spawn id (already rolled if the wave used a weighted set). */
+    spawn: string;
+    count: number;
+    /** Source wave index, for callers that want to key behavior off the wave. */
+    wave: number;
+}
+/** Initialize a director cursor for a schedule. */
+export declare function initDirector(waves: readonly WaveDef[]): DirectorState;
+/**
+ * Advance the director to `time` (sim seconds) and return every spawn that is
+ * now due, in wave order. Mutates `state.next` in place. Deterministic: it emits
+ * the same events for the same (schedule, time, rng-state) on every machine.
+ * A repeating wave can fire multiple times in one poll if the frame straddled
+ * several intervals (e.g. after a restore), so catch-up never drops spawns.
+ */
+export declare function pollDirector(waves: readonly WaveDef[], state: DirectorState, time: number, rng?: Rng): SpawnEvent[];
+/**
+ * A declarative upgrade or evolution node. `requires` lists ids that must all be
+ * owned before this one can be offered — the cat-survivors evolution gate and a
+ * deckbuilder's upgrade prerequisites are the same shape.
+ */
+export interface UpgradeDef {
+    id: string;
+    /** Ids that must all be owned before this becomes available. */
+    requires?: string[];
+    /** Optional: only offer while UNDER this many owned copies (repeatable upgrades). */
+    maxStacks?: number;
+}
+/**
+ * Which upgrades are offerable given what's owned: prerequisites all met, and
+ * not already at `maxStacks` (default 1 — offered until owned once). `owned` may
+ * repeat ids to represent stacks. Ordered by definition order for hash stability.
+ */
+export declare function availableUpgrades(defs: readonly UpgradeDef[], owned: readonly string[]): UpgradeDef[];

package/dist/core/dmath.d.ts

@@ -0,0 +1,20 @@
+/** Deterministic sine (bit-identical on every JS engine). */
+export declare function dsin(x: number): number;
+/** Deterministic cosine (bit-identical on every JS engine). */
+export declare function dcos(x: number): number;
+/** Deterministic arctangent. */
+export declare function datan(x: number): number;
+/** Deterministic atan2(y, x) with standard quadrant conventions. */
+export declare function datan2(y: number, x: number): number;
+/** Deterministic 2^x via Taylor series on the reduced argument. */
+export declare function dexp2(x: number): number;
+/** Deterministic natural exponential eˣ. Routes through dexp2 (eˣ = 2^(x/ln2)). */
+export declare function dexp(x: number): number;
+/** Deterministic hypotenuse: sqrt is IEEE-correctly-rounded, hypot is not. */
+export declare function dhypot(x: number, y: number): number;
+/** Deterministic natural logarithm. */
+export declare function dlog(x: number): number;
+/** Deterministic base-10 logarithm. */
+export declare const dlog10: (x: number) => number;
+/** Deterministic base-2 logarithm. */
+export declare const dlog2: (x: number) => number;

package/dist/core/math.d.ts

@@ -14,6 +14,8 @@ export declare const clamp: (v: number, lo: number, hi: number) => number;
 export declare const lerp: (a: number, b: number, t: number) => number;
 export declare const invLerp: (a: number, b: number, v: number) => number;
 export declare const remap: (v: number, a0: number, a1: number, b0: number, b1: number) => number;
+/** Hermite smoothstep: 0 below `edge0`, 1 above `edge1`, eased in between. */
+export declare const smoothstep: (edge0: number, edge1: number, v: number) => number;
 export declare const TAU: number;
 export declare const deg2rad: (d: number) => number;
 export declare const rad2deg: (r: number) => number;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './core/math';
+export * from './core/dmath';
 export * from './core/rng';
 export * from './core/clock';
 export * from './core/events';
@@ -6,8 +7,10 @@ export * from './core/hash';
 export * from './scene/node';
 export { Node as Node2D } from './scene/node';
 export * from './scene/nodes';
+export * from './scene/pool';
 export * from './scene/tween';
 export * from './scene/particles';
+export * from './scene/floatingText';
 export * from './scene/registry';
 export * from './input/actions';
 export * from './input/source';
@@ -16,28 +19,61 @@ export * from './physics/aabb';
 export * from './physics/platformer';
 export * from './physics/spatialHash';
 export * from './physics/raycast';
+export * from './physics/rigidBody';
+export * from './physics/rigidCollide';
+export * from './physics/rigidJoints';
+export * from './physics/rigidStep';
+export * from './physics/rigidQueries';
 export * from './render/commands';
 export * from './render/renderer';
 export * from './render/svgString';
 export * from './render/svg';
 export * from './render/canvas';
 export * from './render/headless';
+export * from './render/nineSlice';
 export * from './art/palette';
 export * from './art/shapes';
+export * from './art/texture';
+export * from './art/font5';
+export * from './art/bitmapFont';
+export * from './art/autotile';
+export * from './procgen/grid';
+export * from './procgen/scatter';
+export * from './procgen/cave';
+export * from './procgen/terrain';
+export * from './procgen/rooms';
 export * from './audio/audio';
 export * from './ui/overlay';
 export * from './ui/settings';
 export * from './ui/shell';
+export * from './ui/transition';
 export * from './verify/solver';
 export * from './verify/determinism';
 export * from './verify/playthrough';
 export * from './verify/capture';
 export * from './verify/driver';
 export * from './verify/bot';
+export * from './verify/layout';
 export * from './verify/feel';
 export * from './verify/filmstrip';
+export * from './logic/fsm';
+export * from './logic/random';
+export * from './logic/graph';
+export * from './logic/history';
+export * from './persist/storage';
+export * from './persist/codec';
+export * from './persist/save';
+export * from './content/dsl';
+export * from './net/players';
+export * from './net/protocol';
+export * from './net/transport';
+export * from './net/inputBuffer';
+export * from './net/lockstep';
+export * from './net/rollback';
+export * from './net/room';
+export * from './net/browser';
 export * from './world';
 export * from './app/game';
 export * from './app/browser';
 /** Engine version. */
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";