@oasys/oecs 0.3.0 → 0.4.0

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

@@ -0,0 +1,533 @@
+import { Template, TemplateEntries, TemplateOverrides } from './store';
+import { FrameTraceSink } from './frame_trace';
+import { ObserverHandle, EntitySetObserverConfig, ArchetypeSetObserverConfig, StructuralObserverConfig } from './observer';
+import { ColumnStore, ColumnStoreRegionHandle, StoreRegionSpec } from '../store';
+import { SCHEDULE, SystemEntry, SystemSet, SystemSetConfig } from './schedule';
+import { Archetype, ArchetypeID } from './archetype';
+import { SystemContext, Query, QueryBuilder, ChangedQuery, QueryResolver } from './query';
+import { EntityID } from './entity';
+import { ComponentDef, ComponentSchema, FieldValues, BundleOrDef } from './component';
+import { SparseComponentDef, SparseComponentID } from './sparse_store';
+import { RelationDef, RelationOptions } from './relation';
+import { EventKey, EventReader, EventSchema, SignalKey } from './event';
+import { ResourceKey } from './resource';
+import { SystemFn, SystemConfig, SystemDescriptor } from './system';
+import { BitSet, TypedArrayTag } from '../../type_primitives';
+import { StoreLayoutListener } from './store_layout_listener';
+import { ComputeBackend } from './compute_backend';
+import { ResolvedECSMemory, ECSMemoryOptions } from './ecs_memory';
+export interface ECSOptions {
+    fixedTimestep?: number;
+    maxFixedSteps?: number;
+    /** How the world's memory is sized and backed (#682) — the single
+     * sizing surface, replacing the pre-release `initialCapacity` +
+     * `bufferAllocator` pair. Express intent through exactly one arm:
+     * `{ budget: { entities } }` (derive everything), `{ maxBytes }`
+     * (explicit cap), `{ wasm: { memory } | { maximumPages } }` (the SAB
+     * IS a WebAssembly.Memory — zero-copy with a WASM `ComputeBackend`), or
+     * `{ allocator }` (expert escape hatch, in-place-typed per ADR-0008).
+     * Omitted ⇒ growable backing with a 256 MiB cap and 1024-row columns.
+     * The resolved plan is exposed as `ECS.memoryPlan`. */
+    memory?: ECSMemoryOptions;
+    /** Consumer-declared SAB regions (#623), forwarded to `Store`. Each
+     * `StoreRegionSpec` carries an opaque `region_id`, a precomputed byte size,
+     * and an `init` closure; the engine lays them out generically and exposes
+     * them via `regionHandle(id)` / `regionOffset(id)`. A game (e.g.
+     * `@internal/sim`'s region specs) supplies these — the engine ships no
+     * game regions of its own. Replaces the eight game-named region options
+     * (`terrain_map_radius`, `spatial_grid_*`, `army_*`, `flow_field_*`,
+     * `actionRingCapacitySlots`) the ECS used to carry. (ADR-0018.) */
+    regions?: readonly StoreRegionSpec[];
+    /** Byte size of the opt-in sim-bindings region (#625), forwarded to `Store`.
+     * A consumer that attaches a WASM `ComputeBackend` passes its own size — for
+     * this game, `@internal/sim`'s `SIM_BINDINGS_BYTES` (computed from the binding
+     * manifest) — so the host can publish the `(component_id, field_id)` IDs the
+     * accelerated systems read. Omitted / 0 ⇒ no region: a pure-TS world pays
+     * nothing for the WASM seam. The size is a runtime input, not an engine ABI
+     * constant, since #625 de-welded it from the generated ABI. */
+    bindingsRegionBytes?: number;
+    /** Opt into the **determinism surface** (#626 / ADR-0020), forwarded to
+     * `Store`. Default `false`. When `false`, the canonical-ordering methods
+     * (`stateHash`, `snapshotSparse`, `restoreSparse`) throw
+     * `DETERMINISM_DISABLED`; when `true`, today's replay/hash behavior is
+     * reproduced bit-for-bit. Determinism is the implementer's choice — our
+     * server match opts in (replay verification), the client stays off (it rolls
+     * back via diffs, not re-sim). The flag gates ONLY that surface: memory-safety
+     * invariants (the in-place SAB allocator, ADR-0008) and the `enabled_count`
+     * partition are always-on regardless. */
+    deterministic?: boolean;
+}
+export declare class ECS implements QueryResolver {
+    private readonly store;
+    private readonly schedule;
+    private readonly ctx;
+    /** Component observers (#517 §1 / ADR-0013). Inert until `observe(...)` is
+     * called — the structural-flush fast path is byte-for-byte unchanged. */
+    private readonly _observers;
+    private readonly systems;
+    private nextSystemId;
+    private _tick;
+    private _fixedTimestep;
+    private _accumulator;
+    private _maxFixedSteps;
+    private readonly queryCache;
+    private readonly scratchMask;
+    private _nextQueryIdCounter;
+    readonly _andSingleCache: Map<number, Query<any>>;
+    readonly _notSingleCache: Map<number, Query<any>>;
+    readonly _anyOfSingleCache: Map<number, Query<any>>;
+    readonly _changedSingleCache: Map<number, ChangedQuery<any>>;
+    readonly _withSparseSingleCache: Map<number, Query<any>>;
+    readonly _withoutSparseSingleCache: Map<number, Query<any>>;
+    readonly _withRelationSingleCache: Map<number, Query<any>>;
+    readonly _withoutRelationSingleCache: Map<number, Query<any>>;
+    readonly _optionalSingleCache: Map<number, Query<any>>;
+    readonly _includeDisabledSingleCache: Map<number, Query<any>>;
+    readonly _hierarchySingleCache: Map<number, Query<any>>;
+    private readonly _layoutSubscribers;
+    private _backend;
+    private readonly _memory;
+    /** What `ECSOptions.memory` resolved to (#682): backing allocator kind,
+     * column capacity, entity-index reservation, byte cap, and a
+     * human-readable derivation trace. Diagnostics surface — log it when
+     * sizing questions come up instead of reverse-engineering the SAB. */
+    get memoryPlan(): ResolvedECSMemory;
+    /** The backing `WebAssembly.Memory` when `memory.wasm` was used (both
+     * bring-your-own and engine-constructed), else `null`. A consumer hands
+     * this to its WASM `ComputeBackend` so the sim and the live columns
+     * share the same bytes. */
+    get wasmMemory(): WebAssembly.Memory | null;
+    constructor(options?: ECSOptions);
+    /** Resolve a consumer-declared SAB region's byte offset by `region_id`, or
+     * 0 when absent. Generic, de-gamed replacement (#623) for the removed
+     * game-named accessors; pair with the consumer's own region module to
+     * materialise a typed view. Delegates to `Store.regionOffset`. */
+    regionOffset(regionId: number): number;
+    /** A handle (`{ buffer, view, offset, bytes }`) to a consumer-declared SAB
+     * region resolved by `region_id`, or `null` when absent. A consumer's
+     * region module builds a TypedArray view over the region's span from this.
+     * Re-fetch after a SAB grow. Delegates to `Store.regionHandle`. (#623) */
+    regionHandle(regionId: number): ColumnStoreRegionHandle | null;
+    /** Batch variant of `regionHandle` for hosts wiring several consumer
+     * regions at startup: returns the handles in argument order, never null —
+     * throws ONE `REGION_NOT_DECLARED` naming every missing region id instead
+     * of a null-guard per region. Same staleness rule as `regionHandle`:
+     * re-fetch after a SAB grow. */
+    regionHandles(...regionIds: number[]): ColumnStoreRegionHandle[];
+    /** Subscribe to SAB-layout publications. `listener.setLayout(0)` is
+     * called immediately to seed the initial layout, then again after
+     * every SAB grow / extend (the `view_stamp` republish protocol).
+     * Returns an unsubscribe function.
+     *
+     * The engine has no concept of what subscribes — it publishes SAB layouts
+     * and walks away. A consumer subscribes whatever wrapper it owns (a compute
+     * backend, a Worker proxy, a debug recorder) and drives it from its own
+     * code. A `ComputeBackend` is subscribed automatically by `attachBackend`,
+     * so most consumers call that rather than this directly. */
+    onStoreLayoutPublished(listener: StoreLayoutListener): () => void;
+    /** Attach an opt-in compute backend (#622). Default is none: a bare `ECS`
+     * runs pure-TS systems and the schedule's dispatch is byte-for-byte the
+     * no-backend path. Once attached, a scheduled system carrying a
+     * `backendHandle` (its `SystemConfig`) is executed via `backend.run(handle)`
+     * instead of its `fn` closure; systems without a handle are unaffected.
+     *
+     * The backend is also subscribed as a SAB-layout listener (seeded now, then
+     * republished on every grow), folding in the `onStoreLayoutPublished` seam.
+     * Returns a detach function that unsubscribes the layout listener and reverts
+     * the schedule to the pure-TS path.
+     *
+     * One backend per ECS: attaching while one is already attached throws in
+     * `__DEV__` (detach first). The engine never inspects the backend beyond
+     * `setLayout` / `run` — it carries no game vocabulary. */
+    attachBackend(backend: ComputeBackend): () => void;
+    /** Look up the field index a component reserves for `fieldName`. The
+     * index is assigned by `registerComponent` in insertion order and is
+     * stable for the lifetime of the ECS. Used by systems that need to
+     * pass `(component_id, field_id)` pairs across the WASM FFI — the Zig
+     * side identifies columns by these numeric IDs. */
+    fieldId<S extends Record<string, TypedArrayTag>>(def: ComponentDef<S>, fieldName: Extract<keyof S, string>): number;
+    /** Resolve an archetype's row index to the `EntityID` at that slot.
+     * A WASM system that drains events from the event ring as
+     * `(archId, row, …)` payloads uses this to convert the (archId, row)
+     * pair into the `EntityID` the `ctx.emit(...)` API expects.
+     * Throws if the (archId, row) pair is out of range. (#250 / Phase 4
+     * PR 4D) */
+    entityIdAtRow(archetypeId: number, row: number): EntityID;
+    get fixedTimestep(): number;
+    set fixedTimestep(value: number);
+    get fixedAlpha(): number;
+    /** The single SAB backing every archetype's column views. Exposed for
+     * snapshot/restore, `columnStoreStateHash`-based determinism checks, and
+     * Phase 2+ WASM/worker hand-off paths. Mutation flows through the
+     * usual `addComponent` / `removeComponent` / `flush` APIs; readers
+     * that hold a column view across a grow must consult
+     * `header.view_stamp` to detect a republish (#171 §8.1). */
+    get columnStore(): ColumnStore;
+    /** Count of live archetypes (including the empty one). Surfaces the
+     * Store-side `archetype_count` so Phase C tests can assert the
+     * pre-warmed closure was materialised; equally useful for diagnostics. */
+    get archetypeCount(): number;
+    /** Count of registered relations (#471). Surfaces the Store-side count so
+     * tests can assert it alongside `archetype_count` when checking the
+     * no-transition invariant. */
+    get relationCount(): number;
+    /** Whether the determinism surface is enabled (#626 / ADR-0020). `false`
+     * (the default) ⇒ `stateHash` / `snapshotSparse` / `restoreSparse` throw
+     * `DETERMINISM_DISABLED`. Opt in via `new ECS({ deterministic: true })`. */
+    get deterministic(): boolean;
+    /** Attach (or detach with `null`) a per-world frame-trace sink (ADR-0030):
+     * the engine then fires structured `FrameTraceSink` events at each system,
+     * flush, command, observer firing, and event during `update()`, so a consumer
+     * can reconstruct exactly what travelled through the ECS each frame. The sink
+     * also receives a `phaseBoundary(phase)` at each phase's post-flush settle
+     * point — the safe seam to read `stateHash()` between phases of one frame and
+     * bisect a divergence to the exact phase (#797 / ADR-0032). The seam is
+     * `__DEV__`-gated end to end — in a production build this setter keeps an empty
+     * body and the world never retains a sink. The sink only observes; it does not
+     * perturb `stateHash`, ordering, or any behaviour. */
+    setTrace(sink: FrameTraceSink | null): void;
+    /** FNV-1a 32 over (archetype_id, live row count, live column bytes)
+     * for every archetype in id order. The canonical "live ECS state
+     * digest" — broader than the pre-#171 per-networked-component fold
+     * (every column contributes, not just BIT_HEALTH / BIT_HEX_POS etc.)
+     * and tighter than `columnStoreStateHash(ecs.columnStore)` (skips trailing
+     * unused SAB capacity). Per-call cost scales with live entity count,
+     * not SAB capacity. (#171 §6.1.9 Phase 5)
+     *
+     * Opt-in (#626 / ADR-0020): throws `DETERMINISM_DISABLED` unless the ECS was
+     * constructed with `{ deterministic: true }`. */
+    stateHash(): number;
+    /** Serialize the sparse stores (out-of-identity components, ADR-0011) to a
+     * self-contained byte buffer — the sparse half of a world snapshot, written
+     * in canonical entity-index order so it's insertion-order-independent
+     * (#470). The dense half is the SAB snapshot (`snapshotColumnStore(columnStore)`).
+     * Pairs with `restoreSparse`.
+     *
+     * Opt-in (#626 / ADR-0020): throws `DETERMINISM_DISABLED` unless the ECS was
+     * constructed with `{ deterministic: true }`. */
+    snapshotSparse(): Uint8Array;
+    /** Repopulate the sparse stores from `snapshotSparse` bytes (full-equality
+     * round-trip of membership + data). Sparse components must already be
+     * registered in the same order; throws `SparseRestoreError` on a shape or
+     * identity mismatch (store/field count, field-identity schema hash, an entity
+     * index past `MAX_INDEX`, or a non-canonical frame with trailing bytes).
+     *
+     * Opt-in (#626 / ADR-0020): throws `DETERMINISM_DISABLED` unless the ECS was
+     * constructed with `{ deterministic: true }`. */
+    restoreSparse(bytes: Uint8Array): void;
+    /** Capture the full live world — dense (SAB columns), sparse + relations, and
+     * the host-side bookkeeping the SAB omits (tick, entity recycle free-list,
+     * alive count, per-archetype row/enabled counts) — to one self-contained byte
+     * buffer that `restoreInto` can mount back onto a live, ticking world
+     * ("rewind a running world and keep ticking", #789). Take it at a tick
+     * boundary (between `update()`s).
+     *
+     * Opt-in (ADR-0020): throws `DETERMINISM_DISABLED` unless `{ deterministic:
+     * true }`. v1 does NOT capture resources, events, or change-detection /
+     * scheduler baselines (`changed()` queries) — see ADR-0031. */
+    snapshot(): Uint8Array;
+    /** Mount a `snapshot()` buffer onto this live world and leave it ready to keep
+     * ticking (#789). Fails closed on a malformed frame or a registration mismatch
+     * (different component/archetype graph, mismatched entity-index capacity, or a
+     * divergent sparse-store registration) BEFORE mutating any live state — the
+     * guard reads the snapshot's descriptors + sparse-section shape from the bytes,
+     * since the dense build reuses (and overwrites) the live in-place backing.
+     * Throws `WorldRestoreError` (dense) / `SparseRestoreError` (sparse). Requires a
+     * world whose archetype set + column layout match the snapshot's (prewarm so the
+     * set is stable).
+     *
+     * Opt-in (ADR-0020): throws `DETERMINISM_DISABLED` unless `{ deterministic:
+     * true }`. */
+    restoreInto(bytes: Uint8Array): void;
+    registerComponent<S extends Record<string, TypedArrayTag>>(schema: S): ComponentDef<S>;
+    registerComponent<const F extends readonly string[], T extends TypedArrayTag = "f64">(fields: F, type?: T): ComponentDef<{
+        readonly [K in F[number]]: T;
+    }>;
+    registerTag(): ComponentDef<Record<string, never>>;
+    registerSparseComponent<S extends Record<string, TypedArrayTag>>(schema: S): SparseComponentDef<S>;
+    registerSparseComponent<const F extends readonly string[], T extends TypedArrayTag = "f64">(fields: F, type?: T): SparseComponentDef<{
+        readonly [K in F[number]]: T;
+    }>;
+    /** Register a sparse tag (empty schema) — membership only, no data. */
+    registerSparseTag(): SparseComponentDef<Record<string, never>>;
+    registerEvent<S extends EventSchema>(key: EventKey<S>, fields: readonly (keyof S & string)[]): void;
+    registerSignal(key: SignalKey): void;
+    registerResource<T>(key: ResourceKey<T>, value: T): void;
+    resource<T>(key: ResourceKey<T>): T;
+    setResource<T>(key: ResourceKey<T>, value: T): void;
+    /** Drop a resource from the world (#798). Unlike {@link registerResource}
+     * — a one-time world-setup op — this is a runtime mutation, so it is access-
+     * checked as a *write* (a system removing a resource must declare it in
+     * `resourceWrites`, which is what serialises it against readers/writers of the
+     * same key). Fails closed on a missing key. Afterwards the key is free to
+     * `registerResource` again — the present → absent → present lifecycle.
+     * Resources are out of `stateHash` and snapshot/resume, so a remove never
+     * perturbs the determinism hash. */
+    removeResource<T>(key: ResourceKey<T>): void;
+    hasResource<T>(key: ResourceKey<T>): boolean;
+    createEntity(): EntityID;
+    createEntity<Defs extends readonly ComponentDef[]>(template: Template<Defs>, overrides?: TemplateOverrides<Defs>): EntityID;
+    /** Register an archetype template (#462). Resolves the component set +
+     * default field values to a target archetype once (creating it if absent —
+     * fits the prewarm model), so later `spawn` / `spawnMany` calls land
+     * entities directly in that archetype with **zero archetype transitions**.
+     *
+     *   const Bullet = ecs.template([
+     *     { def: Position, values: { x: 0, y: 0 } },
+     *     { def: Velocity, values: { vx: 0, vy: 0 } },
+     *   ]);
+     *
+     * The big win is multi-component entities and bulk spawns; a single-
+     * component spawn is no faster than `createEntity` + `addComponent`, which
+     * already bump-allocates a fresh entity into the target archetype. See
+     * ADR-0010. */
+    template<Defs extends readonly ComponentDef[]>(entries: TemplateEntries<Defs>): Template<Defs>;
+    /** Bulk-spawn `count` identical entities from `template`. Field writes are
+     * O(columns) (one `TypedArray.fill` per column), not O(count×columns).
+     * Returns the new ids in spawn order. */
+    createEntities(template: Template, count: number): EntityID[];
+    /**
+     * Spawn an entity from varargs bundles (§bundles) — the immediate
+     * host-side analog of `ctx.commands.spawn`. `ecs.spawnBundle(bundle(Pos,{x,y}),
+     * bundle(Vel,{vx:1}), IsEnemy)` collapses the five attach shapes into one. Each
+     * bundle is applied immediately; a single combined-archetype insertion (one
+     * transition instead of one-per-component) is a later optimization — for the
+     * prototype this mirrors the existing per-component `addComponent` path.
+     */
+    spawnBundle(...items: BundleOrDef[]): EntityID;
+    /** Buffer an entity for deferred destruction (applied at the next phase
+     *  flush — matches the semantics of `SystemContext.destroyEntity`). The
+     *  ECS surface is unsuffixed because the context (`ECS` vs Store) already
+     *  implies the mode; `Store.destroyEntity` is the immediate path. */
+    destroyEntity(id: EntityID): void;
+    isAlive(id: EntityID): boolean;
+    get entityCount(): number;
+    addComponent(entityId: EntityID, def: ComponentDef<Record<string, never>>): this;
+    addComponent<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, values: FieldValues<S>): this;
+    addComponents(entityId: EntityID, entries: {
+        def: ComponentDef;
+        values?: Record<string, number>;
+    }[]): void;
+    removeComponent(entityId: EntityID, def: ComponentDef): this;
+    removeComponents(entityId: EntityID, defs: ComponentDef[]): void;
+    hasComponent(entityId: EntityID, def: ComponentDef): boolean;
+    /** Disable `id` (idempotent). Excluded from default queries until re-enabled. */
+    disable(id: EntityID): this;
+    /** Re-enable a disabled `id` (idempotent). */
+    enable(id: EntityID): this;
+    /** Whether `id` is currently disabled. */
+    isDisabled(id: EntityID): boolean;
+    addSparse(entityId: EntityID, def: SparseComponentDef<Record<string, never>>): this;
+    addSparse<S extends ComponentSchema>(entityId: EntityID, def: SparseComponentDef<S>, values: FieldValues<S>): this;
+    removeSparse(entityId: EntityID, def: SparseComponentDef): this;
+    hasSparse(entityId: EntityID, def: SparseComponentDef): boolean;
+    getSparseField<S extends ComponentSchema>(entityId: EntityID, def: SparseComponentDef<S>, field: string & keyof S): number;
+    setSparseField<S extends ComponentSchema>(entityId: EntityID, def: SparseComponentDef<S>, field: string & keyof S, value: number): void;
+    /** Register a relation kind. Exclusive (default) stores one target per
+     * source in a backing sparse component; `{ multi: true }` stores a target
+     * set per source. `{ onDeleteTarget: "delete" | "clear" | "orphan" }`
+     * selects what happens to a relation's sources when a target is destroyed
+     * (default `orphan`, #473). See `registerRelation` on `Store` / ADR-0011. */
+    registerRelation(opts?: RelationOptions): RelationDef;
+    /** Add a `(R, tgt)` pair to `src`. Exclusive replaces the existing target;
+     * multi adds to the set. No archetype transition. */
+    addRelation(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. */
+    removeRelation(src: EntityID, def: RelationDef, tgt?: EntityID): this;
+    /** The single target of `src` under an exclusive relation, or `undefined`. */
+    targetOf(src: EntityID, def: RelationDef): 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. */
+    sourcesOf(def: RelationDef, tgt: EntityID): EntityID[];
+    /** Whether `src` holds any pair under `R`. */
+    hasRelation(src: EntityID, def: RelationDef): boolean;
+    /** All `(source, target)` pairs of relation `R` — the `(R, *)` wildcard
+     * (#472). Sources in canonical entity-index order; a multi source's targets
+     * ascending by id. Cold path. */
+    pairsOf(def: RelationDef): [EntityID, EntityID][];
+    /** Every `(relation, source)` pointing at `tgt`, across all relation kinds —
+     * the `(*, T)` wildcard (#472). Ordered by relation id then source id. The
+     * single-relation form is `sourcesOf(def, tgt)`. */
+    sourcesOfAny(tgt: EntityID): [RelationDef, EntityID][];
+    /** Reclaim relation reverse-index memory: drop every reverse entry whose
+     * target has been destroyed, returning the total dropped (#491). Under the
+     * default `orphan` policy a destroyed target's reverse entry lingers until
+     * each source re-targets or dies, so orphan-pointing at a churn of
+     * short-lived targets grows the index without bound. A purely cold-path
+     * reclaim — no observable state change (forward links stay dangling per
+     * `orphan`, `stateHash` is unaffected) — call it at scene/snapshot
+     * boundaries. */
+    compactRelations(): number;
+    /** Walk relation `R` up from `src` to its chain root, returning
+     * `[src, parent, …, root]` (nearest-ancestor-first). Exclusive only. */
+    ancestorsOf(src: EntityID, def: RelationDef): EntityID[];
+    /** The root of `src`'s `R`-chain (`src` itself when it has no target).
+     * Exclusive only. */
+    rootOf(src: EntityID, def: RelationDef): 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): EntityID[];
+    /**
+     * Bulk add a component to ALL entities in the given archetype.
+     * O(columns) via TypedArray.set() instead of O(N×columns).
+     *
+     * Takes an `ArchetypeID` (from `ArchetypeView.id`) rather than a concrete
+     * `Archetype` — the concrete type is internal (issue #378).
+     */
+    batchAddComponent(src: ArchetypeID, def: ComponentDef<Record<string, never>>): void;
+    batchAddComponent<S extends ComponentSchema>(src: ArchetypeID, def: ComponentDef<S>, values: FieldValues<S>): void;
+    /**
+     * Bulk remove a component from ALL entities in the given archetype.
+     * O(columns) via TypedArray.set() instead of O(N×columns).
+     *
+     * Takes an `ArchetypeID` (from `ArchetypeView.id`); see `batchAddComponent`.
+     */
+    batchRemoveComponent(src: ArchetypeID, def: ComponentDef): void;
+    getField<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S): number;
+    setField<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): void;
+    /** Read-modify-write one field: `updateField(e, Gold, "value", v => v - cost)`
+     * is the one-line form of the `getField` → compute → `setField` round trip.
+     * Returns the written value. Same access-check and observer semantics as the
+     * two calls it composes. */
+    updateField<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, fn: (current: number) => number): number;
+    emit(key: SignalKey): void;
+    emit<S extends EventSchema>(key: EventKey<S>, values: S): void;
+    read<S extends EventSchema>(key: EventKey<S>): EventReader<S>;
+    query<T extends ComponentDef[]>(...defs: T): Query<T>;
+    _getLastRunTick(): number;
+    /** Current ECS write tick — the tick `eachChunk` stamps via `cols.mut` (§eachChunk). */
+    _getCurrentTick(): number;
+    _getQueryDirtyEpoch(): number;
+    _nextQueryId(): number;
+    /** QueryResolver implementation — sparse-membership match path (#469). */
+    _forEachSparseMatch(include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, sparseInclude: readonly SparseComponentID[], sparseExclude: readonly SparseComponentID[], denseArchetypes: readonly Archetype[], cb: (entityId: EntityID) => void, includeDisabled: boolean): void;
+    /** QueryResolver implementation — backing sparse id of a relation, for the
+     * `(R, *)` wildcard term (`Query.withRelation`, #579). */
+    _relationBackingSparseId(def: RelationDef): SparseComponentID;
+    /** QueryResolver implementation — `(*, T)` wildcard match path (#579). */
+    _forEachRelationTargetMatch(target: EntityID, include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, sparseInclude: readonly SparseComponentID[], sparseExclude: readonly SparseComponentID[], includeDisabled: boolean, cb: (entityId: EntityID) => void): void;
+    /** QueryResolver implementation — depth-ordered hierarchy match path (#581). */
+    _forEachHierarchyMatch(include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, sparseInclude: readonly SparseComponentID[], sparseExclude: readonly SparseComponentID[], denseArchetypes: readonly Archetype[], relation: RelationDef, maxDepth: number, includeDisabled: boolean, cb: (entityId: EntityID) => void): void;
+    /** QueryResolver implementation — creates or retrieves a cached Query. */
+    _resolveQuery(include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, defs: readonly ComponentDef[]): Query<any>;
+    private _findCached;
+    /**
+     * Register a system.
+     *
+     *   // Bare function (no query, no lifecycle hooks)
+     *   world.registerSystem((ctx, dt) => { ... });
+     *
+     *   // Function + query builder (query resolved at registration time)
+     *   world.registerSystem(
+     *     (q, ctx, dt) => { q.forEach((arch) => { ... }); },
+     *     (qb) => qb.with(Pos, Vel),
+     *   );
+     *
+     *   // Full config — declares reads/writes (dev-checked) + optional lifecycle hooks
+     *   world.registerSystem({ reads: [Pos, Vel], writes: [Pos], fn(ctx, dt) { ... } });
+     */
+    registerSystem(fn: SystemFn): SystemDescriptor;
+    registerSystem<Defs extends readonly ComponentDef[]>(fn: (q: Query<Defs>, ctx: SystemContext, dt: number) => void, queryFn: (qb: QueryBuilder) => Query<Defs>): SystemDescriptor;
+    registerSystem(config: SystemConfig): SystemDescriptor;
+    addSystems(label: SCHEDULE, ...entries: (SystemDescriptor | SystemEntry)[]): this;
+    /**
+     * Configure a `SystemSet` (#576) — the shared run condition and/or ordering
+     * every member inherits. Additive and order-independent with respect to
+     * `addSystems`: see `Schedule.configureSet`. Returns `this` to chain.
+     */
+    configureSet(set: SystemSet, config: SystemSetConfig): this;
+    removeSystem(system: SystemDescriptor): void;
+    get systemCount(): number;
+    /**
+     * Register a per-component observer (#517 §1 / ADR-0013). Reactions that were
+     * hand-polled every tick — "on `Death` added → spawn corpse", "on `HexPos`
+     * set → mark the spatial index" — become declarative.
+     *
+     * - **`onAdd` / `onRemove`** `(eid, ctx)` fire at the structural-flush
+     *   boundary, after the batch commits, in canonical order (access-topological
+     *   across observers, entity-id order within), looping to a fixed point so
+     *   cascades settle. Determinism: a `stateHash` replay reproduces regardless
+     *   of the order ops were queued.
+     * - **`onDisable` / `onEnable`** `(eid, ctx)` fire at the same flush boundary
+     *   when an entity carrying the component is *disabled* / *enabled* (#577,
+     *   ADR-0023), once per net transition, for every component the entity carries
+     *   (a disable is a soft remove of the whole mask from default queries). Like
+     *   `onAdd`/`onRemove`, an *immediate* `world.disable()` does not fire — only
+     *   the deferred `ctx.disable()` toggle does. `yieldExisting` seeds enabled
+     *   members only, so a disabled entity is correctly absent at seed.
+     * - **`onSet`** fires at the post-update detection point. Default
+     *   `granularity: "archetype"` fires `(arch, ctx)` once per changed
+     *   archetype-column (the consumer iterates `arch.entityCount` rows) — free,
+     *   reusing the change tick. `granularity: "entity"` fires `(eid, ctx)` once
+     *   per changed entity, draining the opt-in per-row dirty list (registering it
+     *   enables dirty tracking for the component; the producer records via
+     *   `ctx.setField` automatically, or `ctx.markChanged` in a `getColumn`
+     *   hot loop).
+     *
+     * Observer callbacks that touch ECS state must declare it via `access`
+     * (merged over an all-empty declaration) — undeclared access throws in
+     * `__DEV__`, and those decls drive the firing order. `yieldExisting` replays
+     * `onAdd` over current matches on registration. Register at world-build time
+     * (before `startup()`); the returned handle's `dispose()` unregisters.
+     */
+    observe<S extends ComponentSchema>(def: ComponentDef<S>, config: StructuralObserverConfig): ObserverHandle;
+    observe<S extends ComponentSchema>(def: ComponentDef<S>, config: EntitySetObserverConfig): ObserverHandle;
+    observe<S extends ComponentSchema>(def: ComponentDef<S>, config: ArchetypeSetObserverConfig): ObserverHandle;
+    startup(): void;
+    /** Compute the archetype closure from every registered system's AND
+     * observer's `spawns` + `transitions` and ask the store to plant the
+     * whole set in one `extendColumnStore` call. Observers carry the same
+     * access shape systems do (a synthesized `SystemDescriptor`), so an
+     * observer that spawns/transitions gets its target archetype prewarmed
+     * too rather than first-touching lazily mid-tick (#768). Exposed as
+     * `private` because the only caller is `startup()`; visible to tests via
+     * the `archetype_count` delta on the public ECS facade. */
+    private prewarmArchetypes;
+    update(dt: number): void;
+    /**
+     * Stamp every SAB-backed archetype's live `length` into its SAB
+     * descriptor's `row_count` field. **You usually don't need to call
+     * this directly** — `update()` publishes at tick start and
+     * `SystemContext.flush()` publishes at every phase boundary, so any
+     * WASM scan running inside the schedule sees fresh counts for free.
+     * This is an escape hatch for code that mutates archetype state
+     * outside the system framework and wants to force a republish without
+     * going through `flush()`. No in-repo callers today.
+     *
+     * Cheap: walks the descriptor region once, does no column I/O.
+     */
+    publishArchetypeRowCounts(): void;
+    flush(): void;
+    dispose(): void;
+}
+/** Phase C of issue #213 — archetype closure from a descriptor set.
+ *
+ * Each descriptor is a system or an observer's synthesized `SystemDescriptor`
+ * (#768) — both carry `spawns` + `transitions`. Seeds the worklist with every
+ * descriptor's `spawns`; iteratively applies every descriptor's `transitions`
+ * to every discovered mask whose components cover the transition's `whenHas`.
+ * Returns the union of seeds + reachable targets, deduplicated by hash-bucketed
+ * mask equality.
+ *
+ * Termination: every transition either monotonically grows the mask (add
+ * outpacing remove), monotonically shrinks it, or returns a mask the
+ * `seen` map already holds. Because the universe of masks is bounded by
+ * `2^|components|` (and in practice the in-tree spawn/transition set is
+ * tiny — ~20 masks at most), the worklist is finite and we exit when it
+ * empties.
+ *
+ * Liberal `whenHas` per design doc §6.6 — over-approximation is fine; an
+ * unreachable transition target costs one descriptor row at the SAB tail,
+ * not column bytes. Empty `spawns` + `transitions` short-circuit to zero.
+ */
+declare function computeArchetypeClosure(descriptors: Iterable<SystemDescriptor>): BitSet[];
+/** @internal — test seam for the closure walk. Exposed so the prewarm
+ * tests can exercise the BFS without standing up a full Store. */
+export declare const _ecsInternals: {
+    computeArchetypeClosure: typeof computeArchetypeClosure;
+};
+export {};
+//# sourceMappingURL=ecs.d.ts.map

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

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