1681-engine 0.0.0-stage → 0.5.8

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"}

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,137 @@
+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;
+    /** Every live entity, for tools (a debugger, a save); allocates, so not for a per-frame path. */
+    entities(): Entity[];
+    /** The component types `e` holds, for tools; allocates. */
+    componentsOf(e: Entity): ComponentType<unknown>[];
+    /** 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;WAiBM,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"}

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

@@ -0,0 +1,67 @@
+import { Container } from 'pixi.js';
+import { World } from '../ecs/World.js';
+import type { Engine } from './Engine.js';
+/** Input a scene can be told to forget its pending presses on (an `Actions`). */
+export interface FlushableInput {
+    flush(): void;
+}
+/** A timer `Scene.delay` started; `remove` cancels it. */
+export interface SceneTimer {
+    remove(): void;
+}
+/**
+ * One screen of the game: a title, a level, a pause menu. A scene owns a `World` of entities and systems and a
+ * `root` container in the engine's world layer; both are cleared when it leaves, so nothing it made outlives it.
+ *
+ * Override the hooks you need. `fixedUpdate` runs once per simulation step, `update` once per rendered frame, both
+ * after the world's own systems of that phase.
+ *
+ * Two things a scene should hand the engine so they end with it: timers (`delay`, not `stage.time.delayedCall`, whose
+ * timers belong to the stage and fire after the scene has gone) and its input (`useInput`, flushed when a scene pushed
+ * over this one pops, so presses made in a pause menu are not read again by the level under it).
+ *
+ * Names taken: `world`, `root` and `hud` are the scene's own fields, so a subclass cannot declare a field of those
+ * names for something else (a HUD class of the game's is best kept as `display`, `overlay`, …).
+ */
+export declare abstract class Scene {
+    readonly world: World;
+    /** Everything the scene draws in the world goes under this (the camera moves it). */
+    readonly root: Container<import("pixi.js").ContainerChild>;
+    /** Everything the scene draws on the screen (HUD) goes under this. */
+    readonly hud: Container<import("pixi.js").ContainerChild>;
+    private bound;
+    private readonly timers;
+    private readonly inputs;
+    /** The engine running this scene; only valid between `enter` and `exit`. */
+    get engine(): Engine;
+    /** Called once when the scene becomes active. May be async: the scene starts updating when it resolves. */
+    onEnter(): void | Promise<void>;
+    /** Called when the scene is removed. The world and containers are cleared after it returns. */
+    onExit(): void;
+    /** Called when another scene is pushed over this one. */
+    onPause(): void;
+    /** Called when the scene over this one is popped. */
+    onResume(): void;
+    /** Once per simulation step, `dt` in seconds. */
+    fixedUpdate(_dt: number): void;
+    /** Once per rendered frame, `dt` in seconds; `alpha` is the share of a step since the last one (0–1). */
+    update(_dt: number, _alpha: number): void;
+    /**
+     * Calls `fn` after `ms` on the stage's clock, unless the scene has left by then: its timers are cancelled when it
+     * exits. Only valid while the scene is running (between `enter` and `exit`).
+     */
+    delay(ms: number, fn: () => void): SceneTimer;
+    /**
+     * Registers input the scene reads (an `Actions`) and returns it, so a field can be written in one line:
+     * `private readonly input = this.useInput(new Actions(keyboard, bindings));`. When a scene pushed over this one
+     * pops, every registered input is flushed before `onResume`, so a key pressed in the menu is not a press here.
+     */
+    useInput<T extends FlushableInput>(input: T): T;
+    /** @internal Called by the scene manager before `onResume`. */
+    flushInput(): void;
+    /** @internal Engine-side wiring; games call `engine.scenes`. */
+    attach(engine: Engine): void;
+    /** @internal Clears what the scene made but keeps its containers, so the same scene may be entered again. */
+    detach(): void;
+}
+//# sourceMappingURL=Scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../src/engine/Scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,KAAK,IAAI,IAAI,CAAC;CACf;AAED,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,8BAAsB,KAAK;IACzB,QAAQ,CAAC,KAAK,QAAe;IAC7B,qFAAqF;IACrF,QAAQ,CAAC,IAAI,8CAA6C;IAC1D,sEAAsE;IACtE,QAAQ,CAAC,GAAG,8CAAmB;IAC/B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAE/C,4EAA4E;IAC5E,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED,2GAA2G;IAC3G,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC/B,+FAA+F;IAC/F,MAAM,IAAI,IAAI;IACd,yDAAyD;IACzD,OAAO,IAAI,IAAI;IACf,qDAAqD;IACrD,QAAQ,IAAI,IAAI;IAChB,iDAAiD;IACjD,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAC9B,yGAAyG;IACzG,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAEzC;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,UAAU;IAe7C;;;;OAIG;IACH,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAK/C,+DAA+D;IAC/D,UAAU,IAAI,IAAI;IAIlB,gEAAgE;IAChE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B,6GAA6G;IAC7G,MAAM,IAAI,IAAI;CASf"}

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

@@ -0,0 +1,36 @@
+import type { Engine } from './Engine.js';
+import type { Scene } from './Scene.js';
+/**
+ * A stack of scenes. Only the top one updates; the ones under it are paused but still drawn (a pause menu over the
+ * level). Changes are queued and applied one at a time, so a scene that replaces itself from inside its own update,
+ * or an async `onEnter` still loading, never leaves two scenes half entered.
+ *
+ * The camera is the engine's, not a scene's: `replace` resets it (`Camera.reset`: no target, no bounds, the default
+ * zoom) after the old scenes leave and before the new one enters, so a level's follow and bounds never hold over a
+ * title screen. `push` and `pop` leave it as it is: the scene under a pause menu keeps its view. `pop` flushes the
+ * resumed scene's input (`Scene.useInput`) before its `onResume`.
+ */
+export declare class SceneManager {
+    private readonly engine;
+    private readonly stack;
+    private queue;
+    /** True while an async `onEnter` is running: nothing updates until it is done. */
+    private entering;
+    constructor(engine: Engine);
+    /** The scene that updates, if any. */
+    get current(): Scene | undefined;
+    /** Every scene on the stack, bottom first. */
+    get all(): readonly Scene[];
+    /** Removes every scene and enters `scene`. */
+    replace(scene: Scene): Promise<void>;
+    /** Pauses the current scene and enters `scene` over it. */
+    push(scene: Scene): Promise<void>;
+    /** Leaves the current scene and resumes the one under it. */
+    pop(): Promise<void>;
+    /** Leaves every scene (the engine is shutting down). */
+    clear(): Promise<void>;
+    private enter;
+    private exitTop;
+    private enqueue;
+}
+//# sourceMappingURL=SceneManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../src/engine/SceneManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;;GASG;AACH,qBAAa,YAAY;IAMX,OAAO,CAAC,QAAQ,CAAC,MAAM;IALnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,KAAK,CAAoC;IACjD,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAS;gBAEI,MAAM,EAAE,MAAM;IAE3C,sCAAsC;IACtC,IAAI,OAAO,IAAI,KAAK,GAAG,SAAS,CAE/B;IAED,8CAA8C;IAC9C,IAAI,GAAG,IAAI,SAAS,KAAK,EAAE,CAE1B;IAED,8CAA8C;IAC9C,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpC,2DAA2D;IAC3D,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjC,6DAA6D;IAC7D,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAWpB,wDAAwD;IACxD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAMR,KAAK;IAanB,OAAO,CAAC,OAAO;IAUf,OAAO,CAAC,OAAO;CAMhB"}

package/dist/types/events/EventBus.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Typed observer: listeners subscribe per event name and run in subscription order.
+ * `Events` maps each event name to its payload, e.g. `EventBus<{ enemyKilled: { id: number } }>`.
+ *
+ * A listener that throws does not stop the ones after it; the error is handed to `onError` (the console by default).
+ */
+export declare class EventBus<Events extends object> {
+    private readonly onError;
+    private readonly listeners;
+    constructor(onError?: (type: keyof Events, err: unknown) => void);
+    /** Subscribes to `type`; returns the unsubscribe function. */
+    on<K extends keyof Events>(type: K, fn: (payload: Events[K]) => void): () => void;
+    /** Subscribes for the next `type` only. */
+    once<K extends keyof Events>(type: K, fn: (payload: Events[K]) => void): () => void;
+    off<K extends keyof Events>(type: K, fn: (payload: Events[K]) => void): void;
+    emit<K extends keyof Events>(type: K, payload: Events[K]): void;
+    listenerCount(type: keyof Events): number;
+    clear(): void;
+}
+//# sourceMappingURL=EventBus.d.ts.map

package/dist/types/events/EventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventBus.d.ts","sourceRoot":"","sources":["../../../src/events/EventBus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,QAAQ,CAAC,MAAM,SAAS,MAAM;IAG7B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyD;gBAEtD,OAAO,GAAE,CAAC,IAAI,EAAE,MAAM,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,IAAoF;IAEhK,8DAA8D;IAC9D,EAAE,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAKjF,2CAA2C;IAC3C,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAQnF,GAAG,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAQ5E,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI;IAW/D,aAAa,CAAC,IAAI,EAAE,MAAM,MAAM,GAAG,MAAM;IAIzC,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/fx/FloatingText.d.ts

@@ -0,0 +1,71 @@
+import { type BitmapLabel } from '../core/BitmapLabel.js';
+import type { Container } from 'pixi.js';
+import type { Stage } from '../core/Stage.js';
+/** One look of floating text: a size and a fill colour. Each look is its own baked font. */
+export interface FloatingTextStyle {
+    size: number;
+    color: string;
+}
+export interface FloatingTextOptions {
+    /** A font already loaded (`document.fonts.load`), or the glyphs bake in the fallback. */
+    fontFamily: string;
+    /** Outline colour (default near-black). */
+    stroke?: string;
+    /** Outline width for a size (default a fifth of it, at least 2). */
+    strokeWidth?: (size: number) => number;
+    /** Rasterising resolution (default 4, crisp under a zoomed camera). */
+    resolution?: number;
+    /** Spent labels of one style kept for reuse; the rest are destroyed (default 24). */
+    keepPerStyle?: number;
+    /** Letters beyond ASCII the labels print (see `installLabelFont`), baked with each style's font. */
+    glyphs?: string;
+    /** Depth given to every label taken (default: left as made). */
+    depth?: number;
+    /**
+     * Where new labels are added (default the stage's world layer). Give a scene's `root` and the labels live and die
+     * with the scene: on the world layer they outlive it, and a label still floating when the scene changes stays.
+     */
+    parent?: Container;
+}
+/** How `float` moves a label: pops from `pop`× to 1, holds, then rises `rise` px while fading out. */
+export interface FloatOptions {
+    rise?: number;
+    /** Sideways drift over the fade, px (pass a random one for a crowd of numbers that do not stack). */
+    driftX?: number;
+    pop?: number;
+    popMs?: number;
+    holdMs?: number;
+    fadeMs?: number;
+}
+/**
+ * Floating text — damage numbers, pickups, "+1" — drawn from bitmap fonts and reused rather than created and
+ * destroyed each time: a crowded fight throws dozens a second, and as canvas text each one repainted a canvas at
+ * resolution 4 and uploaded it. A label keeps its font, so spent ones are pooled per style and only their string
+ * changes. Fonts are baked ahead (`warm`): a style first met mid-fight baked its glyph pages on that frame.
+ */
+export declare class FloatingText {
+    private readonly stage;
+    private readonly options;
+    private readonly pools;
+    private readonly stroke;
+    private readonly strokeWidth;
+    private readonly resolution;
+    private readonly keep;
+    constructor(stage: Stage, options: FloatingTextOptions);
+    /**
+     * Bakes the fonts of `styles`, one a task starting `delayMs` from now, so no frame pays for them all at once — ten
+     * at once froze a world's first frame half a second (each font measures and kerns every glyph). Returns a cancel.
+     */
+    warm(styles: readonly FloatingTextStyle[], delayMs?: number, gapMs?: number): () => void;
+    /** Bakes one style's font now. */
+    install(style: FloatingTextStyle): void;
+    /** A label ready to animate: shown, opaque, unscaled, anchored at its bottom centre on (x, y). */
+    take(x: number, y: number, text: string, style: FloatingTextStyle): BitmapLabel;
+    /** Hands a finished label back for reuse. */
+    release(t: BitmapLabel, style: FloatingTextStyle): void;
+    /** A label that pops, rises, fades and goes back to the pool by itself, on the stage's own tweens. */
+    float(x: number, y: number, text: string, style: FloatingTextStyle, options?: FloatOptions): BitmapLabel;
+    /** Destroys every pooled label (a scene ending); labels still out are the scene's to free. */
+    clear(): void;
+}
+//# sourceMappingURL=FloatingText.d.ts.map

package/dist/types/fx/FloatingText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingText.d.ts","sourceRoot":"","sources":["../../../src/fx/FloatingText.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAoB,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,4FAA4F;AAC5F,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,yFAAyF;IACzF,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qFAAqF;IACrF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oGAAoG;IACpG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED,sGAAsG;AACtG,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID;;;;;GAKG;AACH,qBAAa,YAAY;IAQrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAR1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;gBAGX,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,mBAAmB;IAQ/C;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,EAAE,OAAO,SAAO,EAAE,KAAK,SAAK,GAAG,MAAM,IAAI;IAalF,kCAAkC;IAClC,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAIvC,kGAAkG;IAClG,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,WAAW;IAqB/E,6CAA6C;IAC7C,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAavD,sGAAsG;IACtG,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,OAAO,GAAE,YAAiB,GAAG,WAAW;IAqB5G,8FAA8F;IAC9F,KAAK,IAAI,IAAI;CAId"}

package/dist/types/fx/hitStop.d.ts

@@ -0,0 +1,20 @@
+/** The freeze-frame of a blow (ms): 40 for a scratch, up to 140 for one that took a third of the body; a crit +40. */
+export declare function hitStopMs(share: number, crit: boolean): number;
+/** How far the body struck recoils away from the blow (whole world px): a heavy body barely, a crit a pixel further. */
+export declare function recoilPx(heavy: boolean, share: number, crit: boolean): number;
+/** How long a recoil takes to settle back (ms). */
+export declare const RECOIL_MS = 120;
+/** The recoil left at `t` (0 the blow, 1 settled): out at once, eased back, whole pixels only. */
+export declare function recoilAt(px: number, t: number): number;
+/** The least time between two white flashes on a heavy body (ms). */
+export declare const HEAVY_FLASH_GAP_MS = 400;
+/**
+ * How long the body struck flashes white (ms), 0 for none: 70, a crit of one's own 140 (the impact frame), nothing with
+ * `reduce` (a "reduce flashes" setting). A heavy body (a boss, anything drawn large) flashes only for the local
+ * player's own crit, 60 ms, `HEAVY_FLASH_GAP_MS` apart: a sheet covering most of the screen turning white on every
+ * blow, beat and tick is a strobe. Sparks, numbers and the recoil still mark every blow.
+ */
+export declare function hurtFlashMs(heavy: boolean, impact: boolean, reduce: boolean): number;
+/** The gap a body keeps between two flashes (ms). */
+export declare function hurtFlashGapMs(heavy: boolean): number;
+//# sourceMappingURL=hitStop.d.ts.map

package/dist/types/fx/hitStop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitStop.d.ts","sourceRoot":"","sources":["../../../src/fx/hitStop.ts"],"names":[],"mappings":"AAMA,sHAAsH;AACtH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAG9D;AAED,wHAAwH;AACxH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAG7E;AAED,mDAAmD;AACnD,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAIpF;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAErD"}