1681-engine 0.0.0-stage → 0.5.9

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;AAMrC,KAAK,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AA8BzC,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/pixelZoom.d.ts

@@ -0,0 +1,45 @@
+export interface PixelZoomOptions {
+    /** Canvas height (CSS px) worth one zoom step before clamping (default 290: ×2 on a phone held landscape, ×4 at 1080p). */
+    pxPerStep?: number;
+    /** The least and most zoom a screen gets on its own, before a player's offset (default 2 and 5). */
+    baseMin?: number;
+    baseMax?: number;
+    /** The least and most zoom any offset may reach (default 1 and 6). */
+    min?: number;
+    max?: number;
+    /** The one fractional zoom allowed, or null for whole steps only (default 1.5). */
+    halfZoom?: number | null;
+}
+/**
+ * The zoom a screen this tall gets on its own: one step per `pxPerStep` of height, within `baseMin`–`baseMax`.
+ * With the defaults a 375–440-px phone held landscape gets 2 (about 200 world px tall: ×1 drew a 24-px character
+ * 4 mm tall, ×3 left less than a monster's reach on screen), a 720p window 2, 1080p 4.
+ */
+export declare function baseZoom(canvasHeight: number, options?: PixelZoomOptions): number;
+/**
+ * The camera zoom (screen px per world px) for a canvas this tall, moved `offset` steps by the player (rounded to
+ * half steps), within `min`–`max`. Whole, or exactly `halfZoom`: a half step anywhere else rounds to the whole one.
+ */
+export declare function worldZoom(canvasHeight: number, offset?: number, options?: PixelZoomOptions): number;
+/**
+ * The zoom steps to offer a player on a screen this tall, by zoom from farthest to nearest: each of `offsets`
+ * and, where it lies below the screen's own zoom and no further than `lowest`, the offset that lands on `halfZoom`.
+ * Two offsets giving the same zoom are offered once, the one nearer 0 kept.
+ */
+export declare function zoomSteps(canvasHeight: number, offsets?: readonly number[], lowest?: number, options?: PixelZoomOptions): {
+    offset: number;
+    zoom: number;
+}[];
+/**
+ * The renderer's resolution for a zoom: 1 at a whole zoom (one backing pixel per CSS pixel, the cheapest fill), and at
+ * a fractional one the least whole resolution up to `maxResolution` (default 4) that makes `zoom × resolution` whole
+ * (2 at ×1.5, so a world pixel is 3 backing pixels) — but only on a screen of `devicePixelRatio` ≥ `minDpr`
+ * (default 1.5): a coarser one cannot show the difference and would pay the fill for nothing. 1 when none fits.
+ */
+export declare function zoomResolution(zoom: number, devicePixelRatio: number, minDpr?: number, maxResolution?: number): number;
+/**
+ * The whole-number scale content of this size is drawn at to fit a box (a map panel, a preview): the largest integer
+ * that fits both ways, never below 1, so every source pixel is the same number of screen pixels.
+ */
+export declare function fitScale(contentW: number, contentH: number, boxW: number, boxH: number): number;
+//# sourceMappingURL=pixelZoom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pixelZoom.d.ts","sourceRoot":"","sources":["../../../src/core/pixelZoom.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,2HAA2H;IAC3H,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oGAAoG;IACpG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAQD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAGjF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,SAAI,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAI9F;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,SAAS,MAAM,EAAmB,EAC3C,MAAM,SAAO,EACb,OAAO,CAAC,EAAE,gBAAgB,GACzB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAcpC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAM,EAAE,aAAa,SAAI,GAAG,MAAM,CAO9G;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/F"}

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

@@ -0,0 +1,15 @@
+/** Something to run at a time: a timer, an effect's later beat. `removed` ones are dropped without running. */
+export interface DueCall {
+    at: number;
+    fn: () => void;
+    removed?: boolean;
+}
+/**
+ * Runs and removes every call of `scheduled` due by `now`, in place: the list is compacted and `scratch` (kept by the
+ * caller, empty between calls) collects the due ones, so a frame allocates nothing. A call that throws goes to
+ * `failed` and the rest still run; whatever happens the due calls are gone from both lists afterwards. A list that
+ * kept a thrower threw again every frame anything else was scheduled, and cut short whatever the frame ran after it.
+ * A call scheduled by a running one lands in `scheduled` and waits for the next pass, even if already due.
+ */
+export declare function runDue<T extends DueCall>(scheduled: T[], scratch: T[], now: number, failed: (err: unknown) => void): void;
+//# sourceMappingURL=runDue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runDue.d.ts","sourceRoot":"","sources":["../../../src/core/runDue.ts"],"names":[],"mappings":"AAAA,+GAA+G;AAC/G,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,IAAI,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CA6BzH"}

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

@@ -0,0 +1,16 @@
+import { Texture } from 'pixi.js';
+/**
+ * `texture`'s frame with every opaque pixel painted `color` (default white), alpha kept; made once per frame and colour
+ * and cached. Only for textures that are never repainted (atlas frames, snapshots): copy a live one first
+ * (`TextureRegistry.snapshotInto`) and paint the copy with `fillSolid`. Null when the frame cannot be read (no
+ * drawable source, an empty or rotated frame, a cross-origin image).
+ */
+export declare function solidSilhouette(texture: Texture, color?: number): Texture | null;
+/** Paints every opaque pixel of a canvas `color` (default white), keeping its alpha. Upload the texture after. */
+export declare function fillSolid(canvas: unknown, color?: number): void;
+/**
+ * Frees cached silhouettes: those of one `texture` (it is about to be repainted or destroyed), or all of them (a
+ * scene or atlas change). A sprite still wearing one must be given another texture first.
+ */
+export declare function clearSilhouettes(texture?: Texture): void;
+//# sourceMappingURL=silhouette.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"silhouette.d.ts","sourceRoot":"","sources":["../../../src/core/silhouette.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,OAAO,EAAE,MAAM,SAAS,CAAC;AAiBhD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,SAAW,GAAG,OAAO,GAAG,IAAI,CAgClF;AAED,kHAAkH;AAClH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,SAAW,GAAG,IAAI,CAUjE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAcxD"}

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;AASxC;;;;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;IAwBf,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"frameStats.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/frameStats.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,yGAAyG;IACzG,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,mGAAmG;AACnG,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGvE;AAED,wCAAwC;AACxC,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAIpF;AAID,8GAA8G;AAC9G,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,SAAK,GAAG,YAAY,CAWtG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,aAAa,SAAM,GAAG,OAAO,CAElF"}

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

@@ -0,0 +1,9 @@
+import type { Renderer } from 'pixi.js';
+/**
+ * The largest texture side the GPU takes (WebGL's MAX_TEXTURE_SIZE), or null when the renderer is not WebGL. Many
+ * phones stop at 4096, so an atlas planned for 8192 must split its pages there (`atlasPageLimit`).
+ */
+export declare function maxTextureSize(renderer: Renderer): number | null;
+/** The GPU's own name where the browser gives it (WEBGL_debug_renderer_info), else null; for telling devices apart. */
+export declare function gpuName(renderer: Renderer, max?: number): string | null;
+//# sourceMappingURL=gpuInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpuInfo.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/gpuInfo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMxC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAKhE;AAED,uHAAuH;AACvH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,SAAK,GAAG,MAAM,GAAG,IAAI,CAQnE"}

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

@@ -0,0 +1,12 @@
+import { type Application } from 'pixi.js';
+/** An error as one short line, for a player's screenshot or a report. */
+export declare function describeError(err: unknown, max?: number): string;
+/**
+ * Replaces Pixi's render on the ticker with one that survives a throw and reports a renderer that keeps failing.
+ * A ticker listener that throws never asks for the next frame, and `Stage`'s per-step guard covers the game's steps,
+ * not the renderer's: a render that threw on its first frame froze the canvas in silence while the page went on.
+ * A single bad frame is let go; `failures` in a row are reported once. Returns the uninstall, which puts Pixi's own
+ * render back.
+ */
+export declare function guardRender(app: Application, onFail: (detail: string, err: unknown) => void, failures?: number): () => void;
+//# sourceMappingURL=renderGuard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderGuard.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/renderGuard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,SAAS,CAAC;AAE5D,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,SAAM,GAAG,MAAM,CAG7D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,EAAE,QAAQ,SAAK,GAAG,MAAM,IAAI,CAsBvH"}