1681-engine 0.0.0-stage → 0.5.9

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,96 @@
+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';
+    /**
+     * Pause simulating and drawing while the page is hidden (another tab, the phone's home screen) and resume when it
+     * is shown, with no catch-up burst of steps (default false). A pause the game made itself is left alone.
+     */
+    pauseWhenHidden?: boolean;
+    /**
+     * Mirror the system's "reduce motion" setting into `engineSettings.reducedFx`, now and on every change (default
+     * false). Leave it off when the game has its own reduced-effects toggle and mirrors that instead.
+     */
+    followReducedMotion?: boolean;
+}
+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;
+    /** Pauses through the loop's own switch, so a hidden tab never counts as the game's own pause (`forget`). */
+    private readonly hiddenPause;
+    private readonly unwatch;
+    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;
+    private makeHiddenPause;
+    private pauseLoop;
+    private resumeLoop;
+    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;AAE9C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,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;IAChC;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;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;IAaf,QAAQ,CAAC,GAAG,EAAE,WAAW;IAZ3B,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,6GAA6G;IAC7G,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0B;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2D;IAElF,OAAO;WAmBM,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;IAKb,MAAM,IAAI,IAAI;IAKd,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU;IASlB,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;IAY9B,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/HiddenPause.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pauses a loop while the page is hidden and resumes it when it comes back — but only if it was the one that paused
+ * it: a game paused by its own menu stays paused when the tab returns. Pure (the page's visibility comes in through
+ * `hidden`/`shown`), so the rule is tested under node; `watchVisibility` wires it to the document.
+ */
+export interface Pausable {
+    readonly paused: boolean;
+    pause(): void;
+    resume(): void;
+}
+export declare class HiddenPause {
+    private readonly target;
+    private pausedByUs;
+    constructor(target: Pausable);
+    hidden(): void;
+    shown(): void;
+    /** The game paused or resumed it itself: whatever happens next is its choice, not ours to undo. */
+    forget(): void;
+    /** Listens to `visibilitychange` on `doc`; returns the unsubscribe. A no-op without a document. */
+    watch(doc?: Pick<Document, 'visibilityState' | 'addEventListener' | 'removeEventListener'> | null): () => void;
+}
+//# sourceMappingURL=HiddenPause.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HiddenPause.d.ts","sourceRoot":"","sources":["../../../src/engine/HiddenPause.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,WAAW;IAGV,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,UAAU,CAAS;gBAEE,MAAM,EAAE,QAAQ;IAE7C,MAAM,IAAI,IAAI;IAMd,KAAK,IAAI,IAAI;IAOb,mGAAmG;IACnG,MAAM,IAAI,IAAI;IAId,mGAAmG;IACnG,KAAK,CAAC,GAAG,GAAE,IAAI,CAAC,QAAQ,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,qBAAqB,CAAC,GAAG,IAAwD,GAAG,MAAM,IAAI;CAOlK"}

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

@@ -0,0 +1,62 @@
+import type { BLEND_MODES } from 'pixi.js';
+import type { Image } from '../core/Image.js';
+import type { Stage } from '../core/Stage.js';
+export interface AfterimagesOptions {
+    /** Colours the copies wear, cycled one per copy (default white): a trail shimmering from white to blue, say. */
+    tints?: readonly number[];
+    /** Opacity a copy starts at (default 0.6). */
+    alpha?: number;
+    /** How long a copy takes to fade out, ms (default 260). */
+    durationMs?: number;
+    /** The least time between two copies, ms (default 22: a copy every frame or so at 60 fps without doubling up). */
+    spacingMs?: number;
+    /** The scale a copy shrinks to as it fades, a share of the body's (default 0.85; 1 keeps it). */
+    endScale?: number;
+    /** How copies blend (default `'add'`: light; `'normal'` for painted shadows). */
+    blend?: BLEND_MODES;
+    /**
+     * Copies of a live body (one repainted every frame) are kept in a ring of this many textures, reused, and spent
+     * copies are pooled up to this many (default 16: at 22 ms apart and 260 ms each, never all in use at once).
+     */
+    slots?: number;
+}
+/**
+ * Afterimages of a moving body — a dash, a blink, a quick step: copies of its current frame left behind as flat
+ * silhouettes in a tint, fading out. A copy is its frame's cached solid silhouette (`solidSilhouette`) tinted, not a
+ * fill filter, so a trail costs no render pass per copy; copies are pooled rather than made every few ms, and a live
+ * body's frames are snapshotted into a fixed ring of textures instead of a new canvas each time.
+ */
+export declare class Afterimages {
+    private readonly stage;
+    private readonly tints;
+    private readonly alpha;
+    private readonly durationMs;
+    private readonly spacingMs;
+    private readonly endScale;
+    private readonly blend;
+    private readonly slots;
+    private readonly prefix;
+    /** The copy wearing each ring slot's texture: it goes before its texture is painted over. */
+    private readonly slotUsers;
+    private slot;
+    private readonly fading;
+    private readonly free;
+    private lastAt;
+    private count;
+    constructor(stage: Stage, options?: AfterimagesOptions);
+    /**
+     * Leaves a copy of `body` as drawn now, standing at world (x, y) with draw order `depth` (default just behind a
+     * body sorted by `y`), unless one was left less than `spacingMs` before `now`. Answers the copy, or null when none
+     * was laid (too soon, or the frame could not be read): a caller drawing its own speed streaks between copies
+     * follows that.
+     */
+    trail(body: Image, x: number, y: number, now: number, depth?: number): Image | null;
+    /** Copies still fading. */
+    get active(): number;
+    private copyOf;
+    /** A faded copy: hidden and kept for the next one (a ring slot's copy stays with its slot). */
+    private spend;
+    /** Takes every copy off the stage and frees the ring's textures. */
+    destroy(): void;
+}
+//# sourceMappingURL=Afterimages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Afterimages.d.ts","sourceRoot":"","sources":["../../../src/fx/Afterimages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,MAAM,WAAW,kBAAkB;IACjC,gHAAgH;IAChH,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kHAAkH;IAClH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID;;;;;GAKG;AACH,qBAAa,WAAW;IAkBpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjBxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;IAC1D,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,KAAK,CAAK;gBAGC,KAAK,EAAE,KAAK,EAC7B,OAAO,GAAE,kBAAuB;IAWlC;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,SAAQ,GAAG,KAAK,GAAG,IAAI;IA2BlF,2BAA2B;IAC3B,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,OAAO,CAAC,MAAM;IA6Bd,+FAA+F;IAC/F,OAAO,CAAC,KAAK;IASb,oEAAoE;IACpE,OAAO,IAAI,IAAI;CAYhB"}