lantern-engine 0.0.0-stage → 0.4.0

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

@@ -0,0 +1,22 @@
+import { Text as PixiText } from 'pixi.js';
+export interface TextStyle {
+    fontFamily?: string;
+    fontSize: string | number;
+    color?: string;
+    stroke?: string;
+    strokeThickness?: number;
+    /** Texture pixels per world pixel: world text is zoomed by the camera, so it is rasterised finer. */
+    resolution?: number;
+    align?: 'left' | 'center' | 'right';
+    lineSpacing?: number;
+    wordWrapWidth?: number;
+}
+declare const Text_base: typeof PixiText & (new (...args: any[]) => import("./gameObject.js").GameObjectMembers);
+/** Canvas text in world or screen space. */
+export declare class Text extends Text_base {
+    constructor(x: number, y: number, text: string, style: TextStyle);
+    setOrigin(x?: number, y?: number): this;
+    setText(text: string): this;
+}
+export {};
+//# sourceMappingURL=Text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../src/core/Text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAyB,MAAM,SAAS,CAAC;AAGlE,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qGAAqG;IACrG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;;AAED,4CAA4C;AAC5C,qBAAa,IAAK,SAAQ,SAAoB;gBAChC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS;IAkBhE,SAAS,CAAC,CAAC,SAAM,EAAE,CAAC,SAAI,GAAG,IAAI;IAK/B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAI5B"}

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

@@ -0,0 +1,51 @@
+import { CanvasSource, Texture } from 'pixi.js';
+/** A canvas-backed texture with named frames; repaint the canvas, then `refresh()` to upload it. */
+export declare class CanvasTexture {
+    readonly key: string;
+    readonly canvas: HTMLCanvasElement;
+    readonly frames: Map<string, Texture<import("pixi.js").TextureSource<any>>>;
+    readonly source: CanvasSource;
+    readonly whole: Texture;
+    constructor(key: string, canvas: HTMLCanvasElement);
+    get width(): number;
+    get height(): number;
+    get context(): CanvasRenderingContext2D;
+    /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */
+    add(name: string, _source: number, x: number, y: number, w: number, h: number): void;
+    /**
+     * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is
+     * found by this texture's key. A texture of its own over the other page's source: each side frees its own.
+     */
+    adopt(name: string, from: CanvasTexture): void;
+    refresh(): void;
+    destroy(): void;
+}
+/** Every texture of the world by key: the sprite atlas and per-player repainted sheets. */
+export declare class TextureRegistry {
+    private readonly textures;
+    /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */
+    private readonly live;
+    private missing;
+    private snapshots;
+    markLive(key: string): void;
+    isLive(key: string): boolean;
+    /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */
+    snapshot(key: string, frame?: string | number): string;
+    /**
+     * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only
+     * made anew when the frame's size changes. Frame '0' is the copy.
+     */
+    snapshotInto(key: string, frame: string | number | undefined, into: string): void;
+    exists(key: string): boolean;
+    addCanvas(key: string, canvas: HTMLCanvasElement): CanvasTexture;
+    /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */
+    addSpriteSheet(key: string, canvas: HTMLCanvasElement, size: {
+        frameWidth: number;
+        frameHeight: number;
+    }): CanvasTexture;
+    createCanvas(key: string, width: number, height: number): CanvasTexture;
+    remove(key: string): void;
+    get(key: string, frame?: string | number): Texture;
+    private warn;
+}
+//# sourceMappingURL=TextureRegistry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextureRegistry.d.ts","sourceRoot":"","sources":["../../../src/core/TextureRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAa,OAAO,EAAE,MAAM,SAAS,CAAC;AAE3D,oGAAoG;AACpG,qBAAa,aAAa;IAMtB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,MAAM,EAAE,iBAAiB;IANpC,QAAQ,CAAC,MAAM,6DAA8B;IAC7C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;gBAGb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,iBAAiB;IAMpC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,OAAO,IAAI,wBAAwB,CAEtC;IAED,gFAAgF;IAChF,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAKpF;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI;IAO9C,OAAO,IAAI,IAAI;IAIf,OAAO,IAAI,IAAI;CAMhB;AAED,2FAA2F;AAC3F,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,6GAA6G;IAC7G,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,SAAS,CAAK;IAEtB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI3B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,iHAAiH;IACjH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAatD;;;OAGG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAkBjF,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,aAAa;IAOhE,sFAAsF;IACtF,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,aAAa;IAUxH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa;IAOvE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAOlD,OAAO,CAAC,IAAI;CAOb"}

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

@@ -0,0 +1,53 @@
+export type TweenTarget = Record<string, unknown> & {
+    destroyed?: boolean;
+};
+/** Tween config in the shape the renderer has always used: numeric props at the top level or under `props`. */
+export interface TweenConfig {
+    targets: object | object[];
+    duration?: number;
+    delay?: number;
+    /** Ms to stay at the end values before a yoyo plays back. */
+    hold?: number;
+    yoyo?: boolean;
+    /** Extra plays after the first (-1 = forever). */
+    repeat?: number;
+    ease?: string;
+    props?: Record<string, number>;
+    onStart?: () => void;
+    onUpdate?: () => void;
+    onComplete?: () => void;
+    [prop: string]: unknown;
+}
+/** One running tween; `remove()` stops it without calling onComplete. */
+export declare class Tween {
+    private readonly cfg;
+    private readonly ends;
+    private tracks;
+    private elapsed;
+    private plays;
+    removed: boolean;
+    readonly targets: TweenTarget[];
+    constructor(cfg: TweenConfig, ends: Record<string, number>);
+    /**
+     * Every target is a destroyed display object: nothing is left to move. A forever tween (`repeat: -1`) on a sprite
+     * its owner freed used to stay in the list for good, holding the sprite, and the list grew with every map loaded.
+     * A plain object (a clock a callback reads) has no `destroyed` and is never taken for one. Only a forever tween is
+     * dropped this way: a finite one still runs out and calls its `onComplete`, which may clean up more than the sprite.
+     */
+    private orphaned;
+    remove(): void;
+    stop(): void;
+    /** Advances by `dt` ms; returns false once the tween is finished. */
+    step(dt: number): boolean;
+}
+/** Frame-driven tween manager (the renderer's replacement for Phaser's TweenManager). */
+export declare class Tweener {
+    /** Global speed factor; hit-stop slows every tween at once. */
+    timeScale: number;
+    private tweens;
+    add(cfg: TweenConfig): Tween;
+    killTweensOf(target: object | object[]): void;
+    update(dt: number): void;
+    clear(): void;
+}
+//# sourceMappingURL=Tweener.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tweener.d.ts","sourceRoot":"","sources":["../../../src/core/Tweener.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5E,+GAA+G;AAC/G,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAaD,yEAAyE;AACzE,qBAAa,KAAK;IAQd,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IARvB,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,UAAS;IAChB,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;gBAGb,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAM/C;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAQhB,MAAM,IAAI,IAAI;IAId,IAAI,IAAI,IAAI;IAIZ,qEAAqE;IACrE,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;CA+C1B;AAcD,yFAAyF;AACzF,qBAAa,OAAO;IAClB,+DAA+D;IAC/D,SAAS,SAAK;IACd,OAAO,CAAC,MAAM,CAAe;IAE7B,GAAG,CAAC,GAAG,EAAE,WAAW,GAAG,KAAK;IAoB5B,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAK7C,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAiBxB,KAAK,IAAI,IAAI;CAId"}

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

@@ -0,0 +1,16 @@
+import type { TextureRegistry } from './TextureRegistry.js';
+/**
+ * Packs many small procedurally painted canvases into as few textures as the GPU allows, so Pixi can batch every
+ * sprite of the world into very few draw calls. One page on every desktop (up to 8192 square); a device whose GPU
+ * takes less gets pages of `limit` (`atlasPageLimit`, `planAtlas`). Every frame is registered under the one `key`
+ * whichever page holds it — the pages after the first are textures of their own (`key~1`, `key~2`…) whose frames
+ * the first page's texture adopts — so the world keeps asking for `atlas` and a frame name, and never knows.
+ * Frame names: `name` for single images, `name#i` for sheet frames.
+ */
+export declare class AtlasBuilder {
+    private items;
+    add(name: string, canvas: HTMLCanvasElement): void;
+    addSheet(name: string, canvas: HTMLCanvasElement, frameWidth: number, frameHeight: number): void;
+    build(textures: TextureRegistry, key: string, limit?: number): void;
+}
+//# sourceMappingURL=atlas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/core/atlas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAUzD;;;;;;;GAOG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAmB;IAEhC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAIlD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAIhG,KAAK,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,SAAkB,GAAG,IAAI;CAuC7E"}

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

@@ -0,0 +1,34 @@
+export declare const ATLAS_PAD = 2;
+/** The page side every desktop GPU takes, and the one the atlas was built to before pages existed. */
+export declare const ATLAS_PAGE_FULL = 8192;
+/**
+ * How big an atlas page may be on this device: 8192 wherever the GPU takes it (every desktop — unchanged), else
+ * split at 4096, or at the largest power of two the GPU does take if that is smaller still. Unknown: 8192, as before.
+ */
+export declare function atlasPageLimit(maxTextureSize: number | null): number;
+export interface AtlasSize {
+    w: number;
+    h: number;
+}
+export interface AtlasPage {
+    width: number;
+    height: number;
+}
+export interface AtlasPlan {
+    pages: AtlasPage[];
+    /** One per input, in input order: the page and the top-left corner. */
+    places: {
+        page: number;
+        x: number;
+        y: number;
+    }[];
+}
+/**
+ * Shelf-packs the images, tallest first, into pages no larger than `limit` on either side. The page width is the
+ * power of two that fits the widest image and the square root of the total area (at least 1024), capped at `limit`;
+ * a shelf that would run past `limit` starts a new page. With everything fitting under `limit` this is exactly the
+ * single page the atlas always was. An image larger than `limit` itself is given a page of its own (the GPU will
+ * refuse it, but nothing else is lost with it).
+ */
+export declare function planAtlas(sizes: readonly AtlasSize[], limit: number): AtlasPlan;
+//# sourceMappingURL=atlasPlan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atlasPlan.d.ts","sourceRoot":"","sources":["../../../src/core/atlasPlan.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,sGAAsG;AACtG,eAAO,MAAM,eAAe,OAAO,CAAC;AAIpC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGpE;AAED,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,uEAAuE;IACvE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAqC/E"}

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

@@ -0,0 +1,3 @@
+export type EaseFn = (t: number) => number;
+export declare function easeByName(name: string | undefined): EaseFn;
+//# sourceMappingURL=eases.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eases.d.ts","sourceRoot":"","sources":["../../../src/core/eases.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAmB3C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAK3D"}

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

@@ -0,0 +1,42 @@
+import { type BLEND_MODES, type Container } from 'pixi.js';
+import type { Stage } from './Stage.js';
+type Ctor<T> = new (...args: any[]) => T;
+/** What `GameObject` adds to a Pixi display object. */
+export interface GameObjectMembers {
+    scene: Stage;
+    /** False once destroyed. */
+    readonly active: boolean;
+    /** The draw order in the world layer (`zIndex`): bigger is in front. */
+    depth: number;
+    /** Scale without the flip: stays positive on a mirrored sprite. */
+    scaleX: number;
+    scaleY: number;
+    flipX: boolean;
+    flipY: boolean;
+    setScale(x: number, y?: number): this;
+    setFlipX(v: boolean): this;
+    setFlipY(v: boolean): this;
+    setFlip(x: boolean, y: boolean): this;
+    setDepth(d: number): this;
+    setAlpha(a?: number): this;
+    setVisible(v: boolean): this;
+    setPosition(x?: number, y?: number): this;
+    setRotation(r?: number): this;
+    setAngle(a?: number): this;
+    setBlendMode(mode: BLEND_MODES): this;
+    setTint(color?: number): this;
+    /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */
+    setTintFill(color: number): this;
+    clearTint(): this;
+    /** 0 pins the object to the screen instead of the world. */
+    setScrollFactor(f: number): this;
+    destroy(): void;
+}
+/**
+ * The chainable setters the world code was written against (setDepth, setAlpha, setTintFill...), added onto a Pixi
+ * display object. Scale is kept apart from flipping, so `scaleX` stays positive on a mirrored sprite as it did
+ * before, and a tween on scale cannot undo a flip.
+ */
+export declare function GameObject<TBase extends Ctor<Container>>(Base: TBase): TBase & Ctor<GameObjectMembers>;
+export {};
+//# sourceMappingURL=gameObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gameObject.d.ts","sourceRoot":"","sources":["../../../src/core/gameObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,KAAK,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAsBzC,uDAAuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,CAAC;IACb,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACtC,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,8EAA8E;IAC9E,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,SAAS,IAAI,IAAI,CAAC;IAClB,4DAA4D;IAC5D,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAuKtG"}

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

@@ -0,0 +1,9 @@
+/**
+ * Pixi 8's `BatchTextureArray.clear` sets `ids[source.uid] = null` instead of deleting the key, and its batches are
+ * pooled, so every pooled batch keeps one key for every texture source ever drawn through it — about 70% of what a
+ * fight's heap grew by in an hour (Pixi 8.21.0). The replacement deletes the key, which reads the
+ * same to Pixi (`checkAndUpdateTexture` treats null and a missing key alike). Applied once, and only while `clear`
+ * still has the shape it was written against, so a Pixi that fixed or changed it is left alone.
+ */
+export declare function patchPixi(): boolean;
+//# sourceMappingURL=pixiPatches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pixiPatches.d.ts","sourceRoot":"","sources":["../../../src/core/pixiPatches.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAkBnC"}

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

@@ -0,0 +1,4 @@
+import type { Container } from 'pixi.js';
+/** Anything that can be placed in the world: images, graphics, groups, text. */
+export type WorldObject = Container;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,SAAS,CAAC"}

package/dist/types/ecs/SparseSet.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One component type's storage: a sparse set. `sparse[index]` is where the entity's value sits in the dense arrays
+ * (or -1), and `entities`/`values` are packed with no holes, so walking a component is a walk over two flat arrays
+ * and finding one is two array reads. Removing swaps the last entry into the hole.
+ *
+ * Indexed by the entity's slot index (`entityIndex`), not the whole id: the generation is checked by the world.
+ */
+export declare class SparseSet<T> {
+    private sparse;
+    /** Packed entity ids, in the same order as `values`. */
+    readonly entities: number[];
+    readonly values: T[];
+    /** Bumped whenever an entity joins or leaves the set (not when a value changes): query caches key on it. */
+    version: number;
+    get size(): number;
+    has(index: number): boolean;
+    /** The value at slot `index`, or undefined. */
+    get(index: number): T | undefined;
+    set(index: number, entity: number, value: T): void;
+    /** Removes slot `index`; true if it was there. */
+    delete(index: number, indexOf: (entity: number) => number): boolean;
+    clear(): void;
+    private grow;
+}
+//# sourceMappingURL=SparseSet.d.ts.map

package/dist/types/ecs/SparseSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparseSet.d.ts","sourceRoot":"","sources":["../../../src/ecs/SparseSet.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,MAAM,CAA2C;IACzD,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAM;IACjC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,CAAM;IAC1B,4GAA4G;IAC5G,OAAO,SAAK;IAEZ,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI3B,+CAA+C;IAC/C,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAMjC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAclD,kDAAkD;IAClD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO;IAkBnE,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,IAAI;CAQb"}

package/dist/types/ecs/World.d.ts

@@ -0,0 +1,133 @@
+import { type Columns, type FieldSpec, type FieldValues, type FieldsType } from './fields.js';
+/**
+ * An entity–component–system store. Entities are numbers; components are data kept in one sparse set per component
+ * type; systems are functions run in the order they were added, each in a phase:
+ *
+ * - `fixed` runs once per simulation step (`FixedLoop`), for movement and rules;
+ * - `frame` runs once per rendered frame, for drawing and anything purely visual.
+ *
+ * Storage is a sparse set per component (packed arrays, O(1) lookups), the layout fast ECS libraries use. For hot
+ * loops prefer `each` (a callback, no allocation per entity) over `query` (an iterator yielding a fresh row).
+ *
+ * Entity ids are recycled: an id carries its slot index and a generation, so an id kept after its entity was
+ * destroyed never matches the entity that later reuses the slot.
+ *
+ * Changing structure while walking: adding components is always safe (new entries are not visited this walk).
+ * Removing a component or destroying an entity while a `query`, an `each` or a system run is in progress is deferred
+ * until it ends, so nothing is skipped or visited twice.
+ */
+export type Entity = number;
+/** A component type: a typed key. Make one per kind of data with `defineComponent`. */
+export interface ComponentType<T> {
+    readonly id: number;
+    readonly name: string;
+    /** Phantom field carrying `T`; never set. */
+    readonly __type?: T;
+}
+export declare function defineComponent<T>(name: string): ComponentType<T>;
+/** A component of numeric fields kept in typed-array columns (`fields.ts`): the fast form for data every body has. */
+export declare function defineFields<const S extends FieldSpec>(name: string, fields: S): FieldsType<S>;
+export type SystemPhase = 'fixed' | 'frame';
+export interface SystemContext {
+    world: World;
+    /** Seconds this run covers: one step in `fixed`, the frame's length in `frame`. */
+    dt: number;
+    /** `performance.now()` of the frame. */
+    now: number;
+    /** In `frame`: the share of a step since the last fixed step (0–1), for interpolation. 0 in `fixed`. */
+    alpha: number;
+}
+export interface System {
+    readonly name: string;
+    readonly phase: SystemPhase;
+    run(ctx: SystemContext): void;
+    /** Called when the system is taken out of its world (or the world is cleared). */
+    dispose?(): void;
+}
+/** A system from a function. */
+export declare function system(name: string, phase: SystemPhase, run: (ctx: SystemContext) => void): System;
+export type ComponentValues<T extends readonly ComponentType<unknown>[]> = {
+    [K in keyof T]: T[K] extends ComponentType<infer V> ? V : never;
+};
+/** The slot an entity id sits in. */
+export declare const entityIndex: (e: Entity) => number;
+export declare class World {
+    /** Current generation per slot; an id is alive when its generation matches and the slot is in use. */
+    private generations;
+    private readonly inUse;
+    private readonly free;
+    private live;
+    private readonly stores;
+    /** Typed-array columns of the field components, by component id. */
+    private readonly cols;
+    private readonly systems;
+    private readonly pending;
+    /** `slots` results by the component ids asked for, rebuilt only when one of those sets changed membership. */
+    private readonly slotCache;
+    /** Walks (`query`, `each`, system runs) in progress: structure changes wait until it is 0. */
+    private walking;
+    /** A new entity with no components. */
+    create(): Entity;
+    /** A new entity with these components. */
+    spawn(...components: [ComponentType<unknown>, unknown][]): Entity;
+    isAlive(e: Entity): boolean;
+    /** Live entities. */
+    get size(): number;
+    /** Removes an entity and every component it had (deferred while a walk is in progress). */
+    destroy(e: Entity): void;
+    /** Gives an entity a field component; fields left out start at 0. Returns the slot index into its columns. */
+    add<S extends FieldSpec>(e: Entity, type: FieldsType<S>, values?: FieldValues<S>): number;
+    add<T>(e: Entity, type: ComponentType<T>, value: T): T;
+    /**
+     * The typed-array columns of a field component, indexed by slot. Fetch them per system run: adding entities may
+     * grow them into new arrays.
+     */
+    columns<S extends FieldSpec>(type: FieldsType<S>): Columns<S>;
+    get<T>(e: Entity, type: ComponentType<T>): T | undefined;
+    /** The component, or an error naming what is missing: for code that knows the entity has it. */
+    require<T>(e: Entity, type: ComponentType<T>): T;
+    has(e: Entity, type: ComponentType<unknown>): boolean;
+    /** Takes one component off an entity (deferred while a walk is in progress). */
+    remove(e: Entity, type: ComponentType<unknown>): void;
+    /** How many entities hold `type`. */
+    count(type: ComponentType<unknown>): number;
+    /**
+     * Calls `fn(entity, ...components)` for every live entity holding all of `types`. Allocates nothing per entity:
+     * the form for systems that walk thousands of bodies every step.
+     */
+    each<const T extends readonly ComponentType<unknown>[]>(...args: [...types: T, fn: (e: Entity, ...values: ComponentValues<T>) => void]): void;
+    /**
+     * The slot index of every entity holding all of `types`, as a typed array: the fastest walk there is, made for
+     * field components (`defineFields`), whose columns are indexed by slot.
+     *
+     * ```ts
+     * const p = world.columns(Position), v = world.columns(Velocity);
+     * const slots = world.slots(Position, Velocity);
+     * for (let k = 0; k < slots.length; k++) { const i = slots[k]!; p.x[i]! += v.x[i]! * dt; }
+     * ```
+     *
+     * The result is cached and rebuilt only when an entity joins or leaves one of those components, so asking every
+     * step is cheap. It is a view the world owns: read it, don't keep it past the step, and fetch it again after
+     * adding or removing components.
+     */
+    slots(...types: ComponentType<unknown>[]): Int32Array;
+    /**
+     * Every live entity holding all of `types`, with those components in the same order. Yields a fresh row per
+     * entity: convenient, but `each` is the form for hot loops.
+     */
+    query<const T extends readonly ComponentType<unknown>[]>(...types: T): IterableIterator<[Entity, ...ComponentValues<T>]>;
+    /** The first entity matching the query, or undefined: for singletons (the player, the camera target). */
+    first<const T extends readonly ComponentType<unknown>[]>(...types: T): [Entity, ...ComponentValues<T>] | undefined;
+    addSystem(s: System): this;
+    removeSystem(name: string): void;
+    /** Runs every system of `phase` in the order added. A system that throws is reported and the rest still run. */
+    run(phase: SystemPhase, ctx: Omit<SystemContext, 'world'>, onError?: (system: System, err: unknown) => void): void;
+    /** Every entity, component and system gone. */
+    clear(): void;
+    private columnsOf;
+    private store;
+    /** The stores for `types`, or null when one has never been used (so nothing can match). */
+    private setsFor;
+    private endWalk;
+}
+//# sourceMappingURL=World.d.ts.map

package/dist/types/ecs/World.d.ts.map

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

package/dist/types/ecs/fields.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentType } from './World.js';
+/**
+ * Numeric components stored as columns of typed arrays instead of one object per entity: `Position.x` and
+ * `Position.y` are two `Float32Array`s indexed by the entity's slot. A system walking thousands of bodies then reads
+ * memory in order and makes no garbage, which is several times faster than objects at scale (see `bench/`).
+ *
+ * ```ts
+ * const Position = defineFields('Position', { x: 'f32', y: 'f32' });
+ * world.add(e, Position, { x: 10, y: 20 });
+ * const p = world.columns(Position); // fetch per run: columns grow (and are replaced) as entities are added
+ * world.each(Position, (e, i) => { p.x[i] += 1; });
+ * ```
+ *
+ * In `each`/`query` a field component's value is the entity's slot index `i`, the index into every column.
+ */
+export type FieldKind = 'f32' | 'f64' | 'i8' | 'i16' | 'i32' | 'u8' | 'u16' | 'u32';
+export type FieldSpec = Record<string, FieldKind>;
+export type ArrayOf<K extends FieldKind> = K extends 'f32' ? Float32Array : K extends 'f64' ? Float64Array : K extends 'i8' ? Int8Array : K extends 'i16' ? Int16Array : K extends 'i32' ? Int32Array : K extends 'u8' ? Uint8Array : K extends 'u16' ? Uint16Array : Uint32Array;
+/** One typed array per field, indexed by slot. */
+export type Columns<S extends FieldSpec> = {
+    [K in keyof S]: ArrayOf<S[K]>;
+};
+/** What `add` takes for a field component: any subset of its fields (the rest start at 0). */
+export type FieldValues<S extends FieldSpec> = {
+    [K in keyof S]?: number;
+};
+/** A component of numeric fields. Its value in `each`/`query` is the slot index. */
+export interface FieldsType<S extends FieldSpec> extends ComponentType<number> {
+    readonly fields: S;
+}
+export declare function isFields(type: ComponentType<unknown>): type is FieldsType<FieldSpec>;
+/** Fresh columns of at least `n` slots, keeping what `old` held. */
+export declare function growColumns(spec: FieldSpec, n: number, old?: Record<string, ArrayLike<number>>): Record<string, ArrayLike<number>>;
+//# sourceMappingURL=fields.d.ts.map

package/dist/types/ecs/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../src/ecs/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAElD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,SAAS,KAAK,GACtD,YAAY,GACZ,CAAC,SAAS,KAAK,GACb,YAAY,GACZ,CAAC,SAAS,IAAI,GACZ,SAAS,GACT,CAAC,SAAS,KAAK,GACb,UAAU,GACV,CAAC,SAAS,KAAK,GACb,UAAU,GACV,CAAC,SAAS,IAAI,GACZ,UAAU,GACV,CAAC,SAAS,KAAK,GACb,WAAW,GACX,WAAW,CAAC;AAE5B,kDAAkD;AAClD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE7E,8FAA8F;AAC9F,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM;CAAE,CAAC;AAE3E,oFAAoF;AACpF,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,SAAS,CAAE,SAAQ,aAAa,CAAC,MAAM,CAAC;IAC5E,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;CACpB;AAaD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,IAAI,IAAI,UAAU,CAAC,SAAS,CAAC,CAEpF;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CASlI"}

package/dist/types/engine/Engine.d.ts

@@ -0,0 +1,80 @@
+import { Application } from 'pixi.js';
+import { Stage } from '../core/Stage.js';
+import { TextureRegistry } from '../core/TextureRegistry.js';
+import { EventBus } from '../events/EventBus.js';
+import { FixedLoop } from './FixedLoop.js';
+import { SceneManager } from './SceneManager.js';
+import type { Scene } from './Scene.js';
+export interface EngineOptions {
+    /** Where the canvas goes. */
+    parent: HTMLElement;
+    /** A fixed canvas size in CSS pixels. Leave both out to fill `parent` and follow its size. */
+    width?: number;
+    height?: number;
+    /** CSS colour behind the world (default black). */
+    background?: string;
+    /** World pixels are drawn this many screen pixels wide (default 1). Whole numbers keep pixel art crisp. */
+    zoom?: number;
+    /** Simulation steps per second (default 60). */
+    hz?: number;
+    /** Textures shared by the stage; a fresh registry by default. */
+    textures?: TextureRegistry;
+    /**
+     * Pixel art: nearest-neighbour textures, no antialiasing, one backing pixel per CSS pixel, and a camera that lands
+     * on whole pixels (default false: smooth textures drawn at the screen's own density, for any other art style).
+     */
+    pixelPerfect?: boolean;
+    /** Backing pixels per CSS pixel when not `pixelPerfect` (default `devicePixelRatio`, at most 2). */
+    resolution?: number;
+    /**
+     * Renderer preference (default 'webgl'). WebGL 2 runs everywhere the engine is tested. 'webgpu' is experimental:
+     * Pixi falls back to WebGL where WebGPU is missing, but the engine's own paths (pooled `PixelLayer` buffers, the
+     * `erase` blend `Darkness` cuts lights with, the fill filters) have only been profiled on WebGL.
+     */
+    preference?: 'webgl' | 'webgpu';
+}
+export interface EngineEvents {
+    /** Something a guarded step or a system threw; the frame carried on. */
+    error: {
+        where: string;
+        error: unknown;
+    };
+    /** After every rendered frame's update, before Pixi renders. */
+    frame: {
+        now: number;
+        dt: number;
+    };
+}
+/**
+ * The top of the engine: a Pixi application, the `Stage` (world and screen layers, camera, tweens, timers,
+ * pointer), a fixed-step simulation loop and a stack of scenes.
+ *
+ * ```ts
+ * const engine = await Engine.create({ parent: document.body, zoom: 3 });
+ * await engine.scenes.replace(new MyLevel());
+ * ```
+ */
+export declare class Engine {
+    readonly app: Application;
+    readonly stage: Stage;
+    readonly loop: FixedLoop;
+    readonly scenes: SceneManager;
+    readonly events: EventBus<EngineEvents>;
+    private running;
+    private destroyed;
+    private readonly onTick;
+    private constructor();
+    static create(options: EngineOptions): Promise<Engine>;
+    /** The scene that updates now, if any. */
+    get scene(): Scene | undefined;
+    /** Stops simulating and drawing; the canvas keeps its last frame. */
+    pause(): void;
+    resume(): void;
+    get paused(): boolean;
+    /** Reports a fault to `events.error` (and the console when nobody listens). */
+    reportError(where: string, error: unknown): void;
+    /** Leaves every scene, removes the canvas and frees the renderer. */
+    destroy(): Promise<void>;
+    private tick;
+}
+//# sourceMappingURL=Engine.d.ts.map

package/dist/types/engine/Engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAiB,MAAM,SAAS,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,WAAW,aAAa;IAC5B,6BAA6B;IAC7B,MAAM,EAAE,WAAW,CAAC;IACpB,8FAA8F;IAC9F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2GAA2G;IAC3G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,oGAAoG;IACpG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACzC,gEAAgE;IAChE,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAiBD;;;;;;;;GAQG;AACH,qBAAa,MAAM;IAUf,QAAQ,CAAC,GAAG,EAAE,WAAW;IAT3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,yBAAgC;IAC/C,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2D;IAElF,OAAO;WAgBM,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAmB5D,0CAA0C;IAC1C,IAAI,KAAK,IAAI,KAAK,GAAG,SAAS,CAE7B;IAED,qEAAqE;IACrE,KAAK,IAAI,IAAI;IAMb,MAAM,IAAI,IAAI;IAOd,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,+EAA+E;IAC/E,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAKhD,qEAAqE;IAC/D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAW9B,OAAO,CAAC,IAAI;CAeb"}

package/dist/types/engine/FixedLoop.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A fixed-timestep accumulator: frames arrive whenever the display wants them, the simulation advances in equal
+ * steps. Movement and anything a server replays must run here, so every machine takes the same steps whatever its
+ * frame rate.
+ *
+ * A frame that comes very late (a tab in the background, a debugger) would owe hundreds of steps; at most
+ * `maxStepsPerFrame` are run and the rest of the debt is dropped, so the game slows down instead of freezing while it
+ * catches up (the "spiral of death").
+ */
+export interface FixedLoopOptions {
+    /** Steps per second (default 60). */
+    hz?: number;
+    /** The most steps one frame may run before the debt is dropped (default 8). */
+    maxStepsPerFrame?: number;
+}
+export declare class FixedLoop {
+    readonly stepMs: number;
+    readonly stepSeconds: number;
+    private readonly maxSteps;
+    private carry;
+    /** Steps taken since the loop started. */
+    tick: number;
+    constructor(options?: FixedLoopOptions);
+    /**
+     * Feeds one frame of `deltaMs` and runs `step` as many times as it owes. Returns the share of a step left over
+     * (0–1), for interpolating what is drawn between the last two steps.
+     */
+    advance(deltaMs: number, step: (tick: number) => void): number;
+    /** Forgets any debt, e.g. after a scene change or a long load. */
+    reset(): void;
+}
+//# sourceMappingURL=FixedLoop.d.ts.map

package/dist/types/engine/FixedLoop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FixedLoop.d.ts","sourceRoot":"","sources":["../../../src/engine/FixedLoop.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,SAAS;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,KAAK,CAAK;IAClB,0CAA0C;IAC1C,IAAI,SAAK;gBAEG,OAAO,GAAE,gBAAqB;IAQ1C;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM;IAe9D,kEAAkE;IAClE,KAAK,IAAI,IAAI;CAGd"}