@oasys/oecs 0.3.1 → 0.5.0

package/dist/core/ecs/event.d.ts

@@ -0,0 +1,79 @@
+import { Brand } from '../../type_primitives/index.js';
+export type EventID = Brand<number, "event_id">;
+export declare const asEventId: (value: number) => EventID;
+/** Event schema: field name → value type. Every value is a number at
+ * runtime; the declared type may be a branded number (e.g. `EntityID`)
+ * so the brand survives the emit → read round trip at the type layer.
+ * This is the erased/default schema type; the public surfaces constrain
+ * on `EventShape<S>` (below) instead, so schemas may be declared as type
+ * literals OR interfaces — an interface lacks the implicit index
+ * signature literals get (and so isn't assignable to this `Record`
+ * alias), but satisfies the homomorphic `EventShape` check. */
+export type EventSchema = Readonly<Record<string, number>>;
+/**
+ * Homomorphic constraint for event-schema type params (POLISH_AUDIT M9):
+ * `S extends EventShape<S>` checks every property of `S` is a number WITHOUT
+ * requiring an index signature, so `interface`-declared schemas (which lack
+ * the implicit index signature type literals get) are accepted too.
+ */
+export type EventShape<S> = {
+    readonly [K in keyof S]: number;
+};
+/** Schema of a signal — a zero-field event. */
+export type EmptyEventSchema = Readonly<Record<never, number>>;
+declare const __eventSchema: unique symbol;
+export type EventDef<S extends EventShape<S> = EventSchema> = EventID & {
+    readonly [__eventSchema]: (value: S) => S;
+};
+/**
+ * Reader view over an event channel's SoA columns. Columns are read-only
+ * arrays typed per the event schema: consumers index them and read
+ * `.length`. A field declared as a branded number (e.g. `EntityID`) reads
+ * back branded — no cast at the consumer.
+ *
+ * The "cannot mutate the live channel through the reader" property is
+ * **advisory** — the columns are the same live `number[]` objects the channel
+ * mutates (see `EventChannel` below), so the `readonly` typing blocks writes
+ * at the type layer only; a §10c-policed cast can still write through.
+ */
+export type EventReader<S extends EventShape<S>> = {
+    readonly length: number;
+} & {
+    readonly [K in keyof S]: ReadonlyArray<S[K]>;
+};
+export declare class EventChannel {
+    readonly fieldNames: string[];
+    readonly columns: number[][];
+    readonly reader: EventReader<any>;
+    private readonly _readerLen;
+    constructor(fieldNames: string[]);
+    emit(values: Record<string, number>): void;
+    /** Emit a signal (zero-field event). */
+    emitSignal(): void;
+    clear(): void;
+}
+declare const __eventKeySchema: unique symbol;
+export type EventKey<S extends EventShape<S> = EventSchema> = symbol & {
+    readonly [__eventKeySchema]: (value: S) => S;
+};
+declare const __signalKey: unique symbol;
+export type SignalKey = EventKey<EmptyEventSchema> & {
+    readonly [__signalKey]: true;
+};
+/**
+ * Compile-time exact-cover check for `registerEvent`'s `fields` list. The
+ * element type (`keyof S & string`) already rejects foreign fields; this
+ * catches the inverse mistake — an UNDER-registered channel. Registering
+ * `eventKey<{a; b}>` with `["a"]` used to compile, but `emit` requires the
+ * full payload while the channel only has an `a` column, so `b` was silently
+ * dropped and `reader.b` (typed as an array) was `undefined` at runtime.
+ * Resolves to `unknown` (intersection no-op) when `F` covers every key, and
+ * to an impossible tuple naming the missing fields otherwise. A schema with a
+ * string index signature (erased/untyped keys) skips the check — there is no
+ * finite key set to cover.
+ */
+export type EventFieldsCover<S extends EventShape<S>, F extends readonly (keyof S & string)[]> = string extends keyof S ? unknown : Exclude<keyof S & string, F[number]> extends never ? unknown : readonly [`ERROR — missing event field: ${Exclude<keyof S & string, F[number]>}`];
+export declare function eventKey<S extends EventShape<S>>(name: string): EventKey<S>;
+export declare function signalKey(name: string): SignalKey;
+export {};
+//# sourceMappingURL=event.d.ts.map

package/dist/core/ecs/event.d.ts.map

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

package/dist/core/ecs/event_registry.d.cts

@@ -0,0 +1,22 @@
+import { EmptyEventSchema, EventDef, EventReader, EventShape } from './event.cjs';
+export declare class EventRegistry {
+    private readonly channels;
+    private readonly dirtyChannels;
+    private count;
+    private readonly keyMap;
+    registerEvent<S extends EventShape<S>>(fields: readonly (keyof S & string)[]): EventDef<S>;
+    emitEvent(def: EventDef<any>, values: Record<string, number>): void;
+    emitSignal(def: EventDef<EmptyEventSchema>): void;
+    getEventReader<S extends EventShape<S>>(def: EventDef<S>): EventReader<S>;
+    clearEvents(): void;
+    /** `DEV`-only: total events currently buffered across the dirty channels.
+     * `ECS.update` samples this either side of `dispatchSet` to assert an onSet
+     * observer emitted nothing — its emissions would be wiped by the tick-tail
+     * `clearEvents` and break the empty-channel-at-boundary invariant snapshot /
+     * restore relies on (#586). Walks only the dirty list, never the hot emit path. */
+    devBufferedEventCount(): number;
+    registerEventByKey<S extends EventShape<S>>(key: symbol, fields: readonly (keyof S & string)[]): EventDef<S>;
+    getEventDefByKey(key: symbol): EventDef<any>;
+    hasEventKey(key: symbol): boolean;
+}
+//# sourceMappingURL=event_registry.d.ts.map

package/dist/core/ecs/event_registry.d.ts

@@ -0,0 +1,22 @@
+import { EmptyEventSchema, EventDef, EventReader, EventShape } from './event.js';
+export declare class EventRegistry {
+    private readonly channels;
+    private readonly dirtyChannels;
+    private count;
+    private readonly keyMap;
+    registerEvent<S extends EventShape<S>>(fields: readonly (keyof S & string)[]): EventDef<S>;
+    emitEvent(def: EventDef<any>, values: Record<string, number>): void;
+    emitSignal(def: EventDef<EmptyEventSchema>): void;
+    getEventReader<S extends EventShape<S>>(def: EventDef<S>): EventReader<S>;
+    clearEvents(): void;
+    /** `DEV`-only: total events currently buffered across the dirty channels.
+     * `ECS.update` samples this either side of `dispatchSet` to assert an onSet
+     * observer emitted nothing — its emissions would be wiped by the tick-tail
+     * `clearEvents` and break the empty-channel-at-boundary invariant snapshot /
+     * restore relies on (#586). Walks only the dirty list, never the hot emit path. */
+    devBufferedEventCount(): number;
+    registerEventByKey<S extends EventShape<S>>(key: symbol, fields: readonly (keyof S & string)[]): EventDef<S>;
+    getEventDefByKey(key: symbol): EventDef<any>;
+    hasEventKey(key: symbol): boolean;
+}
+//# sourceMappingURL=event_registry.d.ts.map

package/dist/core/ecs/event_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_registry.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/event_registry.ts"],"names":[],"mappings":"AAAA;;;;;;;KAOK;AAGL,OAAO,EAGN,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,MAAM,SAAS,CAAC;AAGjB,qBAAa,aAAa;IAEzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAK/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,KAAK,CAAK;IAIlB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAEzD,aAAa,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAC3C,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,GACnC,QAAQ,CAAC,CAAC,CAAC;IAOP,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAYnE,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAQjD,cAAc,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAIzE,WAAW,IAAI,IAAI;IAS1B;;;;uFAImF;IAC5E,qBAAqB,IAAI,MAAM;IAQ/B,kBAAkB,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAChD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,GACnC,QAAQ,CAAC,CAAC,CAAC;IAcP,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC;IAY5C,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAGxC"}

package/dist/core/ecs/facades.d.cts

@@ -0,0 +1,158 @@
+import { Store } from './store.cjs';
+import { EntityID } from './entity.cjs';
+import { OnDeleteTarget, RelationDef, RelationOptions } from './relation.cjs';
+import { ResourceKey } from './resource.cjs';
+import { EventFieldsCover, EventKey, EventReader, EventShape, SignalKey } from './event.cjs';
+/** Relations — sparse `(relation, target)` pairs and hierarchy traversal
+ * (#471 / #474, ADR-0011). Add/remove/re-target cause no archetype
+ * transition; ops are immediate and safe mid-tick. Traversal and wildcard
+ * reads are cold-path. */
+export declare class ECSRelations {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Register a relation kind. Exclusive (default) stores one target per
+     * source; `{ multi: true }` stores a target set per source.
+     * `{ onDeleteTarget: "delete" | "clear" | "orphan" }` selects target-death
+     * cleanup (default `orphan`, #473).
+     *
+     * The overloads stamp the CARDINALITY into the handle type (typestate
+     * a173382 / POLISH_AUDIT #7), exactly like the flat `registerRelation`:
+     * the exclusive-only surfaces (`targetOf`, `ancestorsOf`/`rootOf`/
+     * `cascadeOf`, `Query.hierarchy`) accept only `RelationDef<"exclusive">`,
+     * so passing a `{ multi: true }` relation is a compile error. A
+     * dynamically-built options value falls to the erased overload and keeps
+     * the runtime check as its only guard. */
+    register(opts?: {
+        readonly exclusive?: true;
+        readonly multi?: false;
+        readonly onDeleteTarget?: OnDeleteTarget;
+    }): RelationDef<"exclusive">;
+    register(opts: {
+        readonly multi: true;
+        readonly exclusive?: false;
+        readonly onDeleteTarget?: OnDeleteTarget;
+    }): RelationDef<"multi">;
+    register(opts?: RelationOptions): RelationDef;
+    /** Count of registered relations. */
+    get count(): number;
+    /** Add a `(R, tgt)` pair to `src`. Exclusive replaces the existing target;
+     * multi adds to the set. No archetype transition. */
+    add(src: EntityID, def: RelationDef, tgt: EntityID): this;
+    /** Remove a `(R, tgt)` pair from `src`. For multi, omitting `tgt` removes
+     * all of `src`'s targets. No archetype transition. */
+    remove(src: EntityID, def: RelationDef, tgt?: EntityID): this;
+    /** Whether `src` holds any pair under `R`. */
+    has(src: EntityID, def: RelationDef): boolean;
+    /** The single target of `src` under an exclusive relation, or `undefined`. */
+    targetOf(src: EntityID, def: RelationDef<"exclusive">): EntityID | undefined;
+    /** All targets of `src` under `R`, ascending by id. */
+    targetsOf(src: EntityID, def: RelationDef): EntityID[];
+    /** Sources pointing at `tgt` under `R` (the reverse index), ascending by id.
+     * `(entity, def)` order, matching `targetOf` / `targetsOf`. */
+    sourcesOf(tgt: EntityID, def: RelationDef): EntityID[];
+    /** All `(source, target)` pairs of relation `R` — the `(R, *)` wildcard
+     * (#472). Sources in canonical entity-index order. Cold path. */
+    pairsOf(def: RelationDef): readonly (readonly [EntityID, EntityID])[];
+    /** Every `(relation, source)` pointing at `tgt`, across all relation kinds —
+     * the `(*, T)` wildcard (#472). Ordered by relation id then source id. */
+    sourcesOfAny(tgt: EntityID): readonly (readonly [RelationDef, EntityID])[];
+    /** Walk relation `R` up from `src` to its chain root, returning
+     * `[src, parent, …, root]` (nearest-ancestor-first). Exclusive only. */
+    ancestorsOf(src: EntityID, def: RelationDef<"exclusive">): EntityID[];
+    /** The root of `src`'s `R`-chain (`src` itself when it has no target).
+     * Exclusive only. */
+    rootOf(src: EntityID, def: RelationDef<"exclusive">): EntityID;
+    /** Walk relation `R` down from `root` over the reverse index, returning the
+     * subtree (including `root`) breadth-first — parents before children (the
+     * `cascade` order). Exclusive only. */
+    cascadeOf(root: EntityID, def: RelationDef<"exclusive">): EntityID[];
+    /** Reclaim relation reverse-index memory: drop every reverse entry whose
+     * target has been destroyed, returning the total dropped (#491). Purely
+     * cold-path, no observable state change — call at scene/snapshot
+     * boundaries. */
+    compact(): number;
+}
+/** Event channels and signals. Emit during one `update()`, visible to every
+ * later system in that call, cleared before the next. System-side reads and
+ * emits go through `ctx` — this facade is the HOST-side surface. */
+export declare class ECSEvents {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Register an event channel at world setup, before anything emits on it.
+     * `fields` must name EVERY schema key — an under-registered channel would
+     * silently drop the missing fields at emit (see `EventFieldsCover`).
+     *
+     * @example
+     * const Damaged = eventKey<{ target: EntityID; amount: number }>("Damaged");
+     * ecs.events.register(Damaged, ["target", "amount"]);
+     * ecs.events.emit(Damaged, { target: e, amount: 10 }); // or ctx.emit inside a system
+     */
+    register<S extends EventShape<S>, const F extends readonly (keyof S & string)[]>(key: EventKey<S>, fields: F & EventFieldsCover<S, F>): void;
+    /** Register a signal (empty-payload event channel). */
+    registerSignal(key: SignalKey): void;
+    emit(key: SignalKey): void;
+    emit<S extends EventShape<S>>(key: EventKey<S>, values: NoInfer<S>): void;
+    read<S extends EventShape<S>>(key: EventKey<S>): EventReader<S>;
+}
+/** World resources — singleton values keyed by `ResourceKey<T>`. Runtime
+ * mutations (`set` / `remove`) are access-checked as resource writes inside
+ * a system span; `register` is a one-time world-setup op. */
+export declare class ECSResources {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Register a resource at world setup. Reading/writing an unregistered
+     * key throws (fail-closed) — registration is the explicit "this world has
+     * this singleton" declaration, not a lazy default.
+     *
+     * @example
+     * const GameTime = resourceKey<{ elapsed: number }>("GameTime");
+     * ecs.resources.register(GameTime, { elapsed: 0 });
+     * ecs.resources.get(GameTime).elapsed; // or ctx.resource(GameTime) inside a system
+     */
+    register<T>(key: ResourceKey<T>, value: NoInfer<T>): void;
+    get<T>(key: ResourceKey<T>): T;
+    set<T>(key: ResourceKey<T>, value: NoInfer<T>): void;
+    /** Drop a resource from the world (#798). Access-checked as a *write*;
+     * fails closed on a missing key. Afterwards the key is free to `register`
+     * again — the present → absent → present lifecycle. */
+    remove<T>(key: ResourceKey<T>): void;
+    has<T>(key: ResourceKey<T>): boolean;
+}
+/** The determinism surface (#626 / ADR-0020): world snapshot/resume and the
+ * canonical state digest. Every member except `deterministic` throws
+ * `DETERMINISM_DISABLED` unless the world was constructed with
+ * `{ deterministic: true }`. All cold-path — take captures at tick
+ * boundaries (between `update()`s). */
+export declare class ECSSnapshots {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Whether the determinism surface is enabled. */
+    get deterministic(): boolean;
+    /** FNV-1a 32 digest over every archetype's live rows in id order — the
+     * canonical "live ECS state digest". Per-call cost scales with live
+     * entity count, not SAB capacity. */
+    stateHash(): number;
+    /** Capture the full live world (dense + sparse/relations + host-side
+     * bookkeeping) to one self-contained byte buffer that `restore` can mount
+     * back onto a live, ticking world (#789). v1 does NOT capture resources,
+     * events, or change-detection baselines (ADR-0031). */
+    capture(): Uint8Array;
+    /** Mount a `capture()` buffer onto this live world and keep ticking.
+     * Fails closed on a malformed frame or registration mismatch BEFORE
+     * mutating any live state. Requires a matching archetype set + column
+     * layout (prewarm so the set is stable). */
+    restore(bytes: Uint8Array): void;
+    /** Serialize the sparse stores + relations to a self-contained buffer —
+     * the sparse half of a world snapshot, canonical entity-index order
+     * (#470). Pairs with `restoreSparse`. */
+    captureSparse(): Uint8Array;
+    /** Repopulate the sparse stores + relation indices from `captureSparse`
+     * bytes. Sparse components must already be registered in the same order;
+     * throws `SparseRestoreError` on a shape or identity mismatch. */
+    restoreSparse(bytes: Uint8Array): void;
+}
+//# sourceMappingURL=facades.d.ts.map

package/dist/core/ecs/facades.d.ts

@@ -0,0 +1,158 @@
+import { Store } from './store.js';
+import { EntityID } from './entity.js';
+import { OnDeleteTarget, RelationDef, RelationOptions } from './relation.js';
+import { ResourceKey } from './resource.js';
+import { EventFieldsCover, EventKey, EventReader, EventShape, SignalKey } from './event.js';
+/** Relations — sparse `(relation, target)` pairs and hierarchy traversal
+ * (#471 / #474, ADR-0011). Add/remove/re-target cause no archetype
+ * transition; ops are immediate and safe mid-tick. Traversal and wildcard
+ * reads are cold-path. */
+export declare class ECSRelations {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Register a relation kind. Exclusive (default) stores one target per
+     * source; `{ multi: true }` stores a target set per source.
+     * `{ onDeleteTarget: "delete" | "clear" | "orphan" }` selects target-death
+     * cleanup (default `orphan`, #473).
+     *
+     * The overloads stamp the CARDINALITY into the handle type (typestate
+     * a173382 / POLISH_AUDIT #7), exactly like the flat `registerRelation`:
+     * the exclusive-only surfaces (`targetOf`, `ancestorsOf`/`rootOf`/
+     * `cascadeOf`, `Query.hierarchy`) accept only `RelationDef<"exclusive">`,
+     * so passing a `{ multi: true }` relation is a compile error. A
+     * dynamically-built options value falls to the erased overload and keeps
+     * the runtime check as its only guard. */
+    register(opts?: {
+        readonly exclusive?: true;
+        readonly multi?: false;
+        readonly onDeleteTarget?: OnDeleteTarget;
+    }): RelationDef<"exclusive">;
+    register(opts: {
+        readonly multi: true;
+        readonly exclusive?: false;
+        readonly onDeleteTarget?: OnDeleteTarget;
+    }): RelationDef<"multi">;
+    register(opts?: RelationOptions): RelationDef;
+    /** Count of registered relations. */
+    get count(): number;
+    /** Add a `(R, tgt)` pair to `src`. Exclusive replaces the existing target;
+     * multi adds to the set. No archetype transition. */
+    add(src: EntityID, def: RelationDef, tgt: EntityID): this;
+    /** Remove a `(R, tgt)` pair from `src`. For multi, omitting `tgt` removes
+     * all of `src`'s targets. No archetype transition. */
+    remove(src: EntityID, def: RelationDef, tgt?: EntityID): this;
+    /** Whether `src` holds any pair under `R`. */
+    has(src: EntityID, def: RelationDef): boolean;
+    /** The single target of `src` under an exclusive relation, or `undefined`. */
+    targetOf(src: EntityID, def: RelationDef<"exclusive">): EntityID | undefined;
+    /** All targets of `src` under `R`, ascending by id. */
+    targetsOf(src: EntityID, def: RelationDef): EntityID[];
+    /** Sources pointing at `tgt` under `R` (the reverse index), ascending by id.
+     * `(entity, def)` order, matching `targetOf` / `targetsOf`. */
+    sourcesOf(tgt: EntityID, def: RelationDef): EntityID[];
+    /** All `(source, target)` pairs of relation `R` — the `(R, *)` wildcard
+     * (#472). Sources in canonical entity-index order. Cold path. */
+    pairsOf(def: RelationDef): readonly (readonly [EntityID, EntityID])[];
+    /** Every `(relation, source)` pointing at `tgt`, across all relation kinds —
+     * the `(*, T)` wildcard (#472). Ordered by relation id then source id. */
+    sourcesOfAny(tgt: EntityID): readonly (readonly [RelationDef, EntityID])[];
+    /** Walk relation `R` up from `src` to its chain root, returning
+     * `[src, parent, …, root]` (nearest-ancestor-first). Exclusive only. */
+    ancestorsOf(src: EntityID, def: RelationDef<"exclusive">): EntityID[];
+    /** The root of `src`'s `R`-chain (`src` itself when it has no target).
+     * Exclusive only. */
+    rootOf(src: EntityID, def: RelationDef<"exclusive">): EntityID;
+    /** Walk relation `R` down from `root` over the reverse index, returning the
+     * subtree (including `root`) breadth-first — parents before children (the
+     * `cascade` order). Exclusive only. */
+    cascadeOf(root: EntityID, def: RelationDef<"exclusive">): EntityID[];
+    /** Reclaim relation reverse-index memory: drop every reverse entry whose
+     * target has been destroyed, returning the total dropped (#491). Purely
+     * cold-path, no observable state change — call at scene/snapshot
+     * boundaries. */
+    compact(): number;
+}
+/** Event channels and signals. Emit during one `update()`, visible to every
+ * later system in that call, cleared before the next. System-side reads and
+ * emits go through `ctx` — this facade is the HOST-side surface. */
+export declare class ECSEvents {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Register an event channel at world setup, before anything emits on it.
+     * `fields` must name EVERY schema key — an under-registered channel would
+     * silently drop the missing fields at emit (see `EventFieldsCover`).
+     *
+     * @example
+     * const Damaged = eventKey<{ target: EntityID; amount: number }>("Damaged");
+     * ecs.events.register(Damaged, ["target", "amount"]);
+     * ecs.events.emit(Damaged, { target: e, amount: 10 }); // or ctx.emit inside a system
+     */
+    register<S extends EventShape<S>, const F extends readonly (keyof S & string)[]>(key: EventKey<S>, fields: F & EventFieldsCover<S, F>): void;
+    /** Register a signal (empty-payload event channel). */
+    registerSignal(key: SignalKey): void;
+    emit(key: SignalKey): void;
+    emit<S extends EventShape<S>>(key: EventKey<S>, values: NoInfer<S>): void;
+    read<S extends EventShape<S>>(key: EventKey<S>): EventReader<S>;
+}
+/** World resources — singleton values keyed by `ResourceKey<T>`. Runtime
+ * mutations (`set` / `remove`) are access-checked as resource writes inside
+ * a system span; `register` is a one-time world-setup op. */
+export declare class ECSResources {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Register a resource at world setup. Reading/writing an unregistered
+     * key throws (fail-closed) — registration is the explicit "this world has
+     * this singleton" declaration, not a lazy default.
+     *
+     * @example
+     * const GameTime = resourceKey<{ elapsed: number }>("GameTime");
+     * ecs.resources.register(GameTime, { elapsed: 0 });
+     * ecs.resources.get(GameTime).elapsed; // or ctx.resource(GameTime) inside a system
+     */
+    register<T>(key: ResourceKey<T>, value: NoInfer<T>): void;
+    get<T>(key: ResourceKey<T>): T;
+    set<T>(key: ResourceKey<T>, value: NoInfer<T>): void;
+    /** Drop a resource from the world (#798). Access-checked as a *write*;
+     * fails closed on a missing key. Afterwards the key is free to `register`
+     * again — the present → absent → present lifecycle. */
+    remove<T>(key: ResourceKey<T>): void;
+    has<T>(key: ResourceKey<T>): boolean;
+}
+/** The determinism surface (#626 / ADR-0020): world snapshot/resume and the
+ * canonical state digest. Every member except `deterministic` throws
+ * `DETERMINISM_DISABLED` unless the world was constructed with
+ * `{ deterministic: true }`. All cold-path — take captures at tick
+ * boundaries (between `update()`s). */
+export declare class ECSSnapshots {
+    private readonly store;
+    /** @internal constructed by `ECS`. */
+    constructor(store: Store);
+    /** Whether the determinism surface is enabled. */
+    get deterministic(): boolean;
+    /** FNV-1a 32 digest over every archetype's live rows in id order — the
+     * canonical "live ECS state digest". Per-call cost scales with live
+     * entity count, not SAB capacity. */
+    stateHash(): number;
+    /** Capture the full live world (dense + sparse/relations + host-side
+     * bookkeeping) to one self-contained byte buffer that `restore` can mount
+     * back onto a live, ticking world (#789). v1 does NOT capture resources,
+     * events, or change-detection baselines (ADR-0031). */
+    capture(): Uint8Array;
+    /** Mount a `capture()` buffer onto this live world and keep ticking.
+     * Fails closed on a malformed frame or registration mismatch BEFORE
+     * mutating any live state. Requires a matching archetype set + column
+     * layout (prewarm so the set is stable). */
+    restore(bytes: Uint8Array): void;
+    /** Serialize the sparse stores + relations to a self-contained buffer —
+     * the sparse half of a world snapshot, canonical entity-index order
+     * (#470). Pairs with `restoreSparse`. */
+    captureSparse(): Uint8Array;
+    /** Repopulate the sparse stores + relation indices from `captureSparse`
+     * bytes. Sparse components must already be registered in the same order;
+     * throws `SparseRestoreError` on a shape or identity mismatch. */
+    restoreSparse(bytes: Uint8Array): void;
+}
+//# sourceMappingURL=facades.d.ts.map

package/dist/core/ecs/facades.d.ts.map

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

package/dist/core/ecs/frame_stepper.d.cts

@@ -0,0 +1,58 @@
+import { ECS } from './ecs.cjs';
+type FrameCallback = (timestampMs: number) => void;
+type RequestFrame = (callback: FrameCallback) => number;
+type CancelFrame = (handle: number) => void;
+export interface FrameStepperOptions {
+    /** Delta used by `step()` when no dt is supplied, in seconds. Default 1/60. */
+    readonly fixedDt?: number;
+    /** Clamp browser-frame deltas before forwarding them to `ECS.update()`, in
+     * seconds. Default 0.25. A backgrounded tab suspends rAF; the first frame
+     * after it resumes carries the whole suspended interval as one delta, and
+     * without the clamp that lands in `update()`'s accumulator as a giant
+     * catch-up burst (bounded by `maxFixedSteps`, but still a burst). Manual
+     * `step()` deltas are deliberately not clamped — an explicit dt is trusted. */
+    readonly maxDt?: number;
+    /** Dependency injection for tests or non-browser hosts. Defaults to `requestAnimationFrame`. */
+    readonly requestFrame?: RequestFrame;
+    /** Dependency injection for tests or non-browser hosts. Defaults to `cancelAnimationFrame`. */
+    readonly cancelFrame?: CancelFrame;
+    /** Start the automatic frame loop immediately. */
+    readonly autoStart?: boolean;
+}
+/**
+ * Small host-side controller for manual ECS frame stepping.
+ *
+ * `ECS.update(dt)` is already the authoritative "run one frame" primitive.
+ * This class wraps it with pause/play controls for browser loops and an explicit
+ * `step()` method for debuggers, tests, editor tools, and rollback playback.
+ */
+export declare class FrameStepper {
+    private readonly ecs;
+    private readonly requestFrame?;
+    private readonly cancelFrame?;
+    private frameHandle;
+    private lastTimestampMs;
+    private running;
+    private _fixedDt;
+    private _maxDt;
+    constructor(ecs: ECS, options?: FrameStepperOptions);
+    get fixedDt(): number;
+    set fixedDt(value: number);
+    get maxDt(): number;
+    set maxDt(value: number);
+    get isRunning(): boolean;
+    /** Advance exactly one ECS frame. */
+    step(dt?: number): void;
+    /** Advance several fixed-size frames, useful for replaying a paused sim. */
+    stepFrames(count: number, dt?: number): void;
+    /** Start ticking with `requestAnimationFrame`; no-op when already running. */
+    play(): void;
+    /** Stop the automatic frame loop. Manual `step()` still works while paused. */
+    pause(): void;
+    toggle(): void;
+    dispose(): void;
+    private scheduleNextFrame;
+    private readonly onFrame;
+}
+export {};
+//# sourceMappingURL=frame_stepper.d.ts.map

package/dist/core/ecs/frame_stepper.d.ts

@@ -0,0 +1,58 @@
+import { ECS } from './ecs.js';
+type FrameCallback = (timestampMs: number) => void;
+type RequestFrame = (callback: FrameCallback) => number;
+type CancelFrame = (handle: number) => void;
+export interface FrameStepperOptions {
+    /** Delta used by `step()` when no dt is supplied, in seconds. Default 1/60. */
+    readonly fixedDt?: number;
+    /** Clamp browser-frame deltas before forwarding them to `ECS.update()`, in
+     * seconds. Default 0.25. A backgrounded tab suspends rAF; the first frame
+     * after it resumes carries the whole suspended interval as one delta, and
+     * without the clamp that lands in `update()`'s accumulator as a giant
+     * catch-up burst (bounded by `maxFixedSteps`, but still a burst). Manual
+     * `step()` deltas are deliberately not clamped — an explicit dt is trusted. */
+    readonly maxDt?: number;
+    /** Dependency injection for tests or non-browser hosts. Defaults to `requestAnimationFrame`. */
+    readonly requestFrame?: RequestFrame;
+    /** Dependency injection for tests or non-browser hosts. Defaults to `cancelAnimationFrame`. */
+    readonly cancelFrame?: CancelFrame;
+    /** Start the automatic frame loop immediately. */
+    readonly autoStart?: boolean;
+}
+/**
+ * Small host-side controller for manual ECS frame stepping.
+ *
+ * `ECS.update(dt)` is already the authoritative "run one frame" primitive.
+ * This class wraps it with pause/play controls for browser loops and an explicit
+ * `step()` method for debuggers, tests, editor tools, and rollback playback.
+ */
+export declare class FrameStepper {
+    private readonly ecs;
+    private readonly requestFrame?;
+    private readonly cancelFrame?;
+    private frameHandle;
+    private lastTimestampMs;
+    private running;
+    private _fixedDt;
+    private _maxDt;
+    constructor(ecs: ECS, options?: FrameStepperOptions);
+    get fixedDt(): number;
+    set fixedDt(value: number);
+    get maxDt(): number;
+    set maxDt(value: number);
+    get isRunning(): boolean;
+    /** Advance exactly one ECS frame. */
+    step(dt?: number): void;
+    /** Advance several fixed-size frames, useful for replaying a paused sim. */
+    stepFrames(count: number, dt?: number): void;
+    /** Start ticking with `requestAnimationFrame`; no-op when already running. */
+    play(): void;
+    /** Stop the automatic frame loop. Manual `step()` still works while paused. */
+    pause(): void;
+    toggle(): void;
+    dispose(): void;
+    private scheduleNextFrame;
+    private readonly onFrame;
+}
+export {};
+//# sourceMappingURL=frame_stepper.d.ts.map

package/dist/core/ecs/frame_stepper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame_stepper.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/frame_stepper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAGjC,KAAK,aAAa,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;AACnD,KAAK,YAAY,GAAG,CAAC,QAAQ,EAAE,aAAa,KAAK,MAAM,CAAC;AACxD,KAAK,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAM5C,MAAM,WAAW,mBAAmB;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;mFAK+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,+FAA+F;IAC/F,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC,kDAAkD;IAClD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC7B;AAsBD;;;;;;GAMG;AACH,qBAAa,YAAY;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAM;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAc;IAC3C,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAS;gBAEJ,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,mBAAwB;IAW9D,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,MAAM,EAE/B;IAED,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,EAE7B;IAED,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED,qCAAqC;IAC9B,IAAI,CAAC,EAAE,GAAE,MAAsB,GAAG,IAAI;IAI7C,4EAA4E;IACrE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAE,MAAsB,GAAG,IAAI;IAMlE,8EAA8E;IACvE,IAAI,IAAI,IAAI;IAanB,+EAA+E;IACxE,KAAK,IAAI,IAAI;IASb,MAAM,IAAI,IAAI;IAKd,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAQtB;CACF"}