hayao 0.1.0 → 0.2.0

package/dist/net/room.d.ts

@@ -0,0 +1,78 @@
+import type { World } from '../world';
+import type { PlayerId } from './players';
+import { type NetSessionConfig } from './protocol';
+import type { Transport } from './transport';
+import { LockstepSession, type DesyncInfo } from './lockstep';
+import { RollbackSession } from './rollback';
+/** A live networked game, the same shape on host and client. */
+export interface NetGame {
+    world: World;
+    session: LockstepSession | RollbackSession;
+    localPlayer: PlayerId;
+    /** Roster at the time the game handle was created. */
+    players: PlayerId[];
+    /** Drive this from the render loop instead of world.advance(). */
+    advance(realMs: number, localActions?: readonly string[]): number;
+    dispose(): void;
+}
+export interface RoomCallbacks {
+    onDesync?: (info: DesyncInfo) => void;
+    onPlayerJoin?: (player: PlayerId, atFrame: number) => void;
+    onPlayerLeave?: (player: PlayerId, atFrame: number) => void;
+}
+export interface RoomHostOptions extends RoomCallbacks {
+    transport: Transport;
+    /** Build the deterministic world every peer will run. */
+    makeWorld: (seed: number) => World;
+    seed?: number;
+    config?: Partial<NetSessionConfig>;
+    maxPlayers?: number;
+    /** Frames between "a joiner exists" and their first live frame. */
+    joinMargin?: number;
+    /** Re-attach behaviors after restore (rollback / late-join snapshot). */
+    attach?: (world: World) => void;
+}
+export declare class RoomHost {
+    readonly localPlayer: PlayerId;
+    readonly seed: number;
+    readonly config: NetSessionConfig;
+    private readonly transport;
+    private readonly makeWorld;
+    private readonly maxPlayers;
+    private readonly joinMargin;
+    private readonly attach?;
+    private readonly callbacks;
+    private players;
+    private uidToPlayer;
+    private nextPlayerIndex;
+    private started;
+    private game;
+    private pendingSnapshots;
+    private unsubscribe;
+    constructor(opts: RoomHostOptions);
+    /** Players currently in the room (host first). */
+    get roster(): PlayerId[];
+    get isStarted(): boolean;
+    /** Freeze the roster's frame 0 and begin simulating. */
+    start(): NetGame;
+    /** Announce a player's departure (disconnect handling is the app's call). */
+    dropPlayer(player: PlayerId): void;
+    dispose(): void;
+    private receive;
+    private handleHello;
+    private serviceSnapshots;
+}
+export interface RoomClientOptions extends RoomCallbacks {
+    transport: Transport;
+    makeWorld: (seed: number) => World;
+    attach?: (world: World) => void;
+    name?: string;
+}
+/**
+ * Join a room: send hello, wait for welcome (+start or snapshot), come back
+ * with a NetGame. Session-layer messages that arrive while the snapshot is in
+ * flight are buffered and replayed so no input is ever missed.
+ */
+export declare function joinRoom(opts: RoomClientOptions): Promise<NetGame>;
+/** Create a room host over a transport. Call `start()` when the lobby is set. */
+export declare function hostRoom(opts: RoomHostOptions): RoomHost;

package/dist/net/transport.d.ts

@@ -0,0 +1,78 @@
+export interface Transport {
+    /** Deliver to every other peer on the bus. */
+    send(data: string): void;
+    /** Subscribe to incoming data. Returns an unsubscribe function. */
+    onMessage(cb: (data: string) => void): () => void;
+    /** Fires when the transport goes away (socket close, hub shutdown). */
+    onClose(cb: () => void): () => void;
+    close(): void;
+    readonly isOpen: boolean;
+}
+export interface LoopbackOptions {
+    /** Delivery delay in ticks (calls to hub.tick()). Default 0 = next tick. */
+    delay?: number;
+    /** Drop every Nth message (deterministic loss pattern). 0 = lossless. */
+    dropEvery?: number;
+}
+/**
+ * An in-memory bus with explicit, deterministic time: nothing is delivered
+ * until `tick()` runs, messages arrive in send order, and loss follows a fixed
+ * pattern. Network tests stay exactly reproducible — no timers, no races.
+ */
+export declare class LoopbackHub {
+    private peers;
+    private queue;
+    private tickCount;
+    private seq;
+    private sent;
+    private readonly delay;
+    private readonly dropEvery;
+    constructor(opts?: LoopbackOptions);
+    /** Create a new endpoint on this bus. */
+    connect(): LoopbackTransport;
+    /** @internal */
+    enqueue(data: string, from: number): void;
+    /** Advance one network tick, delivering everything that is due. */
+    tick(): void;
+    /** Deliver everything in flight (repeated ticks until the queue drains). */
+    flush(): void;
+    get pending(): number;
+}
+export declare class LoopbackTransport implements Transport {
+    private readonly hub;
+    readonly peerIndex: number;
+    private listeners;
+    private closeListeners;
+    private open;
+    constructor(hub: LoopbackHub, peerIndex: number);
+    send(data: string): void;
+    onMessage(cb: (data: string) => void): () => void;
+    onClose(cb: () => void): () => void;
+    close(): void;
+    get isOpen(): boolean;
+    /** @internal */
+    deliver(data: string): void;
+}
+/**
+ * A bus over the browser's BroadcastChannel — every tab on the same origin
+ * that opens the same room name is a peer. Perfect for local two-tab netplay
+ * and demos: no server at all.
+ */
+export declare class BroadcastChannelTransport implements Transport {
+    private channel;
+    private listeners;
+    private closeListeners;
+    private open;
+    constructor(room: string);
+    send(data: string): void;
+    onMessage(cb: (data: string) => void): () => void;
+    onClose(cb: () => void): () => void;
+    close(): void;
+    get isOpen(): boolean;
+}
+/**
+ * A bus over a WebSocket to the hayao relay (`npm run relay`): everyone
+ * connected to the same room URL is a peer; the relay forwards each message to
+ * the room's other sockets. Resolves once the socket is open.
+ */
+export declare function connectWebSocket(url: string): Promise<Transport>;

package/dist/persist/codec.d.ts

@@ -0,0 +1,4 @@
+export declare function rleEncode(input: string): string;
+export declare function rleDecode(input: string): string;
+export declare function packVarints(nums: readonly number[]): string;
+export declare function unpackVarints(input: string): number[];

package/dist/persist/save.d.ts

@@ -0,0 +1,32 @@
+import type { World, WorldSnapshot } from '../world';
+import { type StorageAdapter } from './storage';
+/** Bump when the snapshot shape changes in a way old saves can't satisfy. */
+export declare const SAVE_FORMAT_VERSION = 1;
+/** Serialize a snapshot to a compact JSON string with a version envelope. */
+export declare function serializeSnapshot(snap: WorldSnapshot): string;
+/**
+ * Parse a serialized snapshot back. Returns `null` on anything malformed —
+ * corrupt JSON, wrong version, missing fields — so a bad save is a clean miss,
+ * never a thrown exception mid-game. Guards `JSON.parse` per the invariant.
+ */
+export declare function parseSnapshot(text: string | null): WorldSnapshot | null;
+/**
+ * A tiny save API bound to one World and one storage backend. Slots are named
+ * ('auto', 'slot1', …). Everything routes through `world.snapshot()`/`restore()`
+ * so the saved and restored states share a hash.
+ */
+export declare class SaveManager {
+    private readonly world;
+    private readonly storage;
+    constructor(world: World, storage?: StorageAdapter);
+    /** Snapshot the world and persist it under `slot`. */
+    save(slot?: string): void;
+    /** Restore `slot` into the world. Returns false if absent/corrupt (world untouched). */
+    load(slot?: string): boolean;
+    /** Is there a well-formed save in `slot`? */
+    has(slot?: string): boolean;
+    /** Delete a save slot. */
+    delete(slot?: string): void;
+    /** All slot names currently persisted. */
+    slots(): string[];
+}

package/dist/persist/storage.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A minimal key→string store. Deliberately tiny (get/set/remove/keys) so any
+ * backend — `localStorage`, a Map, a file, IndexedDB — satisfies it trivially.
+ */
+export interface StorageAdapter {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    /** All keys currently held, in insertion order where the backend preserves it. */
+    keys(): string[];
+}
+/** In-memory backend. Deterministic and self-contained — the headless default. */
+export declare class MemoryStorage implements StorageAdapter {
+    private readonly map;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    keys(): string[];
+}
+/** Swallows everything — reads always miss. For runs that must stay pristine. */
+export declare class NullStorage implements StorageAdapter {
+    get(_key: string): string | null;
+    set(_key: string, _value: string): void;
+    remove(_key: string): void;
+    keys(): string[];
+}
+/**
+ * `localStorage`-backed, guarded on every call: a disabled/absent/full store
+ * (private mode, quota, SSR) degrades to a silent miss instead of throwing, so a
+ * save failure never crashes a game. Keys are namespaced by `prefix`.
+ */
+export declare class LocalStorageAdapter implements StorageAdapter {
+    private readonly prefix;
+    constructor(prefix?: string);
+    private ls;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    keys(): string[];
+}
+/**
+ * The right adapter for the current environment: `localStorage` when a real one
+ * is present (browser), otherwise an in-memory map (headless tests/CI). Pass
+ * `NullStorage` explicitly when you want reads to always miss.
+ */
+export declare function defaultStorage(prefix?: string): StorageAdapter;

package/dist/physics/rigidBody.d.ts

@@ -0,0 +1,104 @@
+import type { Rect } from '../core/math';
+export type RigidShape = {
+    kind: 'circle';
+    r: number;
+}
+/** Convex polygon, CCW winding, local coords flat [x0,y0,x1,y1,…]. */
+ | {
+    kind: 'poly';
+    points: number[];
+};
+export type BodyKind = 'dynamic' | 'static' | 'kinematic';
+export interface RigidBody {
+    id: number;
+    kind: BodyKind;
+    shape: RigidShape;
+    /** Pose: position of the center of mass + rotation. */
+    x: number;
+    y: number;
+    a: number;
+    /** Velocity: linear + angular (rad/s). */
+    vx: number;
+    vy: number;
+    w: number;
+    /** Mass properties (0 inverse = immovable / non-rotating). */
+    m: number;
+    invM: number;
+    i: number;
+    invI: number;
+    restitution: number;
+    friction: number;
+    linDamp: number;
+    angDamp: number;
+    gravityScale: number;
+    /** Swept-circle CCD each step (circles only) — for very fast bodies. */
+    bullet: boolean;
+    /** Overlap events only, no collision response. */
+    sensor: boolean;
+    /** Collision filtering: collide iff (a.mask & b.layer) && (b.mask & a.layer). */
+    layer: number;
+    mask: number;
+    canSleep: boolean;
+    sleeping: boolean;
+    sleepTime: number;
+    /** Characteristic radius: converts spin to rim speed for the sleep test. */
+    sleepR: number;
+    /** Per-step force/torque accumulators (cleared after integration). */
+    fx: number;
+    fy: number;
+    torque: number;
+}
+export interface RigidWorldOpts {
+    gravityX?: number;
+    gravityY?: number;
+    /** Solver velocity iterations (default 16 — stacks need it). */
+    iterations?: number;
+    /** Broadphase cell size in px (default 96). */
+    cellSize?: number;
+}
+export interface RigidWorld {
+    gravityX: number;
+    gravityY: number;
+    iterations: number;
+    cellSize: number;
+    nextId: number;
+    bodies: RigidBody[];
+    joints: import('./rigidJoints').Joint[];
+    /** Warm-start impulse cache from the previous step, keyed "a:b:feature". */
+    warm: Record<string, [number, number]>;
+}
+export declare function createRigidWorld(opts?: RigidWorldOpts): RigidWorld;
+export interface RigidBodyDef {
+    kind?: BodyKind;
+    shape: RigidShape;
+    x?: number;
+    y?: number;
+    a?: number;
+    vx?: number;
+    vy?: number;
+    w?: number;
+    density?: number;
+    restitution?: number;
+    friction?: number;
+    linDamp?: number;
+    angDamp?: number;
+    gravityScale?: number;
+    bullet?: boolean;
+    sensor?: boolean;
+    layer?: number;
+    mask?: number;
+    canSleep?: boolean;
+    /** Lock rotation (players, elevators): infinite inertia. */
+    fixedRotation?: boolean;
+}
+export declare function addBody(rw: RigidWorld, def: RigidBodyDef): number;
+export declare function getBody(rw: RigidWorld, id: number): RigidBody | undefined;
+export declare function removeBody(rw: RigidWorld, id: number): void;
+export declare function wakeBody(b: RigidBody): void;
+/** Apply an impulse at a world point (wakes the body). */
+export declare function applyImpulse(rw: RigidWorld, id: number, ix: number, iy: number, px?: number, py?: number): void;
+/** World-space vertices of a poly body (freshly computed — no caches). */
+export declare function worldPoints(b: RigidBody): number[];
+export declare function bodyAABB(b: RigidBody): Rect;
+/** Centered box as a CCW convex polygon — the workhorse shape helper. */
+export declare function polygonBox(w: number, h: number): RigidShape;

package/dist/physics/rigidCollide.d.ts

@@ -0,0 +1,16 @@
+import type { RigidBody } from './rigidBody';
+export interface ContactPoint {
+    px: number;
+    py: number;
+    pen: number;
+    feature: number;
+}
+export interface Manifold {
+    a: RigidBody;
+    b: RigidBody;
+    nx: number;
+    ny: number;
+    points: ContactPoint[];
+}
+/** Dispatch on shape kinds. Normal always points from A toward B. */
+export declare function collide(a: RigidBody, b: RigidBody): Manifold | null;

package/dist/physics/rigidJoints.d.ts

@@ -0,0 +1,65 @@
+import type { RigidBody, RigidWorld } from './rigidBody';
+export interface DistanceJoint {
+    kind: 'distance';
+    id: number;
+    a: number;
+    b: number;
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    length: number;
+    /** Rope mode: only constrain when stretched past `length`. */
+    rope: boolean;
+}
+export interface RevoluteJoint {
+    kind: 'revolute';
+    id: number;
+    a: number;
+    b: number;
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    /** Motor: drive relative angular velocity toward `motorSpeed`. */
+    motorSpeed: number;
+    maxMotorTorque: number;
+    /** Angle limits on (b.a - a.a - refAngle); NaN-free: enabled flag. */
+    limitLower: number;
+    limitUpper: number;
+    limitEnabled: boolean;
+    refAngle: number;
+}
+export type Joint = DistanceJoint | RevoluteJoint;
+export interface DistanceJointDef {
+    a: number;
+    b: number;
+    ax?: number;
+    ay?: number;
+    bx?: number;
+    by?: number;
+    /** Defaults to the current anchor distance. */
+    length?: number;
+    rope?: boolean;
+}
+export interface RevoluteJointDef {
+    a: number;
+    b: number;
+    /** World-space pivot; local anchors are derived from current poses. */
+    px: number;
+    py: number;
+    motorSpeed?: number;
+    maxMotorTorque?: number;
+    limitLower?: number;
+    limitUpper?: number;
+}
+export declare function addDistanceJoint(rw: RigidWorld, def: DistanceJointDef): number;
+export declare function addRevoluteJoint(rw: RigidWorld, def: RevoluteJointDef): number;
+export declare function getJoint(rw: RigidWorld, id: number): Joint | undefined;
+export declare function removeJoint(rw: RigidWorld, id: number): void;
+/** Per-step scratch for accumulated-impulse clamping (one per joint). */
+export interface JointScratch {
+    motorImpulse: number;
+}
+/** One velocity iteration for a single joint. `bias` uses dt for Baumgarte. */
+export declare function solveJoint(j: Joint, A: RigidBody, B: RigidBody, dt: number, scratch: JointScratch): void;

package/dist/physics/rigidQueries.d.ts

@@ -0,0 +1,15 @@
+import type { RigidBody, RigidWorld } from './rigidBody';
+export interface RigidRayHit {
+    id: number;
+    t: number;
+    x: number;
+    y: number;
+    nx: number;
+    ny: number;
+}
+/** Is a world point inside this body's shape? */
+export declare function bodyContains(b: RigidBody, x: number, y: number): boolean;
+/** First body containing the point (topmost = last added wins ties via scan order). */
+export declare function pointQuery(rw: RigidWorld, x: number, y: number, mask?: number): RigidBody | undefined;
+/** Closest hit along the segment (x0,y0)→(x1,y1), or null. */
+export declare function rayCastRigid(rw: RigidWorld, x0: number, y0: number, x1: number, y1: number, mask?: number): RigidRayHit | null;

package/dist/physics/rigidStep.d.ts

@@ -0,0 +1,14 @@
+import type { RigidWorld } from './rigidBody';
+export interface ContactEvent {
+    a: number;
+    b: number;
+    px: number;
+    py: number;
+    nx: number;
+    ny: number;
+    /** Total normal impulse this step — scales with hit violence. */
+    impulse: number;
+    /** Sensor overlap (no collision response was applied). */
+    sensor: boolean;
+}
+export declare function rigidStep(rw: RigidWorld, dt: number): ContactEvent[];

package/dist/procgen/cave.d.ts

@@ -0,0 +1,21 @@
+import type { Rng } from '../core/rng';
+import { type Grid } from './grid';
+export interface CaveOptions {
+    cols: number;
+    rows: number;
+    /** Initial solid-fill probability (0..1). ~0.45 gives balanced caverns. */
+    fill?: number;
+    /** Smoothing passes (more = rounder, larger chambers). Default 4. */
+    steps?: number;
+    /** A cell becomes solid if it has ≥ this many solid neighbours. Default 5. */
+    birth?: number;
+    /** A solid cell survives if it has ≥ this many solid neighbours. Default 4. */
+    survive?: number;
+    /** Force the outer ring solid so the cave is sealed. Default true. */
+    border?: boolean;
+}
+/**
+ * Generate a cave grid (1 = rock, 0 = open) with cellular automata. Deterministic
+ * given `rng`'s state + options. Feed the result to `gridToTilemap` for physics.
+ */
+export declare function generateCave(rng: Rng, opts: CaveOptions): Grid;

package/dist/procgen/grid.d.ts

@@ -0,0 +1,21 @@
+import { type TilemapData } from '../physics/tilemap';
+export interface Grid {
+    cols: number;
+    rows: number;
+    /** Row-major cells, length cols*rows. 1 = solid, 0 = open. */
+    cells: number[];
+}
+/** Allocate a grid filled with a single value (default open). */
+export declare function makeGrid(cols: number, rows: number, fill?: number): Grid;
+/** Read a cell; out-of-bounds reads as solid (1) so borders seal naturally. */
+export declare function gridAt(g: Grid, x: number, y: number): number;
+/** Write a cell (no-op out of bounds). */
+export declare function gridSet(g: Grid, x: number, y: number, v: number): void;
+/** Count solid cells in the 8-neighbourhood (Moore) around (x,y). */
+export declare function solidNeighbours(g: Grid, x: number, y: number): number;
+/**
+ * Project a grid to collision geometry: 1 → SOLID, everything else → EMPTY.
+ * The result is a logical, hash-relevant `TilemapData` — feed it straight to
+ * the physics tilemap functions.
+ */
+export declare function gridToTilemap(g: Grid, tileSize?: number): TilemapData;

package/dist/procgen/rooms.d.ts

@@ -0,0 +1,34 @@
+import type { Rng } from '../core/rng';
+import { type Grid } from './grid';
+export interface Room {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface DungeonOptions {
+    cols: number;
+    rows: number;
+    /** How many placement attempts to make (actual rooms ≤ this). Default 12. */
+    attempts?: number;
+    /** Room side length range (tiles), inclusive. */
+    minSize?: number;
+    maxSize?: number;
+    /** Keep a 1-tile solid margin around the grid. Default true. */
+    border?: boolean;
+}
+export interface Dungeon {
+    rooms: Room[];
+    grid: Grid;
+}
+/** Center tile of a room (floored). */
+export declare function roomCenter(r: Room): {
+    x: number;
+    y: number;
+};
+/**
+ * Generate a room-and-corridor layout in a grid (1 = wall, 0 = floor).
+ * Deterministic given `rng` state + options; consecutive rooms are joined so the
+ * whole floor is connected. Feed `.grid` to `gridToTilemap` for physics.
+ */
+export declare function generateDungeon(rng: Rng, opts: DungeonOptions): Dungeon;

package/dist/procgen/scatter.d.ts

@@ -0,0 +1,32 @@
+/** 32-bit integer hash of a 2D cell + seed. Well-mixed; avalanche on any bit. */
+export declare function cellHash(x: number, y: number, seed?: number): number;
+/** Deterministic float in [0,1) for a cell — hash normalized. */
+export declare function cellFloat(x: number, y: number, seed?: number): number;
+/** Deterministic integer in [0,n) for a cell (e.g. pick a decoration variant). */
+export declare function cellInt(x: number, y: number, n: number, seed?: number): number;
+/** True with ~`probability` at this cell — the stateless scatter test. */
+export declare function scatter(x: number, y: number, probability: number, seed?: number): boolean;
+/**
+ * Enumerate the chosen cells in a rectangle, row-major (ordered). Handy for
+ * placing decoration nodes over a visible region without a PRNG. Cosmetic.
+ */
+export declare function scatterCells(x0: number, y0: number, cols: number, rows: number, probability: number, seed?: number): {
+    x: number;
+    y: number;
+}[];
+/**
+ * Value noise in [0,1] at a fractional coordinate — smooth bilinear blend of the
+ * four surrounding integer-cell hashes. This is the deliberately-small
+ * alternative to a simplex lib (see JS13K-MINING anti-recommendations): enough
+ * for cosmetic terrain tint, cloud cover, wobble; not a gameplay dependency.
+ */
+export declare function valueNoise(x: number, y: number, seed?: number): number;
+export interface FractalOptions {
+    octaves?: number;
+    /** Frequency multiplier per octave (default 2). */
+    lacunarity?: number;
+    /** Amplitude multiplier per octave (default 0.5). */
+    gain?: number;
+}
+/** Fractal (fBm) value noise — layered octaves, normalized to [0,1]. Cosmetic. */
+export declare function fractalNoise(x: number, y: number, seed?: number, opts?: FractalOptions): number;

package/dist/procgen/terrain.d.ts

@@ -0,0 +1,24 @@
+import { type FractalOptions } from './scatter';
+export interface TerrainOptions {
+    /** Baseline ground row (tiles from the top). */
+    base: number;
+    /** Peak deviation above/below the baseline (tiles). */
+    amplitude: number;
+    /** Horizontal frequency — smaller = longer, smoother hills. Default 0.08. */
+    scale?: number;
+    /** Clamp ground into [minRow, maxRow] so it stays on-screen. */
+    minRow?: number;
+    maxRow?: number;
+    seed?: number;
+    fractal?: FractalOptions;
+}
+/**
+ * Ground row (integer tile Y) for a column. Lower row = higher ground. Sampling
+ * the same (col, opts) always returns the same height — the endless-terrain
+ * contract.
+ */
+export declare function terrainHeight(col: number, opts: TerrainOptions): number;
+/** Ground rows for a contiguous chunk `[startCol, startCol+count)` (ordered). */
+export declare function terrainSlice(startCol: number, count: number, opts: TerrainOptions): number[];
+/** True when a tile is solid ground (at or below the surface row) at (col,row). */
+export declare function isGround(col: number, row: number, opts: TerrainOptions): boolean;

package/dist/render/nineSlice.d.ts

@@ -0,0 +1,32 @@
+import { type Rect, type Transform } from '../core/math';
+import type { DrawCommand } from './commands';
+export interface NineSliceStyle {
+    /** Corner size in px — the slice inset that never stretches. */
+    border: number;
+    /** Center fill (the panel body). */
+    fill?: string;
+    /** Edge fill (top/bottom/left/right strips). Defaults to `fill`. */
+    edge?: string;
+    /** Corner fill (the four fixed squares). Defaults to `edge`. */
+    corner?: string;
+    /** Optional bevel: lighten the top/left, darken the bottom/right. */
+    highlight?: string;
+    shadow?: string;
+    /** Outline stroke drawn around the whole frame. */
+    stroke?: string;
+    strokeWidth?: number;
+    /** Outer corner radius applied to the four corner squares. */
+    radius?: number;
+}
+/**
+ * Emit the draw commands for a 9-slice panel filling `rect`. Regions are pushed
+ * back-to-front (center → edges → corners) at painter key `z`, transformed by
+ * `transform` (screen space by default). Border is clamped so it never exceeds
+ * half the smaller side, keeping the grid valid at any size.
+ */
+export declare function nineSlice(rect: Rect, style: NineSliceStyle, z?: number, transform?: Transform): DrawCommand[];
+/** Ready-made frame looks. */
+export declare const PANEL_PRESETS: {
+    readonly parchment: () => NineSliceStyle;
+    readonly slate: () => NineSliceStyle;
+};