1681-engine 0.0.0-stage → 0.5.8

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

@@ -0,0 +1,70 @@
+import { Timeline, type TimelineOptions } from './Timeline.js';
+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;
+}
+/**
+ * Anything the manager can step each frame: a `Tween`, or a `Timeline` it drives. `step` answers false once finished
+ * (the manager then drops it); `remove` stops it for good; `targets` is what `killTweensOf` matches against.
+ */
+export interface Steppable {
+    step(dt: number): boolean;
+    remove(): void;
+    readonly targets: readonly object[];
+}
+/** 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;
+    /**
+     * Steps `item` every frame from the next one on, at this manager's `timeScale`, until its `step` answers false or
+     * the manager is cleared (a stage's manager is cleared when the stage is destroyed).
+     */
+    run<T extends Steppable>(item: T): T;
+    /** A `Timeline` driven by this manager: it follows `timeScale` and stops with `clear`. */
+    timeline(options?: Omit<TimelineOptions, 'tweens'>): Timeline;
+    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":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAG5D,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;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,MAAM,IAAI,IAAI,CAAC;IACf,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,yFAAyF;AACzF,qBAAa,OAAO;IAClB,+DAA+D;IAC/D,SAAS,SAAK;IACd,OAAO,CAAC,MAAM,CAAmB;IAEjC,GAAG,CAAC,GAAG,EAAE,WAAW,GAAG,KAAK;IAoB5B;;;OAGG;IACH,GAAG,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IAKpC,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,GAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAM,GAAG,QAAQ;IAIjE,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/timelinePlace.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Where a child goes on a timeline: a time in ms from its start, or a string —
+ * `'<'` the start of the child added last, `'>'` its end, `'+=200'` / `'-=100'` 200 ms after / 100 ms before the
+ * default place (the timeline's end, or a `parallel` group's start), `'intro'` a label, and any of `'<'`, `'>'` or a
+ * label followed by `+=n` / `-=n`. A string of digits is a time.
+ */
+export type TimelinePosition = number | string;
+/** What a position is measured against; `labels` is written to when a position names a label not yet set. */
+export interface PlaceContext {
+    /** Where a child goes when no position is given: the timeline's end, or the open `parallel` group's start. */
+    fallback: number;
+    /** The end of the timeline as built so far: where a label first named in a position is set. */
+    end: number;
+    lastStart: number;
+    lastEnd: number;
+    labels: Map<string, number>;
+}
+/**
+ * The start time (ms, never below 0) `at` names. A label not set yet is set at the timeline's end, the way GSAP does,
+ * so `to(a, …, { at: 'hit' })` both places the child and names the spot for the children after it.
+ */
+export declare function placeAt(at: TimelinePosition | undefined, ctx: PlaceContext): number;
+//# sourceMappingURL=timelinePlace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timelinePlace.d.ts","sourceRoot":"","sources":["../../../src/core/timelinePlace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,CAAC;AAE/C,6GAA6G;AAC7G,MAAM,WAAW,YAAY;IAC3B,8GAA8G;IAC9G,QAAQ,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAKD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,gBAAgB,GAAG,SAAS,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAsBnF"}

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

@@ -0,0 +1,8 @@
+import type { TweenTarget } from './Tweener.js';
+/**
+ * How a tween reads and writes one property, shared by `Tweener` and `Timeline` so both treat `scale` the same way:
+ * one number written to `scaleX` and `scaleY`, the shape every display object here exposes.
+ */
+export declare function readProp(target: TweenTarget, prop: string): number;
+export declare function writeProp(target: TweenTarget, prop: string, value: number): void;
+//# sourceMappingURL=tweenProps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tweenProps.d.ts","sourceRoot":"","sources":["../../../src/core/tweenProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAKhF"}

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/debug/DebugOverlay.d.ts

@@ -0,0 +1,63 @@
+import type { ComponentType, World } from '../ecs/World.js';
+import type { Engine } from '../engine/Engine.js';
+import { ErrorLog } from './ErrorLog.js';
+/** Draws one box in world coordinates (a hurtbox, a wall, a trigger), in `color` (default green). */
+export type BoxDrawer = (x: number, y: number, width: number, height: number, color?: number) => void;
+/** Draws one line in world coordinates (a turned collider's edge, a ray), in `color` (default green). */
+export type LineDrawer = (x0: number, y0: number, x1: number, y1: number, color?: number) => void;
+export interface DebugOverlayOptions {
+    /**
+     * `KeyboardEvent.code` that shows and hides it (default 'Backquote'). The key's own browser action is prevented
+     * (F3 would open the find bar, F12 the developer tools).
+     */
+    key?: string;
+    /** The world to count and inspect (default the current scene's). */
+    world?: () => World | undefined;
+    /** Component types the inspector lists; none, and it lists every entity with all it holds. */
+    components?: readonly ComponentType<unknown>[];
+    /** Entities listed at most (default 12). */
+    inspectLimit?: number;
+    /** Called every shown frame to draw collision boxes (and lines: turned shapes, rays). */
+    colliders?: (draw: BoxDrawer, line: LineDrawer) => void;
+    /** Errors kept (default 8). */
+    errors?: number;
+    /** Where the key is listened for (default `window`). */
+    target?: Window | HTMLElement;
+}
+/**
+ * A developer overlay toggled by a key: FPS with a frame-time graph, draw calls and textures, the entity count, a
+ * list of entities and their components, collision boxes, and the last errors the frame guard caught.
+ *
+ * Hidden, it costs nothing per frame: nothing is drawn or listened to but the key and the engine's `error` event
+ * (so faults from before it was opened are still listed). Shown, it rides the engine's `frame` event.
+ */
+export declare class DebugOverlay {
+    private readonly engine;
+    private readonly options;
+    readonly errors: ErrorLog;
+    private readonly stats;
+    private readonly panel;
+    private readonly back;
+    private readonly graph;
+    private readonly text;
+    private readonly boxes;
+    private readonly boxLayer;
+    private readonly draws;
+    private readonly cleanup;
+    private offFrame;
+    private lastText;
+    private drawCalls;
+    private shown;
+    private readonly drawBox;
+    private readonly drawLine;
+    constructor(engine: Engine, options?: DebugOverlayOptions);
+    get visible(): boolean;
+    toggle(): void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+    private frame;
+    private paintGraph;
+    private paintText;
+}
+//# sourceMappingURL=DebugOverlay.d.ts.map

package/dist/types/debug/DebugOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DebugOverlay.d.ts","sourceRoot":"","sources":["../../../src/debug/DebugOverlay.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,qGAAqG;AACrG,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAEtG,yGAAyG;AACzG,MAAM,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAElG,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,KAAK,GAAG,SAAS,CAAC;IAChC,8FAA8F;IAC9F,UAAU,CAAC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;IAC/C,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yFAAyF;IACzF,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACxD,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CAC/B;AAOD;;;;;;GAMG;AACH,qBAAa,YAAY;IAwBrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAxB1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4G;IACjI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEtB;IAEF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAEvB;gBAGiB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB;IAwBpD,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,MAAM,IAAI,IAAI;IAKd,IAAI,IAAI,IAAI;IAaZ,IAAI,IAAI,IAAI;IAYZ,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,KAAK;IAab,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,SAAS;CAmBlB"}

package/dist/types/debug/DrawCallCounter.d.ts

@@ -0,0 +1,20 @@
+import type { Renderer } from 'pixi.js';
+/**
+ * Counts WebGL draw calls by wrapping the context's draw functions while it is installed, since Pixi 8 keeps no
+ * count of its own. Installed only while the debug overlay is open, so a closed overlay costs nothing; on WebGPU
+ * (no `gl`) it counts nothing and says so.
+ */
+export declare class DrawCallCounter {
+    private readonly renderer;
+    /** Draw calls since the last `take`. */
+    private calls;
+    private restore;
+    constructor(renderer: Renderer);
+    /** Whether this renderer can be counted (WebGL). */
+    get supported(): boolean;
+    install(): void;
+    uninstall(): void;
+    /** Draw calls since the last call, and starts counting again. */
+    take(): number;
+}
+//# sourceMappingURL=DrawCallCounter.d.ts.map

package/dist/types/debug/DrawCallCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrawCallCounter.d.ts","sourceRoot":"","sources":["../../../src/debug/DrawCallCounter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC;;;;GAIG;AACH,qBAAa,eAAe;IAKd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJrC,wCAAwC;IACxC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,OAAO,CAA6B;gBAEf,QAAQ,EAAE,QAAQ;IAE/C,oDAAoD;IACpD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,OAAO,IAAI,IAAI;IAmBf,SAAS,IAAI,IAAI;IAKjB,iEAAiE;IACjE,IAAI,IAAI,MAAM;CAKf"}

package/dist/types/debug/ErrorLog.d.ts

@@ -0,0 +1,20 @@
+/** One fault the frame guard (or a system) caught. */
+export interface LoggedError {
+    where: string;
+    message: string;
+    /** How many times in a row the same fault came in. */
+    count: number;
+    at: number;
+}
+/**
+ * The last `limit` distinct faults, newest last. A fault repeating every frame is one entry with a count, not
+ * sixty lines a second pushing everything else out.
+ */
+export declare class ErrorLog {
+    readonly limit: number;
+    readonly entries: LoggedError[];
+    constructor(limit?: number);
+    add(where: string, error: unknown, at?: number): void;
+    clear(): void;
+}
+//# sourceMappingURL=ErrorLog.d.ts.map

package/dist/types/debug/ErrorLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorLog.d.ts","sourceRoot":"","sources":["../../../src/debug/ErrorLog.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,qBAAa,QAAQ;IAGP,QAAQ,CAAC,KAAK;IAF1B,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAM;gBAEhB,KAAK,SAAK;IAE/B,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,SAAa,GAAG,IAAI;IAYzD,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/debug/FrameStats.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The last `size` frame times in a ring of numbers: pure, allocation-free, read by the debug overlay's graph and
+ * its FPS line. Averages are over the ring, so one long frame shows in `max` without wrecking the FPS shown.
+ */
+export declare class FrameStats {
+    readonly size: number;
+    readonly times: Float32Array;
+    private head;
+    private filled;
+    constructor(size?: number);
+    /** Records one frame's length in ms. */
+    push(ms: number): void;
+    get count(): number;
+    /** The `i`-th frame, oldest first. */
+    at(i: number): number;
+    get average(): number;
+    get max(): number;
+    get fps(): number;
+    clear(): void;
+}
+//# sourceMappingURL=FrameStats.d.ts.map

package/dist/types/debug/FrameStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameStats.d.ts","sourceRoot":"","sources":["../../../src/debug/FrameStats.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,UAAU;IAKT,QAAQ,CAAC,IAAI;IAJzB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAK;gBAEE,IAAI,SAAM;IAI/B,wCAAwC;IACxC,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMtB,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,sCAAsC;IACtC,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAIrB,IAAI,OAAO,IAAI,MAAM,CAKpB;IAED,IAAI,GAAG,IAAI,MAAM,CAIhB;IAED,IAAI,GAAG,IAAI,MAAM,CAGhB;IAED,KAAK,IAAI,IAAI;CAId"}

package/dist/types/debug/inspectWorld.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentType, Entity, World } from '../ecs/World.js';
+/** One entity as the inspector lists it. */
+export interface EntityRow {
+    entity: Entity;
+    /** `Name` or `Name {…}` per component it holds, of those asked about. */
+    components: string[];
+}
+/**
+ * Lists up to `limit` entities with a short preview of each component's value: those holding any of `components`
+ * when the game names some (only those shown), else every live entity with all it holds (`World.entities`,
+ * `componentsOf`). For the debug overlay: it allocates, and runs a few times a second only while the overlay is open.
+ */
+export declare function inspectWorld(world: World, components?: readonly ComponentType<unknown>[], limit?: number, previewLength?: number): EntityRow[];
+//# sourceMappingURL=inspectWorld.d.ts.map

package/dist/types/debug/inspectWorld.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectWorld.d.ts","sourceRoot":"","sources":["../../../src/debug/inspectWorld.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAEjE,4CAA4C;AAC5C,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,SAAK,EAAE,aAAa,SAAK,GAAG,SAAS,EAAE,CAoBtI"}

package/dist/types/diagnostics/ErrorDeduper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Lets through each distinct error once, and only so many in all: a loop throwing every frame is one report, not
+ * sixty a second. Errors are told apart by the first `keyLength` characters of their message.
+ */
+export declare class ErrorDeduper {
+    private readonly max;
+    private readonly keyLength;
+    private readonly seen;
+    constructor(max?: number, keyLength?: number);
+    /** The key to report under, or null when this error was already let through or the allowance is spent. */
+    admit(message: string): string | null;
+    /** Forgets what was let through (a new session). */
+    reset(): void;
+}
+/** The first `lines` lines of a stack, at most `max` characters. */
+export declare function trimStack(stack: string | undefined, lines?: number, max?: number): string;
+//# sourceMappingURL=ErrorDeduper.d.ts.map

package/dist/types/diagnostics/ErrorDeduper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorDeduper.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/ErrorDeduper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,YAAY;IAIrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;gBAGvB,GAAG,SAAK,EACR,SAAS,SAAM;IAGlC,0GAA0G;IAC1G,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOrC,oDAAoD;IACpD,KAAK,IAAI,IAAI;CAGd;AAED,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,SAAI,EAAE,GAAG,SAAM,GAAG,MAAM,CAEjF"}

package/dist/types/diagnostics/FrameSampler.d.ts

@@ -0,0 +1,37 @@
+import { type Ticker } from 'pixi.js';
+import { type FrameSummary } from './frameStats.js';
+export interface FrameSamplerOptions {
+    /** How long one sample spans, ms (default a minute). */
+    windowMs?: number;
+    /** A frame longer than this is a hitch, ms (default 50). */
+    hitchMs?: number;
+    /** Fewer frames than this in a window is no sample (default 30). */
+    minFrames?: number;
+    /** A window whose median frame is over this came from a throttled background window and is dropped (default 500). */
+    throttledMedianMs?: number;
+    /** Frames are not counted while this says so (default: the page is hidden). */
+    paused?: () => boolean;
+    now?: () => number;
+}
+/**
+ * Measures how a game really runs on a player's device: each frame costs one number pushed on an array, and every
+ * `windowMs` the window is summed into a `FrameSummary` handed to `onSample` — FPS, the 1% low, the 95th-percentile
+ * frame, hitches. The engine sends nothing anywhere: what the game does with a sample (a readout, a report to its
+ * server) is the callback's.
+ */
+export declare class FrameSampler {
+    private readonly onSample;
+    private frames;
+    private since;
+    private readonly opts;
+    private readonly paused;
+    private readonly now;
+    constructor(onSample: (summary: FrameSummary) => void, options?: FrameSamplerOptions);
+    /** One frame of `deltaMs`; sums the window once it is full. */
+    push(deltaMs: number): void;
+    /** Starts a fresh window, dropping what was counted (after a scene change, say). */
+    reset(): void;
+    /** Feeds the sampler from a Pixi ticker, after the render; returns the detach. */
+    attach(ticker: Ticker): () => void;
+}
+//# sourceMappingURL=FrameSampler.d.ts.map

package/dist/types/diagnostics/FrameSampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameSampler.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/FrameSampler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAmB,MAAM,SAAS,CAAC;AACvD,OAAO,EAAmC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAElF,MAAM,WAAW,mBAAmB;IAClC,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qHAAqH;IACrH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IAOX,OAAO,CAAC,QAAQ,CAAC,QAAQ;IANrC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwD;IAC7E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEN,QAAQ,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,EAAE,OAAO,GAAE,mBAAwB;IAYzG,+DAA+D;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAe3B,oFAAoF;IACpF,KAAK,IAAI,IAAI;IAKb,kFAAkF;IAClF,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI;CAKnC"}

package/dist/types/diagnostics/bootWatch.d.ts

@@ -0,0 +1,25 @@
+/** What `bootWatch` reports when a start hangs. */
+export interface BootStall {
+    /** The step the start stood on. */
+    step: string;
+    /** Every step reached, in order, with the ms since the watch began when each was reached. */
+    steps: {
+        name: string;
+        atMs: number;
+    }[];
+    /** `stuck: <step>`, a line short enough for a player's screenshot. */
+    detail: string;
+}
+export interface BootWatch {
+    /** Moves the watch on to a named step. */
+    step(name: string): void;
+    /** The start finished: the watch stops. */
+    done(): void;
+}
+/**
+ * Says when a start has not finished `ms` after it began, naming the step it stood on. A world that never got built
+ * otherwise leaves the player looking at a loading line forever while the rest of the page goes on under it; named
+ * steps turn "it hangs" into "it hangs loading textures".
+ */
+export declare function bootWatch(ms: number, onStuck: (stall: BootStall) => void, now?: () => number): BootWatch;
+//# sourceMappingURL=bootWatch.d.ts.map

package/dist/types/diagnostics/bootWatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootWatch.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/bootWatch.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,6FAA6F;IAC7F,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxC,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,0CAA0C;IAC1C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,2CAA2C;IAC3C,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,EAAE,GAAG,GAAE,MAAM,MAAgC,GAAG,SAAS,CAkBjI"}

package/dist/types/diagnostics/captureErrors.d.ts

@@ -0,0 +1,24 @@
+import { ErrorDeduper } from './ErrorDeduper.js';
+/** One error, as handed to `captureErrors`' callback. */
+export interface CapturedError {
+    message: string;
+    /** The first lines of its stack, or ''. */
+    stack: string;
+    /** `uncaught`, `rejection`, or `frame` for one a `Stage` step caught so the frame could go on. */
+    source: 'uncaught' | 'rejection' | 'frame';
+}
+export interface CaptureErrorsOptions {
+    /** Distinct errors reported in all (default 10). */
+    max?: number;
+    /** Also report what a `Stage` frame caught (`Stage.onCaught`; default true): there a fault shows only as a stuck view. */
+    frames?: boolean;
+    /** Shared with the game's own reports (`admit` before sending), so one error is not told twice. */
+    deduper?: ErrorDeduper;
+}
+/**
+ * Hands every error nothing else caught — `error` and `unhandledrejection` on the window, and what a frame caught —
+ * to `onError`, each distinct one once. The engine sends nothing itself; reporting it is the game's. Returns the
+ * uninstall, which puts back whatever held `Stage.onCaught` before.
+ */
+export declare function captureErrors(onError: (e: CapturedError) => void, options?: CaptureErrorsOptions): () => void;
+//# sourceMappingURL=captureErrors.d.ts.map

package/dist/types/diagnostics/captureErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureErrors.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/captureErrors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAa,MAAM,gBAAgB,CAAC;AAEzD,yDAAyD;AACzD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,kGAAkG;IAClG,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,OAAO,CAAC;CAC5C;AAED,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,0HAA0H;IAC1H,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mGAAmG;IACnG,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,IAAI,CA+BjH"}

package/dist/types/diagnostics/contextLoss.d.ts

@@ -0,0 +1,35 @@
+export interface ContextLossPolicy {
+    /** Losses tolerated inside `windowMs` before giving up (default 3). */
+    maxLosses?: number;
+    /** How far back losses are counted, ms (default two minutes). */
+    windowMs?: number;
+}
+export interface ContextLossVerdict {
+    /** The losses still inside the window, this one included (unless the page was hidden). */
+    losses: number[];
+    /** Stop rebuilding: the GPU keeps failing. */
+    giveUp: boolean;
+    /** How long to wait before rebuilding (`rebuildDelayMs`). */
+    delayMs: number;
+}
+/**
+ * One more context loss at `now`, given the earlier ones. A loss while the page is `hidden` is the system taking the
+ * GPU back, not the GPU failing, so it is not counted against it.
+ */
+export declare function noteContextLoss(earlier: readonly number[], now: number, hidden?: boolean, policy?: ContextLossPolicy): ContextLossVerdict;
+/**
+ * How long to wait before rebuilding after a loss, with `losses` counted in the window: a GPU that has just reset is
+ * given longer each time it drops the context again (a rebuild at once was dropped at once on a phone).
+ */
+export declare function rebuildDelayMs(losses: number): number;
+/**
+ * Calls `onLost` with a verdict each time `canvas` (the renderer's) loses its WebGL context; the game tears its world
+ * down and rebuilds it after `delayMs`, or shows an error when `giveUp`. The event's default is prevented, which is
+ * what lets the browser restore the context at all. Returns the uninstall.
+ */
+export declare function watchContextLoss(canvas: EventTarget, onLost: (verdict: ContextLossVerdict) => void, options?: ContextLossPolicy & {
+    onRestored?: () => void;
+    now?: () => number;
+    hidden?: () => boolean;
+}): () => void;
+//# sourceMappingURL=contextLoss.d.ts.map

package/dist/types/diagnostics/contextLoss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextLoss.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/contextLoss.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,0FAA0F;IAC1F,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,8CAA8C;IAC9C,MAAM,EAAE,OAAO,CAAC;IAChB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,UAAQ,EAAE,MAAM,GAAE,iBAAsB,GAAG,kBAAkB,CAK3I;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,EAC7C,OAAO,GAAE,iBAAiB,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAA;CAAO,GACxG,MAAM,IAAI,CAiBZ"}

package/dist/types/diagnostics/frameStats.d.ts

@@ -0,0 +1,30 @@
+/** A summary of the frames of one sampling window. */
+export interface FrameSummary {
+    /** Frames rendered. */
+    frames: number;
+    /** Frames a second over the window. */
+    fps: number;
+    /** The "1% low": the frame rate of the slowest hundredth of frames, which is what stutter feels like. */
+    fpsLow: number;
+    /** The 95th-percentile frame time, ms. */
+    frameP95: number;
+    /** The median frame time, ms. */
+    frameMedian: number;
+    /** The longest frame, ms. */
+    worstMs: number;
+    /** Frames longer than the hitch threshold: the ones a player feels. */
+    hitches: number;
+}
+/** The value at fraction `p` (0..1) of an ascending list, by nearest rank; 0 for an empty list. */
+export declare function percentile(sorted: readonly number[], p: number): number;
+/** Frames longer than `thresholdMs`. */
+export declare function countHitches(frameMs: readonly number[], thresholdMs: number): number;
+/** The summary of frame times (ms) rendered over `spanMs`; a frame over `hitchMs` (default 50) is a hitch. */
+export declare function summarizeFrames(frameMs: readonly number[], spanMs: number, hitchMs?: number): FrameSummary;
+/**
+ * A window the browser throttled: one covered by another window is not `hidden`, but runs at about a frame a second,
+ * and a second copy of a game parked behind the first read as its heaviest scene. Nothing really played runs with
+ * its median frame half a second long.
+ */
+export declare function looksThrottled(summary: FrameSummary, medianLimitMs?: number): boolean;
+//# sourceMappingURL=frameStats.d.ts.map