lantern-engine 0.0.0-stage → 0.4.0

package/dist/types/pixel/PixelLayer.d.ts

@@ -0,0 +1,85 @@
+import { Graphics } from '../core/Graphics.js';
+import type { Stage } from '../core/Stage.js';
+/**
+ * A `Graphics` for the pixel effects: every `fillRect` of a frame is written into a small RGBA buffer
+ * and shown as **one** sprite, instead of becoming a rect Pixi must tessellate, batch and upload. An effect's frame is
+ * hundreds to thousands of one-pixel runs (a poison cloud, a status mark round every body in a pack), and as rects they
+ * were most of a fight's CPU on a phone (profiled). The pixels are the same: whole
+ * world pixels, a translucent fill blended over what was painted before it in the same frame, as a Graphics did.
+ *
+ * Paint between `clear()` and `present()`; anything other than `fillStyle`/`fillRect` still draws through the
+ * Graphics underneath, so a painter using another shape keeps working. Solid pixels may also be **staged**
+ * (`stage`, from `pixelTone`'s batch) and laid in one go by `commit`, which is what a batch's flush does.
+ *
+ * Buffers and their textures are pooled by size class (a texture per effect ran to ~114 a second in a busy fight,
+ * and each one stayed in Pixi's batch tables), so a destroyed layer hands its texture
+ * to the next one; `PixelLayer.drainPool` lets them all go when the map changes.
+ */
+/** A new `PixelLayer` on the stage's world layer. */
+export declare function addPixelLayer(stage: Stage): PixelLayer;
+export declare class PixelLayer extends Graphics {
+    /** This frame's rects: x, y, w, h, colour, alpha — six numbers each. */
+    private readonly rects;
+    /** Staged solid runs not yet committed: x, y, w, colour — four numbers each; later ones win. */
+    private readonly staged;
+    private ink;
+    private inkAlpha;
+    private readonly sprite;
+    private surface;
+    /** Where the buffer's first pixel sits in the layer, as of the last `present`. */
+    private originX;
+    private originY;
+    /** The last frame's size, and how many presents in a row it stayed well inside a quarter of the buffer. */
+    private lastW;
+    private lastH;
+    private small;
+    constructor();
+    /** Textures made, spent buffers waiting in the pool and their bytes (the leak tools read it). */
+    static stats(): {
+        made: number;
+        pooled: number;
+        pooledBytes: number;
+    };
+    /** Lets every pooled buffer go (the world changed map): the next map's effects start a pool of their own. */
+    static drainPool(): void;
+    fillStyle(color: number, alpha?: number): this;
+    fillRect(x: number, y: number, w: number, h: number): this;
+    /** `fillStyle` + `fillRect` on whole pixels in one call, leaving the fill style alone (a hot loop's way in). */
+    rect(x: number, y: number, w: number, h: number, color: number, alpha?: number): void;
+    /**
+     * A solid run of `w` whole pixels at (x, y) in `color`, held until `commit` lays every staged run in the order given
+     * (the later winning where they cross), after whatever was drawn before the commit. What `pixelTone`'s batch writes
+     * instead of filing each pixel in a map and sorting it into rects.
+     */
+    stage(x: number, y: number, w: number, color: number): void;
+    /** Lays the staged runs, as opaque rects, after everything drawn so far. */
+    commit(): void;
+    clear(): this;
+    /** How far the last frame reached from the layer's origin, in world pixels (0 when nothing showed). */
+    reach(): number;
+    /** Writes this frame's rects into the texture and shows it; call once the frame is painted. */
+    present(): void;
+    /**
+     * Shows `other`'s last frame instead of painting one: its texture, placed where it placed it. A frame shared by
+     * several bodies (the same aura on two bodies) is painted once and shown by each of their layers.
+     */
+    mirror(other: PixelLayer): void;
+    /** Shows nothing and lets go of the texture a `mirror` showed. */
+    hideMirror(): void;
+    /** The premultiplied [r, g, b, a] last presented at layer pixel (x, y); zeros where nothing was (tests read it). */
+    pixelAt(x: number, y: number): [number, number, number, number];
+    /** The buffer's size (tests read it). */
+    capacity(): {
+        w: number;
+        h: number;
+    };
+    /**
+     * A buffer at least `w` × `h`: grown a size class at a time and kept while it fits, traded back to the pool for a
+     * smaller one only once the frames have stayed well inside it for `SHRINK_AFTER` presents (a long-lived layer — an
+     * aura, a status mark — that once swelled would otherwise hold and upload its largest buffer for good).
+     */
+    private fit;
+    private dropSurface;
+    destroy(): void;
+}
+//# sourceMappingURL=PixelLayer.d.ts.map

package/dist/types/pixel/PixelLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixelLayer.d.ts","sourceRoot":"","sources":["../../../src/pixel/PixelLayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAqF3C;;;;;;;;;;;;;;GAcG;AACH,qDAAqD;AACrD,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAEtD;AAED,qBAAa,UAAW,SAAQ,QAAQ;IACtC,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,GAAG,CAAY;IACvB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,OAAO,CAAwB;IACvC,kFAAkF;IAClF,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,2GAA2G;IAC3G,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;;IAQlB,iGAAiG;IACjG,MAAM,CAAC,KAAK,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;IAMrE,6GAA6G;IAC7G,MAAM,CAAC,SAAS,IAAI,IAAI;IAMf,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,IAAI;IAMzC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IASnE,gHAAgH;IAChH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,IAAI;IAKhF;;;;OAIG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI3D,4EAA4E;IAC5E,MAAM,IAAI,IAAI;IASL,KAAK,IAAI,IAAI;IAMtB,uGAAuG;IACvG,KAAK,IAAI,MAAM;IAKf,+FAA+F;IAC/F,OAAO,IAAI,IAAI;IAsFf;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAe/B,kEAAkE;IAClE,UAAU,IAAI,IAAI;IAKlB,oHAAoH;IACpH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAa/D,yCAAyC;IACzC,QAAQ,IAAI;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAIpC;;;;OAIG;IACH,OAAO,CAAC,GAAG;IAmBX,OAAO,CAAC,WAAW;IAMV,OAAO,IAAI,IAAI;CAKzB"}

package/dist/types/pixel/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Dither, Lantern Engine's pixel-art module: `import { … } from 'lantern-engine/pixel'`.
+ *
+ * Everything here works on the world's own pixel grid: rects batched into one texture, shapes shaded by hue-shifted
+ * ramps and faded by ordered dither, dithered lighting, bodies that evaporate into their own pixels. Start the engine
+ * with `pixelPerfect: true` so textures stay sharp and the camera lands on whole pixels.
+ */
+export { PixelLayer, addPixelLayer } from './PixelLayer.js';
+export { PixelGrid, PixelWindow, CLEAR, rgba, hex, channels, shade, mix, withAlpha, toCss, hash2, mulberry32, valueNoise, makeSheet, upscale, type Color, } from './pixel.js';
+export { P as PALETTE } from './palette.js';
+export { art, litOutline, groundShadow, shadeBox, type PropArt } from './propKit.js';
+export { ramp, rampTones, hueShade, outlineOf, MATERIALS, type Material, type Ramp } from './ramp.js';
+export { selectiveOutline } from './selout.js';
+/** Pixel shapes on the 1-px world grid: `pixelPaint.ring(g, …)`, `pixelPaint.arc(g, …)`… */
+export * as pixelPaint from './pixelPaint.js';
+/** Colour ramps, grading, dithering and batching under `pixelPaint`. */
+export * as pixelTone from './pixelTone.js';
+export { Evaporation, type DeathPixels } from './Evaporation.js';
+export { spritePixels, NO_PIXELS, PackedPixels, type SpritePixel } from './spritePixels.js';
+export { Darkness, WARM_LIGHT, LAMP_DIM, CARRIED_LIGHT } from './Darkness.js';
+export { flashLight, carriedLight, liveLights, clearLights, type TransientLight } from './lights.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/pixel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pixel/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACL,SAAS,EACT,WAAW,EACX,KAAK,EACL,IAAI,EACJ,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,SAAS,EACT,KAAK,EACL,KAAK,EACL,UAAU,EACV,UAAU,EACV,SAAS,EACT,OAAO,EACP,KAAK,KAAK,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,CAAC,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnG,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,4FAA4F;AAC5F,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,wEAAwE;AACxE,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEzF,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/pixel/lights.d.ts

@@ -0,0 +1,34 @@
+export interface TransientLight {
+    x: number;
+    y: number;
+    /** Radius at its brightest, world px. */
+    r: number;
+    born: number;
+    /** When it is gone; a carried light's is pushed to `CARRIED_MAX_MS` and brought in by its `end()`. */
+    until: number;
+    /** A light riding a moving thing reads its place every frame. */
+    follow?: () => {
+        x: number;
+        y: number;
+    };
+    /** A flash shrinks as it goes out; a carried light keeps its size. */
+    fades: boolean;
+    /** The colour it lays on what it lights: a fireball's orange, a spell's violet, a blade's white. */
+    color: number;
+}
+/** A flash at (x, y) in `color`: `r` px at once, shrinking to nothing over `ms`. */
+export declare function flashLight(x: number, y: number, r: number, ms: number, color?: number, now?: number): void;
+/** A light that rides `at` until `end()` is called (a shot in flight), and never past `CARRIED_MAX_MS`. */
+export declare function carriedLight(at: () => {
+    x: number;
+    y: number;
+}, r: number, color?: number, now?: number): {
+    end: () => void;
+};
+/** The lights burning at `now`, each with its radius then; spent ones are dropped. None while combat lights are off. */
+export declare function liveLights(now: number): readonly TransientLight[];
+/** The radius `l` burns at `now`: a flash eases out from its full size, a carried light holds it. */
+export declare function lightRadius(l: TransientLight, now: number): number;
+/** A new map: nothing of the last one's fight is left burning. */
+export declare function clearLights(): void;
+//# sourceMappingURL=lights.d.ts.map

package/dist/types/pixel/lights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/pixel/lights.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,yCAAyC;IACzC,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,sGAAsG;IACtG,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,sEAAsE;IACtE,KAAK,EAAE,OAAO,CAAC;IACf,oGAAoG;IACpG,KAAK,EAAE,MAAM,CAAC;CACf;AASD,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,SAAQ,EAAE,GAAG,SAAoB,GAAG,IAAI,CAGpH;AAKD,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,SAAQ,EAAE,GAAG,SAAoB,GAAG;IAAE,GAAG,EAAE,MAAM,IAAI,CAAA;CAAE,CAMvI;AAID,wHAAwH;AACxH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,cAAc,EAAE,CAoBjE;AAED,qGAAqG;AACrG,wBAAgB,WAAW,CAAC,CAAC,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED,kEAAkE;AAClE,wBAAgB,WAAW,IAAI,IAAI,CAElC"}

package/dist/types/pixel/palette.d.ts

@@ -0,0 +1,54 @@
+/** Shared colour palette: warm medieval fantasy tones, readable on green ground. */
+export declare const P: {
+    readonly outline: number;
+    readonly outlineSoft: number;
+    readonly black: number;
+    readonly white: number;
+    readonly offWhite: number;
+    readonly skin: number;
+    readonly skinShade: number;
+    readonly skinTan: number;
+    readonly skinTanShade: number;
+    readonly blush: number;
+    readonly hairBlack: number;
+    readonly hairBrown: number;
+    readonly hairAuburn: number;
+    readonly hairWhite: number;
+    readonly hairGrey: number;
+    readonly red: number;
+    readonly redDark: number;
+    readonly crimson: number;
+    readonly orange: number;
+    readonly gold: number;
+    readonly goldDark: number;
+    readonly yellow: number;
+    readonly green: number;
+    readonly greenDark: number;
+    readonly jade: number;
+    readonly jadeDark: number;
+    readonly teal: number;
+    readonly sky: number;
+    readonly azure: number;
+    readonly blue: number;
+    readonly navy: number;
+    readonly indigo: number;
+    readonly purple: number;
+    readonly pink: number;
+    readonly brown: number;
+    readonly brownDark: number;
+    readonly brownLight: number;
+    readonly tan: number;
+    readonly cream: number;
+    readonly grey: number;
+    readonly greyDark: number;
+    readonly greyLight: number;
+    readonly steel: number;
+    readonly steelDark: number;
+    readonly iron: number;
+    readonly wood: number;
+    readonly woodDark: number;
+    readonly woodLight: number;
+    readonly straw: number;
+    readonly strawDark: number;
+};
+//# sourceMappingURL=palette.d.ts.map

package/dist/types/pixel/palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../../src/pixel/palette.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDJ,CAAC"}

package/dist/types/pixel/pixel.d.ts

@@ -0,0 +1,80 @@
+export type Color = number;
+export declare const CLEAR: Color;
+export declare function rgba(r: number, g: number, b: number, a?: number): Color;
+export declare function hex(s: string): Color;
+export declare function channels(c: Color): [number, number, number, number];
+/** f < 1 darkens, f > 1 lightens toward white. */
+export declare function shade(c: Color, f: number): Color;
+export declare function mix(c1: Color, c2: Color, t: number): Color;
+export declare function withAlpha(c: Color, alpha: number): Color;
+export declare function toCss(c: Color): string;
+export declare function hash2(x: number, y: number, seed?: number): number;
+export declare function mulberry32(seed: number): () => number;
+export declare function valueNoise(x: number, y: number, scale: number, seed: number): number;
+export declare class PixelGrid {
+    readonly w: number;
+    readonly h: number;
+    readonly data: Uint32Array;
+    constructor(w: number, h: number);
+    inBounds(x: number, y: number): boolean;
+    px(x: number, y: number, c: Color): void;
+    get(x: number, y: number): Color;
+    alphaAt(x: number, y: number): number;
+    rect(x: number, y: number, w: number, h: number, c: Color): void;
+    hline(x0: number, x1: number, y: number, c: Color): void;
+    vline(x: number, y0: number, y1: number, c: Color): void;
+    /** Filled ellipse; a pixel is inside when its center lies inside the ellipse. */
+    ellipse(cx: number, cy: number, rx: number, ry: number, c: Color): void;
+    circle(cx: number, cy: number, r: number, c: Color): void;
+    ring(cx: number, cy: number, r: number, thickness: number, c: Color): void;
+    line(x0: number, y0: number, x1: number, y1: number, c: Color, thickness?: number): void;
+    /** Filled polygon (even-odd scanline on pixel centers). */
+    poly(points: [number, number][], c: Color): void;
+    /**
+     * Adds `width` pixels of outline around all opaque pixels, one ring at a time — the same result as calling it
+     * `width` times, but each ring only visits the neighbours of the ring before it instead of the whole grid again.
+     * (A pixel next to ring `k` is always filled by ring `k+1`, so nothing further back can still be waiting.)
+     */
+    outline(c: Color, diagonal?: boolean, width?: number): void;
+    /** Replaces every pixel whose color matches `from`. */
+    recolor(from: Color, to: Color): void;
+    /** Multiplies brightness of opaque pixels matching `pred`. */
+    tint(f: number, pred: (x: number, y: number) => boolean): void;
+    blit(src: PixelGrid, dx: number, dy: number, flipX?: boolean): void;
+    /** Alpha-blends a color onto an existing pixel. */
+    blend(x: number, y: number, c: Color): void;
+    /** Reads a canvas back into a grid (a PNG layer of the paper doll joining the painted ones). */
+    static from(canvas: HTMLCanvasElement): PixelGrid;
+    /** The same picture on a grid `factor` times as fine, each pixel becoming a square block. */
+    upscaled(factor: number): PixelGrid;
+    /** Same size and same pixels. */
+    equals(other: PixelGrid): boolean;
+    /** Cheap hash of the pixels, for grouping identical frames before comparing them. */
+    key(): number;
+    clone(): PixelGrid;
+    toCanvas(): HTMLCanvasElement;
+}
+/**
+ * A grid that stands for one window of a larger picture: it is drawn on in the larger picture's coordinates and
+ * keeps only what falls inside `[x0, x0 + w) × [y0, y0 + h)`. A ground painter can paint a crop of a map into one, so the
+ * login screen does not paint the whole of two maps to show 17 tiles of each. Every drawing method goes through
+ * `px`/`get`/`inBounds`/`blend`; `outline`, `tint` and the whole-grid helpers work in window coordinates.
+ */
+export declare class PixelWindow extends PixelGrid {
+    readonly x0: number;
+    readonly y0: number;
+    constructor(x0: number, y0: number, w: number, h: number);
+    inBounds(x: number, y: number): boolean;
+    px(x: number, y: number, c: Color): void;
+    get(x: number, y: number): Color;
+    blend(x: number, y: number, c: Color): void;
+}
+/**
+ * Packs same-sized frames into rows no wider than `maxWidth`. A browser refuses a canvas past about 16k pixels
+ * on a side and hands back a blank one, and a player sheet of six hundred frames at twice the detail is wider
+ * than that, so it wraps. Readers work the row out from the canvas width.
+ */
+export declare function makeSheet(frames: PixelGrid[], maxWidth?: number): HTMLCanvasElement;
+/** Scales a canvas by an integer factor with nearest-neighbour filtering (for UI icons). */
+export declare function upscale(src: HTMLCanvasElement, factor: number): HTMLCanvasElement;
+//# sourceMappingURL=pixel.d.ts.map

package/dist/types/pixel/pixel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixel.d.ts","sourceRoot":"","sources":["../../../src/pixel/pixel.ts"],"names":[],"mappings":"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"}

package/dist/types/pixel/pixelPaint.d.ts

@@ -0,0 +1,43 @@
+import type { Graphics } from '../core/Graphics.js';
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare const WHITE = 16774358;
+export declare const snap: (n: number) => number;
+/** A `size`-px square (1 by default: one art pixel) on the world grid, graded into the world palette. */
+export declare function dot(g: Graphics, x: number, y: number, color: number, size?: number): void;
+/** A horizontal run of `w` px from (x, y), one pixel tall; drawn pixel by pixel while a dither fade or outline is on. */
+export declare function hline(g: Graphics, x: number, y: number, w: number, color: number): void;
+/** Paints `draw` with a dark 1px outline round everything it drew, like the outline on character and prop sprites. */
+export declare function outlined(g: Graphics, outline: number, draw: () => void): void;
+/**
+ * A line `width` px thick built from 1px rows: the row on one side is lit, the far row deep, and a long stroke tapers
+ * to the deep tone at both ends and catches a glint a third of the way along.
+ */
+export declare function stroke(g: Graphics, a: Point, b: Point, color: number, width?: number): void;
+/** A broken ellipse of radius `r` in the ground's 2:1 perspective, lit on the near side, turning with `phase`. */
+export declare function ring(g: Graphics, r: number, color: number, phase?: number, cy?: number): void;
+/** A faceted gem: light left face, base right face, deep lower tip and a glint on top once it is big enough. */
+export declare function diamond(g: Graphics, x: number, y: number, r: number, color: number): void;
+export declare function shards(g: Graphics, t: number, r: number, color: number, inward?: boolean): void;
+/** A filled stepped disc of radius `r` (smoke, gas, puddles), in the ground's 2:1 perspective when `flat`. */
+export declare function blob(g: Graphics, x: number, y: number, r: number, color: number, flat?: boolean): void;
+/** A droplet thrown from (x, y) with velocity (vx, vy) px/s under gravity, `ms` after it left; null once it lands. */
+export declare function drop(x: number, y: number, vx: number, vy: number, ms: number, ground?: number): Point | null;
+/** A pixel X, `r` from its centre to a tip. */
+export declare function xMark(g: Graphics, x: number, y: number, r: number, color: number): void;
+/** A dash streak from `a` to `b`: a dark body with a bright core, eaten away from the start as `t` goes 0 to 1. */
+export declare function dashStreak(g: Graphics, a: Point, b: Point, t: number, edge: number, core: number): void;
+/**
+ * A puff of smoke or gas: a small stepped disc whose rim is dithered (every other pixel) so it reads soft, with a
+ * lighter cap on its upper left. Solid discs the same size read as boulders or bushes.
+ */
+export declare function puffBlob(g: Graphics, x: number, y: number, r: number, body: number, light: number, frame?: number, opacity?: number): void;
+/** An arc of dots on an ellipse from angle `a0` to `a1` (flat: in the ground's 2:1 perspective), `thick` rows deep. */
+export declare function arc(g: Graphics, x: number, y: number, r: number, a0: number, a1: number, color: number, flat?: boolean, thick?: number): void;
+/** Pale stepped dust puffs kicked up around (x, y) and settling over `t` 0..1. */
+export declare function dust(g: Graphics, x: number, y: number, t: number, spread?: number, color?: number): void;
+/** Pixel chunks flung out of (x, y) under gravity (rock, splinters): `ms` after the blow. */
+export declare function debris(g: Graphics, x: number, y: number, count: number, speed: number, ms: number, colors: number[]): void;
+//# sourceMappingURL=pixelPaint.d.ts.map

package/dist/types/pixel/pixelPaint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixelPaint.d.ts","sourceRoot":"","sources":["../../../src/pixel/pixelPaint.ts"],"names":[],"mappings":"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"}

package/dist/types/pixel/pixelTone.d.ts

@@ -0,0 +1,49 @@
+import type { Graphics } from '../core/Graphics.js';
+import { PixelLayer } from './PixelLayer.js';
+export interface Ramp {
+    /** Darkest: under-shade and outline pixels. */
+    shade: number;
+    deep: number;
+    base: number;
+    light: number;
+    /** Near-white glint. */
+    hi: number;
+}
+export declare function ramp(color: number): Ramp;
+/** The formula's five tones for any colour: shadows cool and desaturate, highlights warm. */
+export declare function derivedRamp(color: number): Ramp;
+/**
+ * The colour a pixel is actually painted with: effects are authored in bright, saturated colours, and this pulls them
+ * into the world's palette (muted earth, grass and wood) — saturation down by a quarter, near-whites toned down and
+ * warmed, so an effect sits in the scene instead of glowing on top of it. Glints keep most of their lift.
+ */
+export declare function grade(color: number): number;
+export declare function capturing(): Map<number, number> | null;
+export declare function beginOutline(): void;
+export declare function endOutline(g: Graphics, outline: number): void;
+/**
+ * Lays pixels (keyed by `key`, each with its colour already graded) row by row, one rect for every run of one colour:
+ * the same pixels as one rect each, at a fraction of the rects (single-pixel rects ran to 5,000–9,000 a frame for one
+ * big ring or smoke, enough to be felt as lag).
+ */
+export declare function fillRuns(g: Graphics, pixels: Map<number, number>): void;
+export declare function beginBatch(g: Graphics): void;
+export declare function endBatch(): void;
+/**
+ * Where a solid pixel painted on `g` goes while its batch is open: the layer's staging, the batch's map, or nowhere
+ * (paint it now). `stagePixel` writes into whichever it is.
+ */
+export declare function batchFor(g: Graphics): Map<number, number> | PixelLayer | null;
+/** Writes a solid run of `w` pixels at (x, y) into what `batchFor` returned. */
+export declare function stageRun(held: Map<number, number> | PixelLayer, x: number, y: number, w: number, color: number): void;
+/** Lays what the batch holds now, so a translucent fill that follows lies over it. */
+export declare function flushBatch(): void;
+/** The key `capturing()` and `fillRuns` file a world pixel under. */
+export declare function pixelKey(x: number, y: number): number;
+export declare function record(x: number, y: number, color: number): void;
+export declare function setCoverage(value: number): void;
+/** The current dither fade (1 while nothing fades), for translucent fills that fade with their layer. */
+export declare function currentCoverage(): number;
+/** Whether the world pixel at (x, y) is dropped by the current dither fade. */
+export declare function dithered(x: number, y: number): boolean;
+//# sourceMappingURL=pixelTone.d.ts.map

package/dist/types/pixel/pixelTone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixelTone.d.ts","sourceRoot":"","sources":["../../../src/pixel/pixelTone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAQ1C,MAAM,WAAW,IAAI;IACnB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,EAAE,EAAE,MAAM,CAAC;CACZ;AA+ED,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAExC;AAED,6FAA6F;AAC7F,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAe/C;AAID;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAUD,wBAAgB,SAAS,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAEtD;AAKD,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAiB7D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAOvE;AAkBD,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAU5C;AAED,wBAAgB,QAAQ,IAAI,IAAI,CAM/B;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,GAAG,IAAI,CAG7E;AAED,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAMrH;AAED,sFAAsF;AACtF,wBAAgB,UAAU,IAAI,IAAI,CASjC;AA+BD,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhE;AAOD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,yGAAyG;AACzG,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAKtD"}

package/dist/types/pixel/propKit.d.ts

@@ -0,0 +1,26 @@
+import { type Color, PixelGrid } from './pixel.js';
+export interface PropArt {
+    canvas: HTMLCanvasElement;
+    anchorX: number;
+    anchorY: number;
+}
+export declare function art(g: PixelGrid, anchorX: number, anchorY: number): PropArt;
+/**
+ * The selective outline a prop takes, lit from the upper left like the map: the same ring a plain outline lays, but
+ * full dark only where the silhouette meets the ground (under it) and on its shadow side (the right); along the top
+ * and the left it is the darkest tone of the fill it borders (`outlineOf`), so a lit edge reads as the thing's own
+ * shade rather than a sticker's line. Translucent pixels (a cast
+ * shadow on the ground) are not part of the silhouette.
+ */
+export declare function litOutline(g: PixelGrid, dark?: Color): void;
+/**
+ * A soft shadow thrown down and to the right onto the ground, laid only on empty pixels (call it after `litOutline`,
+ * or the outline would ring the shadow): a darker core and a fainter rim, the violet of the rocks' shadows.
+ */
+export declare function groundShadow(g: PixelGrid, cx: number, cy: number, rx: number, ry: number): void;
+/**
+ * Moves every opaque pixel of a box one step into shadow (or, with `f > 1`, into light) along its own hue: the eave's
+ * shadow on a wall, the dark side of a chimney, a porch's shade. `mask` limits it to some pixels of the box.
+ */
+export declare function shadeBox(g: PixelGrid, x: number, y: number, w: number, h: number, f: number, mask?: (x: number, y: number) => boolean): void;
+//# sourceMappingURL=propKit.d.ts.map

package/dist/types/pixel/propKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propKit.d.ts","sourceRoot":"","sources":["../../../src/pixel/propKit.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,SAAS,EAAQ,MAAM,SAAS,CAAC;AAQtD,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,GAAE,KAAiB,GAAG,IAAI,CAetE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAU/F;AAUD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAQ5I"}

package/dist/types/pixel/ramp.d.ts

@@ -0,0 +1,31 @@
+import { type Color } from './pixel.js';
+export type Material = 'cloth' | 'leather' | 'mail' | 'plate' | 'dragon' | 'fur' | 'skin' | 'hair' | 'gold' | 'gem' | 'shadow';
+export declare const MATERIALS: readonly Material[];
+/** Tones of one colour in one material, darkest to brightest. `base` is the colour itself. */
+export interface Ramp {
+    /** Under-edges, rivets, seams: the darkest tone that is still the material. */
+    deep: Color;
+    dark: Color;
+    mid: Color;
+    base: Color;
+    light: Color;
+    /** One specular pixel: a plate's glint, a strand of hair, a buckle. */
+    glint: Color;
+}
+/** Every factor a ramp or a painter shades by — what a recolour or a fine-pass mask has to recognise. */
+export declare const RAMP_FACTOR_SET: readonly number[];
+/**
+ * `c` shaded by `f` the way `shade` would (f < 1 darkens, f > 1 lifts toward white), with the hue moved the way
+ * `material` moves it. `f === 1` returns `c` itself. A colour with too little saturation to have a hue (steel,
+ * grey wool, white linen) takes the material's hue outright, faintly, so a grey coat still has a violet shadow.
+ */
+export declare function hueShade(c: Color, f: number, material: Material): Color;
+export declare function ramp(c: Color, material: Material): Ramp;
+/** Every tone of `c`'s ramp, for masking a material cue to that material. */
+export declare function rampTones(c: Color, material: Material): Color[];
+/**
+ * The selective-outline tone of a fill: its own hue, cooled and pushed dark enough to hold an edge against grass
+ * (value at most 0.3), so the outline on the lit side is the fill's own darkest shade instead of flat black.
+ */
+export declare function outlineOf(c: Color): Color;
+//# sourceMappingURL=ramp.d.ts.map

package/dist/types/pixel/ramp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ramp.d.ts","sourceRoot":"","sources":["../../../src/pixel/ramp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAA8B,MAAM,SAAS,CAAC;AAUjE,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE/H,eAAO,MAAM,SAAS,EAAE,SAAS,QAAQ,EAAoG,CAAC;AAiC9I,8FAA8F;AAC9F,MAAM,WAAW,IAAI;IACnB,+EAA+E;IAC/E,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,KAAK,CAAC;IACX,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,uEAAuE;IACvE,KAAK,EAAE,KAAK,CAAC;CACd;AAiBD,yGAAyG;AACzG,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAAqD,CAAC;AAsCnG;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,CA2BvE;AAID,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CASvD;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,EAAE,CAG/D;AAID;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAQzC"}

package/dist/types/pixel/selout.d.ts

@@ -0,0 +1,3 @@
+import type { PixelGrid } from './pixel.js';
+export declare function selectiveOutline(g: PixelGrid, width?: number): void;
+//# sourceMappingURL=selout.d.ts.map

package/dist/types/pixel/selout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selout.d.ts","sourceRoot":"","sources":["../../../src/pixel/selout.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAWzC,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,SAAI,GAAG,IAAI,CAmD9D"}

package/dist/types/pixel/spritePixels.d.ts

@@ -0,0 +1,29 @@
+import type { Image } from '../core/Image.js';
+/** One opaque world pixel of a sprite frame: offset from the frame's feet (origin 0.5, 1) and its colour. */
+export interface SpritePixel {
+    dx: number;
+    dy: number;
+    color: number;
+}
+/**
+ * A frame's opaque pixels packed in typed arrays (12 bytes a pixel instead of an object each). Iterating hands out one
+ * reused `SpritePixel`, so read it in the loop and keep nothing of it; `at(i)` reads one into a given object.
+ */
+export declare class PackedPixels implements Iterable<SpritePixel> {
+    readonly dx: Float32Array;
+    readonly dy: Float32Array;
+    readonly color: Uint32Array;
+    readonly length: number;
+    constructor(dx: Float32Array, dy: Float32Array, color: Uint32Array, length: number);
+    [Symbol.iterator](): Iterator<SpritePixel>;
+}
+/** No pixels: what a body hands over when there is nothing of it worth lifting (a death with nothing to evaporate). */
+export declare const NO_PIXELS: PackedPixels;
+/**
+ * The opaque pixels of an image's current frame, one per **world** pixel (`artScale` image pixels to one), as offsets
+ * from the frame's feet in unscaled, unflipped world pixels. Read straight off the texture's canvas, so it is the
+ * frame actually on screen. Atlas frames are shared by every body of one kind and cached (least recently read out
+ * first); a texture repainted while in use (a rig body) is read fresh.
+ */
+export declare function spritePixels(img: Image, artScale: number, live: boolean): PackedPixels;
+//# sourceMappingURL=spritePixels.d.ts.map

package/dist/types/pixel/spritePixels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spritePixels.d.ts","sourceRoot":"","sources":["../../../src/pixel/spritePixels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,6GAA6G;AAC7G,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,qBAAa,YAAa,YAAW,QAAQ,CAAC,WAAW,CAAC;IAEtD,QAAQ,CAAC,EAAE,EAAE,YAAY;IACzB,QAAQ,CAAC,EAAE,EAAE,YAAY;IACzB,QAAQ,CAAC,KAAK,EAAE,WAAW;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAHd,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM;IAGxB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC;CAS5C;AAGD,uHAAuH;AACvH,eAAO,MAAM,SAAS,cAAQ,CAAC;AAwB/B;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,YAAY,CA+CtF"}

package/dist/types/platform/touch.d.ts

@@ -0,0 +1,5 @@
+/** A native shell (Capacitor, Electron touch kiosk…) tells the engine it is one; browsers leave it false. */
+export declare function setNativeShell(native: boolean): void;
+/** True when the game is played with fingers (decided once per launch, `detectTouch`). */
+export declare function isTouchUi(): boolean;
+//# sourceMappingURL=touch.d.ts.map

package/dist/types/platform/touch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch.d.ts","sourceRoot":"","sources":["../../../src/platform/touch.ts"],"names":[],"mappings":"AAKA,6GAA6G;AAC7G,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAGpD;AAqBD,0FAA0F;AAC1F,wBAAgB,SAAS,IAAI,OAAO,CAGnC"}

package/dist/types/rig/PosePlayer.d.ts

@@ -0,0 +1,64 @@
+import type { RigPose } from './rigTypes.js';
+/**
+ * A clip of key poses: by name (looked up in the player's library) or inline. The player blends between them, so a
+ * few keys make a smooth motion; `blend: false` steps from key to key instead (pixel-art timing, a tumble).
+ */
+export interface PoseClip {
+    poses: readonly (string | RigPose)[];
+    /** Keys per second (default 8). */
+    fps?: number;
+    /** Per-key lengths in ms, overriding `fps`. */
+    durations?: readonly number[];
+    /** Start over at the end, blending the last key into the first (default true). */
+    loop?: boolean;
+    /** Blend between keys (default true). */
+    blend?: boolean;
+}
+/**
+ * Plays pose clips over time and answers the pose of this moment, blended between keys, with a crossfade when the
+ * clip changes. Pure: give it a library of poses and clips, call `update(dt)`, read `pose`.
+ *
+ * ```ts
+ * const player = new PosePlayer(HUMANOID_POSES, HUMANOID_CLIPS, 'idle');
+ * player.play('walk', { fadeMs: 120 });
+ * player.update(dt);
+ * view.setPose(player.pose);
+ * ```
+ */
+export declare class PosePlayer<Name extends string = string> {
+    private readonly library;
+    private readonly clips;
+    private clip;
+    private name;
+    private elapsed;
+    private ended;
+    /** The pose being faded out of, and how long the fade lasts and has run. */
+    private from;
+    private fadeMs;
+    private fadeAt;
+    private cached;
+    speed: number;
+    /** Called when a clip that does not loop reaches its end. */
+    onComplete: ((clip: Name) => void) | null;
+    constructor(library: Readonly<Record<string, RigPose>>, clips: Record<Name, PoseClip>, initial: NoInfer<Name>);
+    get current(): Name;
+    get finished(): boolean;
+    /** Time into the current clip, ms. */
+    get time(): number;
+    /** Plays `name`, fading from the pose shown now over `fadeMs`. The clip already playing keeps going unless `restart`. */
+    play(name: Name, options?: {
+        fadeMs?: number;
+        restart?: boolean;
+    }): this;
+    /** Advances by `dt` seconds. */
+    update(dt: number): void;
+    /** The pose to show now. */
+    get pose(): RigPose;
+    /** The current clip's pose at `ms` into it. */
+    sample(ms: number): RigPose;
+    private totalMs;
+    private lengthOf;
+    private resolve;
+    private clipOf;
+}
+//# sourceMappingURL=PosePlayer.d.ts.map

package/dist/types/rig/PosePlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PosePlayer.d.ts","sourceRoot":"","sources":["../../../src/rig/PosePlayer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;IACrC,mCAAmC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,kFAAkF;IAClF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,yCAAyC;IACzC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,UAAU,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM;IAehD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAfxB,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAS;IACtB,4EAA4E;IAC5E,OAAO,CAAC,IAAI,CAAwB;IACpC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAwB;IACtC,KAAK,SAAK;IACV,6DAA6D;IAC7D,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;gBAG9B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC1C,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,EAC9C,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC;IAMxB,IAAI,OAAO,IAAI,IAAI,CAElB;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,sCAAsC;IACtC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,yHAAyH;IACzH,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,IAAI;IAc5E,gCAAgC;IAChC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAsBxB,4BAA4B;IAC5B,IAAI,IAAI,IAAI,OAAO,CAMlB;IAED,+CAA+C;IAC/C,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAkB3B,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,MAAM;CAOf"}