@oasys/oecs 0.5.2 → 0.5.4

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

@@ -99,8 +99,8 @@ export interface ComponentDef<S extends ComponentSchema = ComponentSchema> {
 export type SchemaOf<D> = D extends ComponentDef<infer S extends ComponentSchema> ? S : never;
 /**
  * `unknown` if `D` is one of the query's declared terms, else an error tuple —
- * the query-seam sibling of system.ts's `DeclaredRead` (§typestate,
- * POLISH_AUDIT #6). `Query.eachChunk`'s cursor and `ArchetypeView`'s column
+ * the query-seam sibling of system.ts's `DeclaredRead` (§typestate).
+ * `Query.eachChunk`'s cursor and `ArchetypeView`'s column
  * accessors intersect this into their `def` parameter so fetching a component
  * that is NOT a term of the iterating query fails to compile (previously
  * caught only by the dev-mode access check, and only when the system's
@@ -133,7 +133,7 @@ export type ComponentHandle = {
  * returned function produces a `Bundle` when called (`Pos({x,y})`) and carries
  * its numeric id on a non-enumerable `.id` (invisible to spreads / `JSON`).
  * The single cast bridges the function value to the branded handle type — the
- * `.id` is installed at runtime by `defineProperty` (§10c branded-ID boundary).
+ * `.id` is installed at runtime by `defineProperty` (the branded-ID boundary).
  */
 export declare function makeComponentDef<S extends ComponentSchema>(id: ComponentID): ComponentDef<S>;
 export interface Bundle<S extends ComponentSchema = ComponentSchema> {
@@ -180,7 +180,7 @@ export declare function bundleValues(item: BundleOrDef): Readonly<Record<string,
  *
  * **Advisory, not a runtime barrier:** the value behind this type is the live
  * mutable backing `TypedArray` (`Archetype.getColumnRead` returns
- * `.buf as unknown as ReadonlyColumn`), so a §10c-policed cast can still write
+ * `.buf as unknown as ReadonlyColumn`), so a deliberate cast can still write
  * through. For mutation use the mutable `Archetype.getColumn` (tick-bumping).
  * Enforced by the escape-hatch lint, not the runtime.
  */

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

@@ -11,7 +11,7 @@ export interface DeferredCommandHost {
     readonly applyRemoves: () => void;
     readonly applyDestroys: () => void;
     readonly applyToggles: () => void;
-    /** Hot-path gates — live counts of observed components (#531 / #677).
+    /** Hot-path gates — live counts of observed components.
      * While both are 0 the flush takes the byte-for-byte fast path. */
     readonly structuralObserverCount: () => number;
     readonly toggleObserverCount: () => number;

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

@@ -11,7 +11,7 @@ export interface DeferredCommandHost {
     readonly applyRemoves: () => void;
     readonly applyDestroys: () => void;
     readonly applyToggles: () => void;
-    /** Hot-path gates — live counts of observed components (#531 / #677).
+    /** Hot-path gates — live counts of observed components.
      * While both are 0 the flush takes the byte-for-byte fast path. */
     readonly structuralObserverCount: () => number;
     readonly toggleObserverCount: () => number;

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

@@ -1 +1 @@
-{"version":3,"file":"deferred_commands.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/deferred_commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AASxD;;oDAEoD;AACpD,MAAM,WAAW,mBAAmB;IACnC;yEACqE;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC;uEACmE;IACnE,QAAQ,CAAC,uBAAuB,EAAE,MAAM,MAAM,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,MAAM,CAAC;IAC3C;oDACgD;IAChD,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,wBAAwB,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CACvF;AAED,qBAAa,qBAAqB;IAMjC,SAAgB,UAAU,EAAE,QAAQ,EAAE,CAAM;IAC5C,SAAgB,MAAM,EAAE,QAAQ,EAAE,CAAM;IACxC,SAAgB,OAAO,EAAE,YAAY,EAAE,CAAM;IAC7C,SAAgB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAM;IACzD,SAAgB,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3C,SAAgB,UAAU,EAAE,YAAY,EAAE,CAAM;IAIhD,SAAgB,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3C,SAAgB,aAAa,EAAE,OAAO,EAAE,CAAM;IAE9C;;;0BAGsB;IACtB,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C;6EACyE;IACzE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;gBAEzC,IAAI,EAAE,mBAAmB,EAAE,SAAS,EAAE,wBAAwB;IAKnE,YAAY,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI;IAIhC,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAM/E,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI;IAKlD,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAKxD,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;;4EAGwE;IACjE,cAAc,IAAI,IAAI;IAKtB,eAAe,IAAI,IAAI;CA0F9B"}
+{"version":3,"file":"deferred_commands.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/deferred_commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AASxD;;oDAEoD;AACpD,MAAM,WAAW,mBAAmB;IACnC;yEACqE;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC;uEACmE;IACnE,QAAQ,CAAC,uBAAuB,EAAE,MAAM,MAAM,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,MAAM,CAAC;IAC3C;oDACgD;IAChD,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,wBAAwB,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CACvF;AAED,qBAAa,qBAAqB;IAMjC,SAAgB,UAAU,EAAE,QAAQ,EAAE,CAAM;IAC5C,SAAgB,MAAM,EAAE,QAAQ,EAAE,CAAM;IACxC,SAAgB,OAAO,EAAE,YAAY,EAAE,CAAM;IAC7C,SAAgB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAM;IACzD,SAAgB,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3C,SAAgB,UAAU,EAAE,YAAY,EAAE,CAAM;IAIhD,SAAgB,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3C,SAAgB,aAAa,EAAE,OAAO,EAAE,CAAM;IAE9C;;;0BAGsB;IACtB,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C;6EACyE;IACzE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;gBAEzC,IAAI,EAAE,mBAAmB,EAAE,SAAS,EAAE,wBAAwB;IAKnE,YAAY,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI;IAIhC,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAM/E,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI;IAKlD,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAKxD,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;;4EAGwE;IACjE,cAAc,IAAI,IAAI;IAKtB,eAAe,IAAI,IAAI;CAyF9B"}

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

@@ -7,7 +7,7 @@ import { SCHEDULE, SystemEntry, SystemSet, SystemSetConfig } from './schedule.cj
 import { Archetype, ArchetypeID } from './archetype.cjs';
 import { SystemContext, Query, QueryBuilder, QueryCache, QueryResolver } from './query.cjs';
 import { EntityID } from './entity.cjs';
-import { ReadonlyComponentRef } from './ref.cjs';
+import { ComponentCursor, ReadonlyComponentCursor, ReadonlyComponentRef } from './ref.cjs';
 import { ComponentDef, ComponentHandle, ComponentRegisterOptions, ComponentSchema, CompleteFieldValues, Bundle, BundleOrDef, StrictBundles, DefsOf } from './component.cjs';
 import { SparseComponentDef, SparseComponentID } from './sparse_store.cjs';
 import { RelationDef } from './relation.cjs';
@@ -23,41 +23,41 @@ export interface ECSOptions {
      * dropped-ordering-edge warning). Defaults to `console.warn`. Mirrors the
      * `FrameTraceSink` seam's injectable style — no global logger. */
     onWarn?: (message: string) => void;
-    /** How the world's memory is sized and backed (#682) — the single
+    /** How the world's memory is sized and backed — 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).
+     * `{ allocator }` (expert escape hatch, in-place-typed).
      * 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
+    /** Consumer-declared SAB regions, 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.) */
+     * `actionRingCapacitySlots`) the ECS used to carry. */
     regions?: readonly StoreRegionSpec[];
-    /** Byte size of the opt-in sim-bindings region (#625), forwarded to `Store`.
+    /** Byte size of the opt-in sim-bindings region, 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. */
+     * constant; it is de-welded from the generated ABI. */
     bindingsRegionBytes?: number;
-    /** Opt into the **determinism surface** (#626 / ADR-0020), forwarded to
+    /** Opt into the **determinism surface**, 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`
+     * invariants (the in-place SAB allocator) and the `enabled_count`
      * partition are always-on regardless. */
     deterministic?: boolean;
 }
@@ -65,7 +65,7 @@ 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
+    /** Component observers. Inert until `observe(...)` is
      * called — the structural-flush fast path is byte-for-byte unchanged. */
     private readonly _observers;
     /** Relations: register/add/remove/has, wildcard + traversal reads,
@@ -93,7 +93,7 @@ export declare class ECS implements QueryResolver {
     private readonly _layoutSubscribers;
     private _backend;
     private readonly _memory;
-    /** What `ECSOptions.memory` resolved to (#682): backing allocator kind,
+    /** What `ECSOptions.memory` resolved to: 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. */
@@ -121,7 +121,7 @@ export declare class ECS implements QueryResolver {
      * 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`
+    /** Attach an opt-in compute backend. 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)`
@@ -139,13 +139,13 @@ export declare class ECS implements QueryResolver {
     get fixedTimestep(): number;
     set fixedTimestep(value: number);
     get fixedAlpha(): number;
-    /** Attach (or detach with `null`) a per-world frame-trace sink (ADR-0030):
+    /** Attach (or detach with `null`) a per-world frame-trace sink:
      * 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
+     * bisect a divergence to the exact phase. 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. */
@@ -153,8 +153,8 @@ export declare class ECS implements QueryResolver {
     /**
      * Register a dense component and get back its typed handle. Record syntax
      * gives per-field type control; the array shorthand types every field the
-     * same (default `"f64"` — rejected on a `{ deterministic: true }` world
-     * (#777), pass an explicit integer type there). An empty schema `{}` is a
+     * same (default `"f64"` — rejected on a `{ deterministic: true }` world,
+     * pass an explicit integer type there). An empty schema `{}` is a
      * tag. `opts.name` labels dev-mode diagnostics (`'Pos' (component 5)`
      * instead of `component 5`) — diagnostic only, no behavioural effect.
      *
@@ -230,7 +230,7 @@ export declare class ECS implements QueryResolver {
      *
      * `_updating` scopes the guard to THIS world: the accessCheck slot is
      * process-global, so without it a system of world A mutating world B (a
-     * supported #785 pattern — B is not mid-iteration) would false-throw. */
+     * supported pattern — B is not mid-iteration) would false-throw. */
     private _assertHostMutationOutsideSystem;
     /** Immediately destroy an entity — `ecs.despawn(e); ecs.isAlive(e)` is
      *  `false` on the next line, matching the immediacy of every other host
@@ -273,7 +273,7 @@ export declare class ECS implements QueryResolver {
      * 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).
+     * `Archetype` — the concrete type is internal.
      */
     batchAddComponent(src: ArchetypeID, def: ComponentDef<Record<string, never>>): this;
     batchAddComponent<S extends ComponentSchema>(src: ArchetypeID, def: ComponentDef<S>, values: CompleteFieldValues<S>): this;
@@ -285,7 +285,7 @@ export declare class ECS implements QueryResolver {
      */
     batchRemoveComponent(src: ArchetypeID, def: ComponentDef): this;
     getField<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S): number;
-    /** Host-side parity with `SystemContext.refRead` (POLISH_AUDIT M7): a
+    /** Host-side parity with `SystemContext.refRead`: a
      * read-only whole-component view for tooling/tests, instead of reading
      * field-by-field. Same advisory-`readonly` semantics as the ctx variant;
      * no `_changedTick` bump. Dev-throws on a dead entity, or when the entity
@@ -298,7 +298,42 @@ export declare class ECS implements QueryResolver {
      * only valid until the next structural mutation; treat it as an immediate
      * single-expression read and re-create it after any structural change. */
     refRead<S extends ComponentSchema>(def: ComponentDef<S>, entityId: EntityID): ReadonlyComponentRef<S>;
-    /** Total sibling of {@link getField} (POLISH_AUDIT #9): `undefined` when the
+    /**
+     * A re-pointable single-entity cursor over `def` — the by-id sweep accessor.
+     *
+     * `refRead` resolves an entity one time, and each field after that is almost
+     * free. But it allocates one accessor for each entity. That allocation is the
+     * largest part of the cost of a read of one field by id, because to make an
+     * accessor and to read through it costs much more than to move an accessor
+     * that exists. In a loop over a list of entities, the allocation is not
+     * necessary: the code discards each accessor, and it then makes an equal
+     * accessor for the next entity. You make a cursor one time, and you then
+     * point it again:
+     *
+     *   const p = ecs.cursor(Pos);
+     *   for (let i = 0; i < ids.length; i++) {
+     *     p.at(ids[i]);
+     *     p.x += p.y;
+     *   }
+     *
+     * Reach for it when you touch **many entities** by id; reach for `refRead` /
+     * `ref` for a single entity, and for `eachChunk` whenever a query can express
+     * the set. A column walk resolves nothing for each row, so it stays quicker
+     * than a cursor — a cursor removes the allocation, not the resolution.
+     *
+     * Mutable — every `at()` stamps the component's change tick, like `ctx.ref`.
+     * See `cursorRead` for the read-only variant.
+     *
+     * **Staleness:** safer than a held ref, because `at()` re-resolves the
+     * archetype and row each time — a structural mutation between two `at()` calls
+     * cannot make it read the wrong entity. Only the window between one `at()` and
+     * the field accesses following it must be free of structural mutation.
+     */
+    cursor<S extends ComponentSchema>(def: ComponentDef<S>): ComponentCursor<S>;
+    /** Read-only {@link cursor}: no change-tick stamp on `at()`. Advisory only —
+     * same caveat as `refRead` (the setters exist on the shared prototype). */
+    cursorRead<S extends ComponentSchema>(def: ComponentDef<S>): ReadonlyComponentCursor<S>;
+    /** Total sibling of {@link getField}: `undefined` when the
      * entity is dead or doesn't hold the component, instead of a dev throw /
      * prod garbage read. The safe way to probe-and-read in one call:
      * `ecs.tryGetField(e, Health, "current") ?? 0`. */
@@ -327,7 +362,16 @@ export declare class ECS implements QueryResolver {
      */
     query<T extends ComponentDef[]>(...defs: T): Query<T>;
     _nextQueryId(): number;
-    /** QueryResolver implementation — creates or retrieves a cached Query. */
+    /** QueryResolver implementation — creates or retrieves a cached Query.
+     *
+     * **Mask ownership: borrowed.** The three mask arguments are read, never
+     * retained — the mint path copies each one into the `Query`, into the dedup
+     * entry, and (via `Store.registerQuery`) into the registered-query record.
+     * So callers may pass a scratch mask they intend to reuse (`ecs.query`) or
+     * a live mask they still own (`Query.and` / `.without` / `.anyOf` pass
+     * `this._include` etc.). Do NOT add a caller-side `.copy()` "for safety":
+     * on the cache-hit path that is a per-call BitSet + `number[]` allocation
+     * for nothing. */
     _resolveQuery(include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, defs: readonly ComponentDef[]): Query<any>;
     /**
      * Register a system and get its scheduling handle. The config form is the
@@ -392,7 +436,7 @@ export declare class ECS implements QueryResolver {
      * 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
+     * too rather than first-touching lazily mid-tick. Exposed as
      * `private` because the only caller is `startup()`; visible to tests via
      * the `archetype_count` delta on the public ECS facade. */
     private prewarmArchetypes;
@@ -414,7 +458,7 @@ export declare class ECS implements QueryResolver {
      */
     update(dt: number): void;
     dispose(): void;
-    /** Register an archetype template (#462). Resolves the component set +
+    /** Register an archetype template. 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**.
@@ -428,18 +472,17 @@ export declare class ECS implements QueryResolver {
      * store's entry shape, so it lives here with the other real logic, not in the
      * delegation band. The big win is multi-component entities and bulk spawns; a
      * single-component spawn is no faster than `spawn` + `addComponent`, which
-     * already bump-allocates a fresh entity into the target archetype. See
-     * ADR-0010. */
+     * already bump-allocates a fresh entity into the target archetype. */
     template<Items extends readonly BundleOrDef[]>(...items: StrictBundles<Items>): Template<DefsOf<Items>>;
     /** Resolve a consumer-declared SAB region's byte offset by `region_id`, or
-     * 0 when absent. Generic, de-gamed replacement (#623) for the removed
+     * 0 when absent. Generic, de-gamed replacement 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) */
+     * Re-fetch after a SAB grow. Delegates to `Store.regionHandle`. */
     regionHandle(regionId: number): ColumnStoreRegionHandle | null;
     /** Look up the field index a component reserves for `fieldName`. The
      * index is assigned by `registerComponent` in insertion order and is
@@ -451,18 +494,17 @@ export declare class ECS implements QueryResolver {
      * 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) */
+     * Throws if the (archId, row) pair is out of range. */
     entityIdAtRow(archetypeId: number, row: number): EntityID;
     /** 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
+     * 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). */
+     * `header.view_stamp` to detect a republish. */
     get columnStore(): ColumnStore;
     /** Count of live archetypes (including the empty one). Surfaces the
-     * Store-side `archetype_count` so Phase C tests can assert the
+     * Store-side `archetype_count` so tests can assert the
      * pre-warmed closure was materialised; equally useful for diagnostics. */
     get archetypeCount(): number;
     registerTag(): ComponentDef<Record<string, never>>;
@@ -484,24 +526,24 @@ export declare class ECS implements QueryResolver {
     /** Current ECS write tick — the tick `eachChunk` stamps via `cols.mut` (§eachChunk). */
     _getCurrentTick(): number;
     _getQueryDirtyEpoch(): number;
-    /** QueryResolver implementation — sparse-membership match path (#469). */
+    /** QueryResolver implementation — sparse-membership match path. */
     _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). */
+     * `(R, *)` wildcard term (`Query.withRelation`). */
     _relationBackingSparseId(def: RelationDef): SparseComponentID;
-    /** QueryResolver implementation — `(*, T)` wildcard match path (#579). */
+    /** QueryResolver implementation — `(*, T)` wildcard match path. */
     _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). */
+    /** QueryResolver implementation — depth-ordered hierarchy match path. */
     _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;
     addSystems(label: SCHEDULE, ...entries: (SystemDescriptor | SystemEntry)[]): this;
     /**
-     * Configure a `SystemSet` (#576) — the shared run condition and/or ordering
+     * Configure a `SystemSet` — 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;
     /**
-     * Register a per-component observer (#517 §1 / ADR-0013). Reactions that were
+     * Register a per-component observer. Reactions that were
      * hand-polled every tick — "on `Death` added → spawn corpse", "on `HexPos`
      * set → mark the spatial index" — become declarative.
      *
@@ -511,8 +553,8 @@ export declare class ECS implements QueryResolver {
      *   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
+     *   when an entity carrying the component is *disabled* / *enabled*, 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* `ecs.disable()` does not fire — only
      *   the deferred `ctx.commands.disable()` toggle does. `yieldExisting` seeds enabled
@@ -550,10 +592,10 @@ export declare class ECS implements QueryResolver {
     publishArchetypeRowCounts(): void;
     flush(): void;
 }
-/** Phase C of issue #213 — archetype closure from a descriptor set.
+/** 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
+ * — 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
@@ -566,7 +608,7 @@ export declare class ECS implements QueryResolver {
  * 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
+ * Liberal `whenHas` — 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.
  */