1681-engine 0.0.0-stage → 0.5.8

package/dist/types/assets/loadAseprite.d.ts

@@ -0,0 +1,27 @@
+import type { AsepriteSheet } from '../anim/asepriteTypes.js';
+import type { CanvasTexture } from '../core/TextureRegistry.js';
+import { type AssetLoaderOptions } from './AssetLoader.js';
+/** Where an Aseprite sheet's texture goes: the stage's `TextureRegistry` satisfies it. */
+export interface AsepriteTextureSink {
+    addCanvas(key: string, canvas: HTMLCanvasElement): CanvasTexture;
+}
+/** Fetch and decode hooks, as `AssetLoader` takes them (tests, custom transports, a base URL). */
+export type AsepriteLoadOptions = Pick<AssetLoaderOptions, 'baseUrl' | 'fetch' | 'toCanvas'>;
+/**
+ * Registers `canvas` (the sheet image) under `key` with one frame per sheet frame, named by its index ("0", "1"…), so
+ * the clips `parseAseprite` returns play on an `Image` of that key as they are. A trimmed frame keeps its untrimmed
+ * size and offset (Pixi's `orig` and `trim`), so a sprite anchored at its feet does not jump as the trim changes.
+ */
+export declare function addAsepriteTextures(textures: AsepriteTextureSink, key: string, canvas: HTMLCanvasElement, sheet: AsepriteSheet): CanvasTexture;
+/**
+ * Loads an Aseprite export — the JSON, then the sheet image it names (resolved beside the JSON) — registers its
+ * frames under `key` and returns the parsed sheet (clips, slices, layers, cues).
+ *
+ * ```ts
+ * const [hero] = await Promise.all([loadAseprite(stage.textures, 'hero', 'art/hero.json'), assets.load()]);
+ * const sprite = stage.add.image(0, 0, 'hero', 0);
+ * const anim = new Animator(hero.clips, 'idle');
+ * ```
+ */
+export declare function loadAseprite(textures: AsepriteTextureSink, key: string, jsonUrl: string, options?: AsepriteLoadOptions): Promise<AsepriteSheet>;
+//# sourceMappingURL=loadAseprite.d.ts.map

package/dist/types/assets/loadAseprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadAseprite.d.ts","sourceRoot":"","sources":["../../../src/assets/loadAseprite.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEpE,0FAA0F;AAC1F,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,aAAa,CAAC;CAClE;AAED,kGAAkG;AAClG,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC,CAAC;AAE7F;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,aAAa,GAAG,aAAa,CAoB9I;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,aAAa,CAAC,CAmBzJ"}

package/dist/types/audio/Footsteps.d.ts

@@ -0,0 +1,33 @@
+/** What a surface sounds like underfoot: a step, and a beat of hooves (a mount) if it differs. */
+export interface SurfaceSounds {
+    step: string;
+    hoof?: string;
+}
+export interface FootstepOptions {
+    /** Per surface name (`'grass'`, `'stone'`, `'wood'`…), the sounds a foot makes on it. */
+    sounds: Record<string, SurfaceSounds>;
+    /** The surface of anywhere `surfaceAt` does not name. */
+    fallback: string;
+    /** Weight of a step against other sounds (default 0.5). */
+    gain?: number;
+    /** Beyond this (world px) nobody else's steps are heard (default 200). */
+    range?: number;
+}
+/**
+ * Footsteps by the ground under the feet. The game says what a point is made of (`surfaceAt`: a tile's surface, a
+ * Tiled property, a floor collider), and calls `step` on each beat of a walk or a gait; the sound is the surface's,
+ * through `sound` at the feet, quieter and muffled with distance like every other sound, and dropped first when too
+ * many sounds play at once.
+ */
+export declare class Footsteps {
+    private readonly options;
+    private surfaceAt;
+    constructor(options: FootstepOptions);
+    /** Where the surface of a world point comes from; `undefined` is the fallback surface. */
+    setSurfaceAt(surfaceAt: (x: number, y: number) => string | undefined): void;
+    /** The surface at a world point. */
+    surface(x: number, y: number): string;
+    /** One step (or a beat of hooves when `mounted`) at the feet, world x/y; `local` is the player's own. */
+    step(x: number, y: number, local: boolean, mounted?: boolean): void;
+}
+//# sourceMappingURL=Footsteps.d.ts.map

package/dist/types/audio/Footsteps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Footsteps.d.ts","sourceRoot":"","sources":["../../../src/audio/Footsteps.ts"],"names":[],"mappings":"AAEA,kGAAkG;AAClG,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,yFAAyF;IACzF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACtC,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,SAAS,CAAiE;gBAErD,OAAO,EAAE,eAAe;IAErD,0FAA0F;IAC1F,YAAY,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GAAG,IAAI;IAI3E,oCAAoC;IACpC,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAIrC,yGAAyG;IACzG,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,UAAQ,GAAG,IAAI;CAMlE"}

package/dist/types/audio/MusicPlayer.d.ts

@@ -0,0 +1,65 @@
+import { MusicChannel, type PlayOptions } from './music/MusicChannel.js';
+export type { PlayOptions } from './music/MusicChannel.js';
+/**
+ * How music reaches the speaker: `'element'` on the `<audio>` element's own volume (nothing in between; a file from
+ * another origin plays as it is), `'graph'` through a Web Audio gain (the only way where that volume is read-only),
+ * `'auto'` (default) the graph only where it has to be (iOS).
+ */
+export type MusicRoute = 'auto' | 'element' | 'graph';
+export interface MusicOptions {
+    route?: MusicRoute;
+    /** Stop the music while the page is hidden (an app sent to the background). Default: on touch devices. */
+    pauseInBackground?: boolean;
+}
+/**
+ * Background music in layers: each named channel (`'music'` by default, `'ambience'`, any other) plays one looping
+ * track at a time, crossfaded when it changes, all at `engineSettings.musicVolume`. Tracks stream through `<audio>`
+ * elements (no decoding a whole song into memory).
+ *
+ * Browsers start sound only after a user gesture: a track played before one starts on the first tap or key. On iOS the
+ * graph's context is woken inside that gesture too, and again after the app comes back from the background.
+ *
+ * ```ts
+ * music.play('music/forest.ogg');                                     // the 'music' channel
+ * music.channel('ambience').play('amb/wind.ogg', { volume: 0.5 });     // a second layer under it
+ * music.play('music/boss.ogg', { fadeMs: 600 });                      // crossfades the first only
+ * music.stop(2000);
+ * ```
+ */
+export declare class MusicPlayer {
+    private readonly channels;
+    private route;
+    private graph;
+    private graphLocked;
+    private pauseInBackground;
+    private installed;
+    /** Picks the route and background behaviour; call before the first track for the route to apply to every track. */
+    configure(options: MusicOptions): this;
+    /** The channel named `name`, made on first use. */
+    channel(name?: string): MusicChannel;
+    /** The url the `'music'` channel plays, if any. */
+    get current(): string | null;
+    /** Plays `url` on the `'music'` channel. */
+    play(url: string, options?: PlayOptions): void;
+    /** Fades every channel out. */
+    stop(fadeMs?: number): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    private voiceFor;
+    private throughGraph;
+    private context;
+    /** Retries every refused start and follows the volume; the graph's context resumes inside the gesture that called it. */
+    private wake;
+    private install;
+}
+/** A fade's value at `now`: linear from `from` to `to` over `ms`. */
+export declare function fadeValue(f: {
+    from: number;
+    to: number;
+    start: number;
+    ms: number;
+}, now: number): number;
+/** The shared music player. */
+export declare const music: MusicPlayer;
+//# sourceMappingURL=MusicPlayer.d.ts.map

package/dist/types/audio/MusicPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MusicPlayer.d.ts","sourceRoot":"","sources":["../../../src/audio/MusicPlayer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGtE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAEtD,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,0GAA0G;IAC1G,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAC5D,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,iBAAiB,CAAwB;IACjD,OAAO,CAAC,SAAS,CAAS;IAE1B,mHAAmH;IACnH,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAMtC,mDAAmD;IACnD,OAAO,CAAC,IAAI,SAAU,GAAG,YAAY;IAUrC,mDAAmD;IACnD,IAAI,OAAO,IAAI,MAAM,GAAG,IAAI,CAE3B;IAED,4CAA4C;IAC5C,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI;IAI9C,+BAA+B;IAC/B,IAAI,CAAC,MAAM,SAAO,GAAG,IAAI;IAIzB,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI,IAAI;IAId,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,OAAO;IAQf,yHAAyH;IACzH,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,OAAO;CAahB;AAED,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAIzG;AAED,+BAA+B;AAC/B,eAAO,MAAM,KAAK,aAAoB,CAAC"}

package/dist/types/audio/SoundEngine.d.ts

@@ -0,0 +1,42 @@
+export interface SoundOptions {
+    /** Where it happened in the world; absent for what happens to or is done by the local player. */
+    x?: number;
+    y?: number;
+    /** Done by (or to) the local player: full weight. */
+    local?: boolean;
+    /** Extra weight (default 1). */
+    gain?: number;
+    /** How far away it can be heard (px), when nearer than `HEARING`. */
+    range?: number;
+    /** Skipped when the mix is busy (footsteps). */
+    minor?: boolean;
+    /** Cut off after this long (ms), faded over `CUT_FADE_MS`: a cast's sound ends with the cast. */
+    maxMs?: number;
+}
+export declare class SoundEngine {
+    private ctx;
+    private master;
+    private readonly buffers;
+    private readonly samples;
+    private readonly lastAt;
+    private voices;
+    /** Where the local player stands, set by the world scene; null off the world screens. */
+    listener: () => {
+        x: number;
+        y: number;
+    } | null;
+    private onRunning;
+    constructor();
+    play(name: string | undefined, opts?: SoundOptions): void;
+    private level;
+    private context;
+    /**
+     * Starts decoding every recorded take and renders every recipe not rendered yet, one per task, once the context
+     * first runs — so the first swing of a fight does not pay for its sound in that frame.
+     */
+    private prerender;
+    /** Rendered on first use or by `prerender` (a few ms each), then kept. */
+    private buffer;
+}
+export declare const sound: SoundEngine;
+//# sourceMappingURL=SoundEngine.d.ts.map

package/dist/types/audio/SoundEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundEngine.d.ts","sourceRoot":"","sources":["../../../src/audio/SoundEngine.ts"],"names":[],"mappings":"AAqCA,MAAM,WAAW,YAAY;IAC3B,iGAAiG;IACjG,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iGAAiG;IACjG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,GAAG,CAA6B;IACxC,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,yFAAyF;IACzF,QAAQ,EAAE,MAAM;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAc;IAC7D,OAAO,CAAC,SAAS,CAAwC;;IAmCzD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,GAAE,YAAiB,GAAG,IAAI;IA0D7D,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,OAAO;IA0Bf;;;OAGG;IACH,OAAO,CAAC,SAAS;IAajB,0EAA0E;IAC1E,OAAO,CAAC,MAAM;CAaf;AAED,eAAO,MAAM,KAAK,aAAoB,CAAC"}

package/dist/types/audio/cleanTake.d.ts

@@ -0,0 +1,3 @@
+/** The cleaned mono samples, or null for a take that is silence. */
+export declare function cleanSamples(channels: Float32Array[], sampleRate: number): Float32Array | null;
+//# sourceMappingURL=cleanTake.d.ts.map

package/dist/types/audio/cleanTake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanTake.d.ts","sourceRoot":"","sources":["../../../src/audio/cleanTake.ts"],"names":[],"mappings":"AAoBA,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CA6B9F"}

package/dist/types/audio/music/ElementVoice.d.ts

@@ -0,0 +1,14 @@
+import { type MusicVoice } from './musicVoice.js';
+/** A track on the `<audio>` element's own volume, faded frame by frame: nothing between the file and the speaker. */
+export declare class ElementVoice implements MusicVoice {
+    readonly el: HTMLAudioElement;
+    private fading;
+    constructor(el: HTMLAudioElement);
+    level(): number;
+    set(level: number): void;
+    fade(to: number, ms: number, done?: () => void): void;
+    get busy(): boolean;
+    dispose(): void;
+    private stopFade;
+}
+//# sourceMappingURL=ElementVoice.d.ts.map

package/dist/types/audio/music/ElementVoice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementVoice.d.ts","sourceRoot":"","sources":["../../../../src/audio/music/ElementVoice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAExD,qHAAqH;AACrH,qBAAa,YAAa,YAAW,UAAU;IAGjC,QAAQ,CAAC,EAAE,EAAE,gBAAgB;IAFzC,OAAO,CAAC,MAAM,CAAuB;gBAEhB,EAAE,EAAE,gBAAgB;IAEzC,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKxB,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;IAgBrD,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/types/audio/music/GraphVoice.d.ts

@@ -0,0 +1,22 @@
+import { type MusicVoice } from './musicVoice.js';
+/**
+ * A track routed `<audio>` → MediaElementSource → gain → speakers, so its volume and crossfades work where the
+ * element's own `volume` is read-only (iOS). The fade is scheduled on the audio clock (a ramp), so it runs even while
+ * the page draws no frames. A cross-origin file without CORS headers plays silent this way: serve music from the
+ * game's own origin, or keep `ElementVoice` where volume works.
+ */
+export declare class GraphVoice implements MusicVoice {
+    readonly el: HTMLAudioElement;
+    private readonly graph;
+    private readonly gain;
+    private readonly source;
+    private timer;
+    constructor(el: HTMLAudioElement, graph: AudioContext);
+    level(): number;
+    set(level: number): void;
+    fade(to: number, ms: number, done?: () => void): void;
+    get busy(): boolean;
+    dispose(): void;
+    private stopFade;
+}
+//# sourceMappingURL=GraphVoice.d.ts.map

package/dist/types/audio/music/GraphVoice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphVoice.d.ts","sourceRoot":"","sources":["../../../../src/audio/music/GraphVoice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,UAAW,YAAW,UAAU;IAMzC,QAAQ,CAAC,EAAE,EAAE,gBAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IANxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,KAAK,CAA8C;gBAGhD,EAAE,EAAE,gBAAgB,EACZ,KAAK,EAAE,YAAY;IAQtC,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOxB,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;IAarD,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/types/audio/music/MusicChannel.d.ts

@@ -0,0 +1,35 @@
+import type { MusicVoice } from './musicVoice.js';
+export interface PlayOptions {
+    /** Crossfade from what this channel plays now, ms (default 1200). */
+    fadeMs?: number;
+    /** Start over at the end (default true). */
+    loop?: boolean;
+    /** This track's own level, 0–1, under the music volume (default 1). */
+    volume?: number;
+}
+/**
+ * One layer of music (the score, a place's ambience…): one looping track at a time, crossfaded when it changes, at
+ * its own level under the player's music volume.
+ */
+export declare class MusicChannel {
+    private readonly volume;
+    private readonly makeVoice;
+    private voice;
+    private url;
+    private level;
+    constructor(volume: () => number, makeVoice: (el: HTMLAudioElement) => MusicVoice);
+    /** The url of the track playing (or fading in), if any. */
+    get current(): string | null;
+    /** Plays `url`, crossfading from what plays now; the track already playing only takes the new `volume`. */
+    play(url: string, options?: PlayOptions): void;
+    /** Fades this channel out and stops it. */
+    stop(fadeMs?: number): void;
+    /** Retries a start the browser refused, and follows the music volume. */
+    refresh(): void;
+    /** Stops where it is (the app went to the background); `refresh` picks it up again. */
+    pause(): void;
+    dispose(): void;
+    private target;
+    private fadeOut;
+}
+//# sourceMappingURL=MusicChannel.d.ts.map

package/dist/types/audio/music/MusicChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MusicChannel.d.ts","sourceRoot":"","sources":["../../../../src/audio/music/MusicChannel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,qBAAa,YAAY;IAMrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,GAAG,CAAuB;IAClC,OAAO,CAAC,KAAK,CAAK;gBAGC,MAAM,EAAE,MAAM,MAAM,EACpB,SAAS,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,UAAU;IAGlE,2DAA2D;IAC3D,IAAI,OAAO,IAAI,MAAM,GAAG,IAAI,CAE3B;IAED,2GAA2G;IAC3G,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI;IA0BlD,2CAA2C;IAC3C,IAAI,CAAC,MAAM,SAAO,GAAG,IAAI;IAKzB,yEAAyE;IACzE,OAAO,IAAI,IAAI;IAOf,uFAAuF;IACvF,KAAK,IAAI,IAAI;IAIb,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,OAAO;CAKhB"}

package/dist/types/audio/music/musicVoice.d.ts

@@ -0,0 +1,26 @@
+/**
+ * One looping track playing on one channel of `MusicPlayer`, with a volume that can be set and faded. Two ways to get
+ * one: `ElementVoice` (the `<audio>` element's own volume) and `GraphVoice` (the element routed through a Web Audio
+ * gain, for where an `<audio>`'s `volume` is read-only: iOS).
+ */
+export interface MusicVoice {
+    readonly el: HTMLAudioElement;
+    /** The volume now (0..1). */
+    level(): number;
+    /** Sets it at once, cancelling a fade in flight. */
+    set(level: number): void;
+    /** Fades to `level` over `ms`; `done` runs at the end (not if a later fade or `set` takes over). */
+    fade(level: number, ms: number, done?: () => void): void;
+    /** A fade is in flight: the channel leaves the volume setting alone until it ends. */
+    readonly busy: boolean;
+    /** Stops the sound and lets the element go. */
+    dispose(): void;
+}
+/**
+ * True where an `<audio>` ignores `volume` (iOS WebKit), so music has to go through Web Audio to be faded at all.
+ * Newer iOS reads a set volume back while the speaker ignores it, so the probe alone misses it: an iPhone, iPod or an
+ * iPad posing as a Mac is named first.
+ */
+export declare function elementVolumeLocked(): boolean;
+export declare const clamp01: (n: number) => number;
+//# sourceMappingURL=musicVoice.d.ts.map

package/dist/types/audio/music/musicVoice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"musicVoice.d.ts","sourceRoot":"","sources":["../../../../src/audio/music/musicVoice.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;IAC9B,6BAA6B;IAC7B,KAAK,IAAI,MAAM,CAAC;IAChB,oDAAoD;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,oGAAoG;IACpG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACzD,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,+CAA+C;IAC/C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAO7C;AAED,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,MAAqC,CAAC"}

package/dist/types/audio/sampleBank.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The recorded takes of the sounds, registered by the game (`registerTakes`): `<sound>.mp3`, and `<sound>_2.mp3`…
+ * when a sound has more than one. A
+ * sound with takes plays one of them at random, never the same one twice running when it has more; a sound without
+ * any — or whose takes have not decoded yet — falls back to its synth recipe in `SoundEngine`.
+ *
+ * Every take is cleaned once on decode (`cleanTake.ts`: mono, silence trimmed, one loudness), off the main thread
+ * in `takeCleanerWorker.ts`, so `sounds.json`'s `fileGain` is the only mix knob. Measured on the first batch, peaks
+ * alone left their loudness 20 dB apart.
+ */
+/**
+ * Registers recorded takes by file path → url, e.g. a Vite `import.meta.glob('./sfx/*.mp3', { query: '?url',
+ * import: 'default', eager: true })`. `hit.mp3`, `hit_2.mp3`… are takes of `hit`; sound names carry no digits.
+ */
+export declare function registerTakes(urls: Record<string, string>): void;
+/** The sound has recorded takes in the build (decoded or not). */
+export declare const hasTakes: (name: string) => boolean;
+export declare class SampleBank {
+    private readonly decoded;
+    private readonly loading;
+    private readonly last;
+    names(): string[];
+    /** A decoded take, or null while none is ready (the caller then synthesises); starts loading on first ask. */
+    take(ctx: AudioContext, name: string): AudioBuffer | null;
+    load(ctx: AudioContext, name: string): void;
+}
+//# sourceMappingURL=sampleBank.d.ts.map

package/dist/types/audio/sampleBank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampleBank.d.ts","sourceRoot":"","sources":["../../../src/audio/sampleBank.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAKhE;AAED,kEAAkE;AAClE,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,OAAwB,CAAC;AAEjE,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAElD,KAAK,IAAI,MAAM,EAAE;IAIjB,8GAA8G;IAC9G,IAAI,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAYzD,IAAI,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAoB5C"}

package/dist/types/audio/soundTable.d.ts

@@ -0,0 +1,14 @@
+import type { SynthRecipe } from './synth.js';
+/**
+ * The sounds the engine can play: synthesised recipes by name, plus the master share every sound plays at. Empty
+ * until the game registers its own (`registerSounds`); the mapping from game happenings to sound names stays in
+ * the game.
+ */
+export interface SoundTable {
+    /** Share of the effects volume everything plays at: keeps full volume modest next to the music. */
+    master: number;
+    recipes: Record<string, SynthRecipe>;
+}
+export declare const SOUNDS: SoundTable;
+export declare function registerSounds(table: Partial<SoundTable>): void;
+//# sourceMappingURL=soundTable.d.ts.map

package/dist/types/audio/soundTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soundTable.d.ts","sourceRoot":"","sources":["../../../src/audio/soundTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,mGAAmG;IACnG,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACtC;AAED,eAAO,MAAM,MAAM,EAAE,UAAuC,CAAC;AAE7D,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAG/D"}

package/dist/types/audio/synth.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The combat sounds are written, not recorded: a few oscillator or noise layers rendered straight into a buffer
+ * (`sounds.json` → `recipes`). Lo-fi on purpose — 22 kHz mono, short and soft — so they sit with the pixel art
+ * instead of pretending to be a recording.
+ */
+export declare const SYNTH_RATE = 22050;
+export interface SynthLayer {
+    /** Waveform; `noise` is white noise, or sample-and-hold noise at `f` Hz when `f` is given (crunchier). */
+    w: 'sine' | 'square' | 'tri' | 'saw' | 'noise';
+    /** Pitch at the start and at the end of the layer (Hz), swept exponentially. */
+    f?: [number, number];
+    /** Length (s). */
+    t: number;
+    /** Delay before the layer starts (s). */
+    d?: number;
+    /** Attack (s). */
+    at?: number;
+    g: number;
+    /** Decay curve exponent: 1 is linear, higher falls away faster. */
+    c?: number;
+    duty?: number;
+    /** Low- and high-pass cutoff at the start and the end (Hz). */
+    lp?: [number, number];
+    hp?: [number, number];
+}
+export interface SynthRecipe {
+    layers: SynthLayer[];
+    /** Random pitch spread per play (share of 1); the engine's default when absent. */
+    jitter?: number;
+    /** Level of the sound's recorded takes (`registerTakes`), which are normalised on decode; default 1. */
+    fileGain?: number;
+}
+export declare function renderRecipe(recipe: SynthRecipe): Float32Array;
+//# sourceMappingURL=synth.d.ts.map

package/dist/types/audio/synth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth.d.ts","sourceRoot":"","sources":["../../../src/audio/synth.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,UAAU,QAAQ,CAAC;AAEhC,MAAM,WAAW,UAAU;IACzB,0GAA0G;IAC1G,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAAC;IAC/C,gFAAgF;IAChF,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrB,kBAAkB;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,yCAAyC;IACzC,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,kBAAkB;IAClB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,mEAAmE;IACnE,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtB,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wGAAwG;IACxG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAgBD,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CA8C9D"}

package/dist/types/audio/takeCleanerWorker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=takeCleanerWorker.d.ts.map

package/dist/types/audio/takeCleanerWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeCleanerWorker.d.ts","sourceRoot":"","sources":["../../../src/audio/takeCleanerWorker.ts"],"names":[],"mappings":""}

package/dist/types/core/BitmapLabel.d.ts

@@ -0,0 +1,36 @@
+import { BitmapText } from 'pixi.js';
+/**
+ * Adds letters every label font made **after this call** bakes ahead — the accented letters of a language the labels
+ * print (German's `'äöüß'`, say), an arrow, a star. A font already installed keeps the glyphs it was made with, so
+ * call it once at start-up, before the first label or `FloatingText.warm`.
+ *
+ * Without it, a label font holds ASCII only: a letter outside it is still drawn (Pixi bakes it when first printed),
+ * but on that frame, onto a new glyph page — the stall and the canvas memory this module exists to avoid. For one
+ * font's own extra letters, pass them to `installLabelFont` (or `Label.bitmap`, `FloatingText`'s `glyphs`) instead.
+ */
+export declare function addLabelGlyphs(letters: string): void;
+/**
+ * Rasterises one label font once and returns its name. Called ahead of time for the damage numbers: baking a font on
+ * its first number froze the first frame that printed one by ~60 ms. `glyphs` are letters this font bakes besides
+ * ASCII and `addLabelGlyphs`' (a font with its own is a font of its own: pass the same `glyphs` wherever it is used).
+ */
+export declare function installLabelFont(fontFamily: string, size: number, color: string, stroke: string, strokeWidth: number, resolution: number, glyphs?: string): string;
+declare const BitmapLabel_base: typeof BitmapText & (new (...args: any[]) => import("./gameObject.js").GameObjectMembers);
+/**
+ * Text drawn from a bitmap font: the glyphs are rasterised once per font, so changing the string costs no canvas
+ * redraw and no texture upload, and every label of one font batches with the others. For the floating numbers, which
+ * a crowded fight throws dozens of a second — a plain `Text` repaints its canvas at resolution 4 and uploads it on
+ * every change.
+ */
+export declare class BitmapLabel extends BitmapLabel_base {
+    /**
+     * `fontFamily` must already be loaded (`document.fonts.load`), or the glyphs bake in the fallback.
+     * Styled like `worldText`: the same font, size, colour and outline, rasterised at the same resolution. `glyphs`:
+     * letters beyond ASCII it prints (see `installLabelFont`).
+     */
+    constructor(x: number, y: number, text: string, fontFamily: string, size: number, color: string, stroke: string, strokeWidth: number, resolution: number, glyphs?: string);
+    setOrigin(x?: number, y?: number): this;
+    setText(text: string): this;
+}
+export {};
+//# sourceMappingURL=BitmapLabel.d.ts.map

package/dist/types/core/BitmapLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitmapLabel.d.ts","sourceRoot":"","sources":["../../../src/core/BitmapLabel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,UAAU,EAAqB,MAAM,SAAS,CAAC;AAYpE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEpD;AAQD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,SAAK,GAAG,MAAM,CAoB9J;;AAED;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,gBAAsB;IACrD;;;;OAIG;gBACS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,SAAK;IAMrK,SAAS,CAAC,CAAC,SAAM,EAAE,CAAC,SAAI,GAAG,IAAI;IAK/B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAI5B"}

package/dist/types/core/Camera.d.ts

@@ -0,0 +1,115 @@
+import type { Container } from 'pixi.js';
+export interface TrackOptions {
+    /**
+     * How much of the way to the target the camera closes each 60th of a second (0–1, default 1: locked on). 0.1 is a
+     * soft follow; the rate is the same at any frame rate.
+     */
+    lerp?: number;
+    /** A box round the screen's centre (world px) the target may move in without the camera moving. */
+    deadzoneWidth?: number;
+    deadzoneHeight?: number;
+    /** Where on the target to look (world px from its position), e.g. a little above a body's feet. */
+    offsetX?: number;
+    offsetY?: number;
+}
+export interface ViewRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Moves and zooms the world layer. `scrollX/scrollY` is the world point at the top-left of the screen, so
+ * `round(scroll * zoom) / zoom` snaps the view to whole screen pixels.
+ */
+export declare class Camera {
+    private readonly world;
+    private readonly screen;
+    zoom: number;
+    /** The zoom `reset` goes back to: the engine sets it from its `zoom` option (default 1). */
+    defaultZoom: number;
+    /** Backing pixels per screen pixel (the renderer's resolution, `zoomResolution`): what `snap` rounds to. */
+    resolution: number;
+    /** Lands the view on whole backing pixels (pixel art); off, the world moves smoothly between them. */
+    roundPixels: boolean;
+    scrollX: number;
+    scrollY: number;
+    width: number;
+    height: number;
+    private bounds;
+    private shakeUntil;
+    private shakeMs;
+    private shakeAngle;
+    private shakeIntensity;
+    private flashRect;
+    private flashStart;
+    private flashMs;
+    private flashPeak;
+    /** Screen-layer containers laid over the world with its exact transform, shake included (see `follow`). */
+    private readonly followers;
+    private target;
+    private trackOpts;
+    private lastApply;
+    constructor(world: Container, screen: Container);
+    get worldView(): ViewRect;
+    setZoom(z: number): this;
+    /** A world coordinate snapped to the nearest backing pixel: one screen pixel, or a half at ×1.5. */
+    snap(v: number): number;
+    setBounds(x: number, y: number, width: number, height: number): this;
+    /** Lets the view go anywhere again. */
+    clearBounds(): this;
+    /**
+     * Back to how the engine made it: no target, no bounds, `defaultZoom`, scrolled to 0, no shake or flash. The camera
+     * is the engine's, shared by every scene, so a level's target and bounds would otherwise hold over the next scene
+     * (a title screen kept following a hero that no longer existed). `SceneManager.replace` calls it between the old
+     * scenes leaving and the new one entering; `push` and `pop` leave the camera alone, since the scene under a pause
+     * menu still wants its view when it comes back. Layers added with `follow` are kept: they belong to tools that
+     * outlive scenes (a debug overlay), not to a scene.
+     */
+    reset(): this;
+    /** The tracked target, if any. */
+    get tracking(): {
+        readonly x: number;
+        readonly y: number;
+    } | null;
+    /** The bounds the view is kept inside, if any. */
+    get boundsRect(): {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    } | null;
+    centerOn(x: number, y: number): this;
+    setScroll(x: number, y: number): this;
+    /**
+     * Screen shake: `intensity` is a fraction of the screen size, like before. With an `angle` (the way a blow travelled)
+     * the shake runs back and forth along it instead of at random, so a hit is felt coming from somewhere.
+     */
+    shake(ms: number, intensity: number, angle?: number): void;
+    /**
+     * Keeps a container on the screen layer placed exactly over the world layer — zoom, scroll and this frame's
+     * shake — for things drawn in world units above the screen-layer night (fireflies). Written in `apply`, after
+     * the scene updated, so it never lags the world by a frame or misses a shake the world takes.
+     */
+    follow(layer: Container): void;
+    unfollow(layer: Container): void;
+    /** Full-screen colour flash starting at `peak` alpha and fading out over `ms`. */
+    flash(ms: number, r: number, g: number, b: number, _force?: boolean, peak?: number): void;
+    /**
+     * Keeps `target` (anything with `x` and `y`, read every frame: an entity's position, a sprite) in view, inside the
+     * bounds if there are any. Replaces any target before.
+     */
+    track(target: {
+        readonly x: number;
+        readonly y: number;
+    }, options?: TrackOptions): this;
+    untrack(): this;
+    /** Moves the view toward the tracked target for a frame `dtMs` long. */
+    private follow1;
+    /** Writes the camera into the world layer; called once per frame after the scene updated. */
+    apply(now: number): void;
+    private clamp;
+}
+//# sourceMappingURL=Camera.d.ts.map

package/dist/types/core/Camera.d.ts.map

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

package/dist/types/core/Clock.d.ts

@@ -0,0 +1,11 @@
+/** Scene time and one-shot timers, advanced by the frame loop. */
+export declare class Clock {
+    now: number;
+    private timers;
+    delayedCall(ms: number, fn: () => void): {
+        remove: () => void;
+    };
+    update(now: number): void;
+    clear(): void;
+}
+//# sourceMappingURL=Clock.d.ts.map

package/dist/types/core/Clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Clock.d.ts","sourceRoot":"","sources":["../../../src/core/Clock.ts"],"names":[],"mappings":"AAMA,kEAAkE;AAClE,qBAAa,KAAK;IAChB,GAAG,SAAqB;IACxB,OAAO,CAAC,MAAM,CAAe;IAE7B,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG;QAAE,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE;IAM/D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAezB,KAAK,IAAI,IAAI;CAGd"}