@oasys/oecs 0.5.2 → 0.5.4

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

@@ -9,7 +9,7 @@ export type ComponentRef<S extends ComponentSchema> = {
  * Read-only view of a component reference. This is an **advisory** barrier,
  * not a runtime safety boundary: the `readonly` properties block field writes
  * at the type layer, but `createRef` installs working get/set on the shared
- * prototype for both `ref()` and `refRead()`, so a §10c-policed cast can
+ * prototype for both `ref()` and `refRead()`, so a deliberate cast can
  * still write through (and would skip the change-tick bump `ref()` performs).
  * Treat it as "I promise I am only reading," enforced by the escape-hatch lint
  * (`bun run lint:escape-hatches`), not by the runtime.
@@ -28,4 +28,56 @@ export interface RefColumnGroup {
  * calls for the same group only allocate the lightweight ref object.
  */
 export declare function createRef<S extends ComponentSchema>(group: RefColumnGroup, row: number): ComponentRef<S>;
+interface CursorInternal {
+    /** The current archetype's row plane (`Archetype._bufs`), index-parallel with
+     * its `_flatColumns`. Re-read on every `at()`; safe to hold between `at()` and
+     * a field access because `_syncRowPlane` refills it in place. */
+    _bufs: AnyTypedArray[];
+    /** Where this component's columns start in `_bufs` for the current archetype. */
+    _off: number;
+    _row: number;
+}
+/** Mutable single-entity cursor: field get/set plus `at(entity)`. */
+export type ComponentCursor<S extends ComponentSchema> = {
+    -readonly [K in keyof S]: number;
+} & CursorSeek;
+/**
+ * Read-only cursor. **Advisory**, exactly like `ReadonlyComponentRef`: the
+ * prototype carries working setters for both variants, so a deliberate cast
+ * can still write through — and would skip the change-tick bump the mutable
+ * variant performs.
+ */
+export type ReadonlyComponentCursor<S extends ComponentSchema> = {
+    readonly [K in keyof S]: number;
+} & CursorSeek;
+export interface CursorSeek {
+    /**
+     * Point this cursor at `entity`, resolving its archetype and row. Every
+     * subsequent field access reads or writes `entity` until the next `at()`.
+     *
+     * Returns the cursor, so a single-expression read stays one expression:
+     * `ecs.cursor(Pos).at(e).x`. In a loop, prefer calling it as a statement and
+     * reading fields off the cursor — that is the form the allocation-free path
+     * exists for.
+     */
+    at(entity: import('./entity.js').EntityID): this;
+}
+/**
+ * `at()` needs the archetype and row for an entity, and only the Store can
+ * resolve those. Passing the whole Store into the cursor would hand it (and its
+ * users) the mutation surface; this is the one operation it actually needs,
+ * supplied as a closure by whoever creates the cursor.
+ *
+ * The binder also carries the mutable/read-only difference: `Store.cursorBinder`
+ * closes over whether to stamp the change tick, so the variant is settled once
+ * at creation instead of branched on per `at()`.
+ */
+export type CursorBinder = (cursor: CursorInternal, entity: unknown) => void;
+/**
+ * Build a cursor over `fieldNames`, bound by `bind`. The prototype (field
+ * accessors by ordinal, plus `at`) is built once per component and cached; each
+ * call allocates one small object, and then nothing per entity.
+ */
+export declare function createCursor<S extends ComponentSchema>(fieldNames: readonly string[], bind: CursorBinder): ComponentCursor<S>;
+export {};
 //# sourceMappingURL=ref.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCK;AAEL,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE1E,oFAAoF;AACpF,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,eAAe,IAAI;IACrD,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAChC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,eAAe,IAAI;IAC7D,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAC/B,CAAC;AAMF,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,EAAE,CAAC;CACjD;AAWD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,eAAe,EAClD,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,MAAM,GACT,YAAY,CAAC,CAAC,CAAC,CAwBjB"}
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCK;AAEL,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAG1E,oFAAoF;AACpF,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,eAAe,IAAI;IACrD,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAChC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,eAAe,IAAI;IAC7D,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAC/B,CAAC;AAMF,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,EAAE,CAAC;CACjD;AAWD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,eAAe,EAClD,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,MAAM,GACT,YAAY,CAAC,CAAC,CAAC,CAwBjB;AA2CD,UAAU,cAAc;IACvB;;qEAEiE;IACjE,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AAED,qEAAqE;AACrE,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,eAAe,IAAI;IACxD,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAChC,GAAG,UAAU,CAAC;AAEf;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,eAAe,IAAI;IAChE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAC/B,GAAG,UAAU,CAAC;AAEf,MAAM,WAAW,UAAU;IAC1B;;;;;;;;OAQG;IACH,EAAE,CAAC,MAAM,EAAE,OAAO,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;AAU7E;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,eAAe,EACrD,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,IAAI,EAAE,YAAY,GAChB,eAAe,CAAC,CAAC,CAAC,CA8CpB"}

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

@@ -15,7 +15,7 @@ export type RelationDef<C extends RelationCardinality = RelationCardinality> = R
     readonly [__relationCardinality]?: [C];
 };
 /** Access sentinel for the `(*, T)` wildcard query iteration
- * (`Query.forEachRelatedTo`, #579). A `(*, T)` term reads **every** registered
+ * (`Query.forEachRelatedTo`). A `(*, T)` term reads **every** registered
  * relation's reverse index to find sources of `T`, so it can't name a specific
  * relation in `relationReads` the way `withRelation(R)` (`(R, *)`) can. A
  * system that iterates a `(*, T)` wildcard lists `ANY_RELATION` in `relationReads`
@@ -24,7 +24,7 @@ export type RelationDef<C extends RelationCardinality = RelationCardinality> = R
  * minted from 0 upward), so it can never collide with a registered relation. */
 export declare const ANY_RELATION: RelationDef;
 /** Cleanup policy applied to a relation's **sources** when one of its
- * **targets** is destroyed (#473). Chosen per-relation at registration, run at
+ * **targets** is destroyed. Chosen per-relation at registration, run at
  * destroy-flush (and the immediate-destroy path) off the reverse index:
  *
  *   - **`delete`** — cascade: destroy every source of the dead target too,
@@ -33,10 +33,10 @@ export declare const ANY_RELATION: RelationDef;
  *   - **`orphan`** — leave the link intact but dangling. Reads stay safe (the
  *     reverse index is `EntityID`-keyed, so the dead handle never aliases a
  *     recycled slot); `targetOf` returns a dead handle until the source
- *     re-targets or is removed. This is the pre-#473 behaviour and the default.
+ *     re-targets or is removed. This is the original behaviour and the default.
  */
 export type OnDeleteTarget = "delete" | "clear" | "orphan";
-/** Default on-target-delete policy: leave the link dangling (pre-#473
+/** Default on-target-delete policy: leave the link dangling (the original
  * behaviour, zero change for callers that don't opt in). */
 export declare const DEFAULT_ON_DELETE_TARGET: OnDeleteTarget;
 /** Registration options. `exclusive` (one target per source) is the default;
@@ -63,12 +63,12 @@ export declare const RELATION_TARGET_FIELD = "target";
 export type CanonicalTargetSetFn = (sourceIndex: number, targets: readonly EntityID[]) => void;
 /** Receives one canonical `(source, target)` pair during a fold over a
  * relation's forward links. Sources ascend by entity index, each source's
- * targets ascend by id — the #470 determinism order. */
+ * targets ascend by id — the determinism order. */
 export type CanonicalPairFn = (source: EntityID, target: EntityID) => void;
 /** Maps a source entity **index** to its full `EntityID` (generation from the
  * live slot). Supplied by `Store`, which owns entity generations. */
 export type MakeSourceID = (index: number) => EntityID;
-/** One relation's derived side state. **Abstract over cardinality (#498):** the
+/** One relation's derived side state. **Abstract over cardinality:** the
  * base owns the cardinality-agnostic **reverse index** (target → sources, keyed
  * by full `EntityID` so a recycled slot can't alias a dead target's sources) and
  * a handle on the backing `SparseComponentStore`; the forward representation and
@@ -92,12 +92,12 @@ export declare abstract class RelationStore {
      * multi. Carries membership (and the target, when exclusive). */
     readonly sparse: SparseComponentDef;
     /** Cleanup policy applied to this relation's sources when a target is
-     * destroyed (#473). `orphan` (the default) is a no-op — the link dangles
+     * destroyed. `orphan` (the default) is a no-op — the link dangles
      * safely. `Store` reads this at destroy-flush off `sourcesOf`. */
     readonly onDeleteTarget: OnDeleteTarget;
     /** The backing sparse store instance. Owned for registration/liveness by
      * `Store`, but the relation drives the forward/membership rows on it directly
-     * — that is the cardinality interaction this class now encapsulates (#498). */
+     * — that is the cardinality interaction this class now encapsulates. */
     protected readonly _store: SparseComponentStore;
     /** target `EntityID` → set of source `EntityID`s. Keyed by the full id, not
      * the index, so a recycled target slot can't alias a dead target's sources.
@@ -111,7 +111,7 @@ export declare abstract class RelationStore {
      * linger with an empty set). */
     protected unlinkReverse(tgt: EntityID, src: EntityID): void;
     /** Drop every reverse-index entry whose **target** is no longer alive,
-     * returning the count dropped (#491). The `orphan` policy intentionally
+     * returning the count dropped. The `orphan` policy intentionally
      * leaves a destroyed target's reverse entry intact (the link dangles
      * safely), so a long-lived source that orphan-points at a stream of
      * short-lived targets and never re-targets/dies accumulates dead-target keys
@@ -149,7 +149,7 @@ export declare abstract class RelationStore {
      * reverse index in lockstep. Exclusive: replaces any existing target
      * (idempotent if `tgt` is already the target). Multi: adds to the set
      * (idempotent on a duplicate), establishing the membership tag on the first
-     * target. `src` must be live — `Store` checks before delegating (#495). */
+     * target. `src` must be live — `Store` checks before delegating. */
     abstract link(src: EntityID, tgt: EntityID): void;
     /** Remove `(R, tgt)` from `src` — or, when `tgt` is omitted, every target of
      * `src` — keeping forward link + membership + reverse index in lockstep. A
@@ -166,7 +166,7 @@ export declare abstract class RelationStore {
     abstract singleTarget(index: number): EntityID | undefined;
     /** All targets of source `index`, ascending by id — one or zero for
      * exclusive, the full sorted set for multi. The symmetric counterpart to
-     * `sourcesOf` (#498 item 4). */
+     * `sourcesOf`. */
     abstract targetsOf(index: number): EntityID[];
     /** Whether source `index` holds any target under this relation (sparse
      * membership). */
@@ -174,12 +174,12 @@ export declare abstract class RelationStore {
     /** Fold `cb` over this relation's **multi** forward target sets in canonical
      * order (sources ascending by index, each source's targets ascending by id),
      * skipping empty sets. The single source of truth for the canonical multi
-     * traversal shared by `stateHash`, `snapshotRelations`, and `pairsOf`
-     * (#498 item 1). Exclusive relations contribute via the sparse store, so this
+     * traversal shared by `stateHash`, `snapshotRelations`, and `pairsOf`.
+     * Exclusive relations contribute via the sparse store, so this
      * is a no-op for them. */
     abstract forEachCanonicalTargetSet(cb: CanonicalTargetSetFn): void;
     /** Fold `cb` over every `(source, target)` pair of this relation in canonical
-     * order — the `(R, *)` wildcard drive order (#472). `makeId` maps a source
+     * order — the `(R, *)` wildcard drive order. `makeId` maps a source
      * index to its full `EntityID`. Exclusive rides the backing store's
      * `canonicalIndices`; multi rides `forEachCanonicalTargetSet`. */
     abstract forEachCanonicalPair(makeId: MakeSourceID, cb: CanonicalPairFn): void;
@@ -210,7 +210,7 @@ export declare function makeRelationStore(exclusive: boolean, sparse: SparseComp
  * Members are emitted in canonical order (sources ascending by entity index,
  * each source's targets ascending by id) so the bytes are independent of
  * add/remove history — the same byte-level determinism invariant the sparse
- * snapshot holds (#470). Layout (integers little-endian):
+ * snapshot holds. Layout (integers little-endian):
  *
  *   u32 relationCount
  *   repeat relationCount times (registration / id order):

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

@@ -15,7 +15,7 @@ export type RelationDef<C extends RelationCardinality = RelationCardinality> = R
     readonly [__relationCardinality]?: [C];
 };
 /** Access sentinel for the `(*, T)` wildcard query iteration
- * (`Query.forEachRelatedTo`, #579). A `(*, T)` term reads **every** registered
+ * (`Query.forEachRelatedTo`). A `(*, T)` term reads **every** registered
  * relation's reverse index to find sources of `T`, so it can't name a specific
  * relation in `relationReads` the way `withRelation(R)` (`(R, *)`) can. A
  * system that iterates a `(*, T)` wildcard lists `ANY_RELATION` in `relationReads`
@@ -24,7 +24,7 @@ export type RelationDef<C extends RelationCardinality = RelationCardinality> = R
  * minted from 0 upward), so it can never collide with a registered relation. */
 export declare const ANY_RELATION: RelationDef;
 /** Cleanup policy applied to a relation's **sources** when one of its
- * **targets** is destroyed (#473). Chosen per-relation at registration, run at
+ * **targets** is destroyed. Chosen per-relation at registration, run at
  * destroy-flush (and the immediate-destroy path) off the reverse index:
  *
  *   - **`delete`** — cascade: destroy every source of the dead target too,
@@ -33,10 +33,10 @@ export declare const ANY_RELATION: RelationDef;
  *   - **`orphan`** — leave the link intact but dangling. Reads stay safe (the
  *     reverse index is `EntityID`-keyed, so the dead handle never aliases a
  *     recycled slot); `targetOf` returns a dead handle until the source
- *     re-targets or is removed. This is the pre-#473 behaviour and the default.
+ *     re-targets or is removed. This is the original behaviour and the default.
  */
 export type OnDeleteTarget = "delete" | "clear" | "orphan";
-/** Default on-target-delete policy: leave the link dangling (pre-#473
+/** Default on-target-delete policy: leave the link dangling (the original
  * behaviour, zero change for callers that don't opt in). */
 export declare const DEFAULT_ON_DELETE_TARGET: OnDeleteTarget;
 /** Registration options. `exclusive` (one target per source) is the default;
@@ -63,12 +63,12 @@ export declare const RELATION_TARGET_FIELD = "target";
 export type CanonicalTargetSetFn = (sourceIndex: number, targets: readonly EntityID[]) => void;
 /** Receives one canonical `(source, target)` pair during a fold over a
  * relation's forward links. Sources ascend by entity index, each source's
- * targets ascend by id — the #470 determinism order. */
+ * targets ascend by id — the determinism order. */
 export type CanonicalPairFn = (source: EntityID, target: EntityID) => void;
 /** Maps a source entity **index** to its full `EntityID` (generation from the
  * live slot). Supplied by `Store`, which owns entity generations. */
 export type MakeSourceID = (index: number) => EntityID;
-/** One relation's derived side state. **Abstract over cardinality (#498):** the
+/** One relation's derived side state. **Abstract over cardinality:** the
  * base owns the cardinality-agnostic **reverse index** (target → sources, keyed
  * by full `EntityID` so a recycled slot can't alias a dead target's sources) and
  * a handle on the backing `SparseComponentStore`; the forward representation and
@@ -92,12 +92,12 @@ export declare abstract class RelationStore {
      * multi. Carries membership (and the target, when exclusive). */
     readonly sparse: SparseComponentDef;
     /** Cleanup policy applied to this relation's sources when a target is
-     * destroyed (#473). `orphan` (the default) is a no-op — the link dangles
+     * destroyed. `orphan` (the default) is a no-op — the link dangles
      * safely. `Store` reads this at destroy-flush off `sourcesOf`. */
     readonly onDeleteTarget: OnDeleteTarget;
     /** The backing sparse store instance. Owned for registration/liveness by
      * `Store`, but the relation drives the forward/membership rows on it directly
-     * — that is the cardinality interaction this class now encapsulates (#498). */
+     * — that is the cardinality interaction this class now encapsulates. */
     protected readonly _store: SparseComponentStore;
     /** target `EntityID` → set of source `EntityID`s. Keyed by the full id, not
      * the index, so a recycled target slot can't alias a dead target's sources.
@@ -111,7 +111,7 @@ export declare abstract class RelationStore {
      * linger with an empty set). */
     protected unlinkReverse(tgt: EntityID, src: EntityID): void;
     /** Drop every reverse-index entry whose **target** is no longer alive,
-     * returning the count dropped (#491). The `orphan` policy intentionally
+     * returning the count dropped. The `orphan` policy intentionally
      * leaves a destroyed target's reverse entry intact (the link dangles
      * safely), so a long-lived source that orphan-points at a stream of
      * short-lived targets and never re-targets/dies accumulates dead-target keys
@@ -149,7 +149,7 @@ export declare abstract class RelationStore {
      * reverse index in lockstep. Exclusive: replaces any existing target
      * (idempotent if `tgt` is already the target). Multi: adds to the set
      * (idempotent on a duplicate), establishing the membership tag on the first
-     * target. `src` must be live — `Store` checks before delegating (#495). */
+     * target. `src` must be live — `Store` checks before delegating. */
     abstract link(src: EntityID, tgt: EntityID): void;
     /** Remove `(R, tgt)` from `src` — or, when `tgt` is omitted, every target of
      * `src` — keeping forward link + membership + reverse index in lockstep. A
@@ -166,7 +166,7 @@ export declare abstract class RelationStore {
     abstract singleTarget(index: number): EntityID | undefined;
     /** All targets of source `index`, ascending by id — one or zero for
      * exclusive, the full sorted set for multi. The symmetric counterpart to
-     * `sourcesOf` (#498 item 4). */
+     * `sourcesOf`. */
     abstract targetsOf(index: number): EntityID[];
     /** Whether source `index` holds any target under this relation (sparse
      * membership). */
@@ -174,12 +174,12 @@ export declare abstract class RelationStore {
     /** Fold `cb` over this relation's **multi** forward target sets in canonical
      * order (sources ascending by index, each source's targets ascending by id),
      * skipping empty sets. The single source of truth for the canonical multi
-     * traversal shared by `stateHash`, `snapshotRelations`, and `pairsOf`
-     * (#498 item 1). Exclusive relations contribute via the sparse store, so this
+     * traversal shared by `stateHash`, `snapshotRelations`, and `pairsOf`.
+     * Exclusive relations contribute via the sparse store, so this
      * is a no-op for them. */
     abstract forEachCanonicalTargetSet(cb: CanonicalTargetSetFn): void;
     /** Fold `cb` over every `(source, target)` pair of this relation in canonical
-     * order — the `(R, *)` wildcard drive order (#472). `makeId` maps a source
+     * order — the `(R, *)` wildcard drive order. `makeId` maps a source
      * index to its full `EntityID`. Exclusive rides the backing store's
      * `canonicalIndices`; multi rides `forEachCanonicalTargetSet`. */
     abstract forEachCanonicalPair(makeId: MakeSourceID, cb: CanonicalPairFn): void;
@@ -210,7 +210,7 @@ export declare function makeRelationStore(exclusive: boolean, sparse: SparseComp
  * Members are emitted in canonical order (sources ascending by entity index,
  * each source's targets ascending by id) so the bytes are independent of
  * add/remove history — the same byte-level determinism invariant the sparse
- * snapshot holds (#470). Layout (integers little-endian):
+ * snapshot holds. Layout (integers little-endian):
  *
  *   u32 relationCount
  *   repeat relationCount times (registration / id order):

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

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

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

@@ -33,23 +33,23 @@ export declare class RelationService {
     /** Number of registered relations. */
     get count(): number;
     /** Whether any relation registered a non-`orphan` `onDeleteTarget` policy —
-     * the destroy paths' gate for `cleanupTarget` (#473). */
+     * the destroy paths' gate for `cleanupTarget`. */
     get hasTargetCleanup(): boolean;
     /** Register a relation kind. `exclusive` (the default) → one target per
      * source, stored in a backing `{ target: f64 }` sparse component, so the
-     * forward index rides the sparse store and inherits query membership (#469),
-     * `stateHash` + snapshot/restore (#470) for free. `multi` → a set of
+     * forward index rides the sparse store and inherits query membership,
+     * `stateHash` + snapshot/restore for free. `multi` → a set of
      * targets per source, backed by a sparse tag for membership plus a side
      * forward index the relation owns. The two cardinalities are mutually
      * exclusive. `onDeleteTarget` selects the cleanup policy run when a target
      * is destroyed — `delete` (cascade-destroy sources), `clear` (drop the link,
-     * sources survive), or `orphan` (default: leave it dangling, #473). See
-     * ADR-0011 and `relation.ts`.
+     * sources survive), or `orphan` (default: leave it dangling). See
+     * `relation.ts`.
      *
      * The backing sparse store is resolved and handed to the relation so it can
      * drive forward/membership rows directly — the cardinality-specific
      * interaction is `ExclusiveRelationStore` / `MultiRelationStore`'s, not a
-     * branch here (#498). */
+     * branch here. */
     registerRelation(opts?: RelationOptions): RelationDef;
     private relationOf;
     /** Add a `(R, tgt)` pair to `src`. No archetype transition. Exclusive:
@@ -57,7 +57,7 @@ export declare class RelationService {
      * `tgt` is already the target. Multi: adds `tgt` to the set, a no-op if
      * already present. A dead `src` *or* `tgt` is caller error: it throws in
      * `DEV` and is a no-op in production — symmetric, so a production build
-     * never links a reverse-index entry keyed by a destroyed handle (#495). */
+     * never links a reverse-index entry keyed by a destroyed handle. */
     addRelation(src: EntityID, def: RelationDef, tgt: EntityID): void;
     /** Remove a `(R, tgt)` pair from `src`. No archetype transition. Exclusive:
      * `tgt` is optional and the removal is a no-op when it names a target other
@@ -76,8 +76,8 @@ export declare class RelationService {
     sourcesOf(tgt: EntityID, def: RelationDef): 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 are emitted in **canonical entity-index order** (the #470
+    /** All `(source, target)` pairs of relation `R` — the `(R, *)` wildcard.
+     * Sources are emitted in **canonical entity-index order** (the
      * determinism convention): exclusive relations ride the backing sparse
      * store's `canonicalIndices`, multi relations ride the same
      * `forEachCanonicalTargetSet` traversal `stateHash` / `snapshotRelations`
@@ -87,7 +87,7 @@ export declare class RelationService {
      * point-query forms are `targetOf` / `targetsOf`. */
     pairsOf(def: RelationDef): readonly (readonly [EntityID, EntityID])[];
     /** Every `(relation, source)` pointing at `tgt`, across **all** registered
-     * relation kinds — the `(*, T)` wildcard (#472). Walks the relation registry
+     * relation kinds — the `(*, T)` wildcard. Walks the relation registry
      * in id order (each relation's reverse index already returns sources
      * ascending by id), so the result is ordered by relation id then source id.
      * Empty when nothing targets `tgt`. The single-relation form is
@@ -116,7 +116,7 @@ export declare class RelationService {
     forEachRelationTargetMatch(target: EntityID, include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, sparseInclude: readonly SparseComponentID[], sparseExclude: readonly SparseComponentID[], includeDisabled: boolean, cb: (entityId: EntityID) => void): void;
     /** Reclaim reverse-index memory: drop every relation's reverse entries whose
      * **target** has been destroyed, returning the total dropped across all
-     * relations (#491). Under the default `orphan` policy a destroyed target
+     * relations. Under the default `orphan` policy a destroyed target
      * leaves its reverse entry intact until each source re-targets or dies, so a
      * long-lived source that orphan-points at a churn of short-lived targets and
      * never re-targets accumulates dead-target keys without bound. This cold-path
@@ -171,10 +171,10 @@ export declare class RelationService {
      * intact: the reverse index is keyed by full `EntityID`, so a recycled slot
      * never aliases the dead target's sources. The destroyed entity's **target**
      * role is handled separately by `cleanupTarget` per each relation's
-     * `OnDeleteTarget` policy (#473). Gated by the caller on `count > 0`. */
+     * `OnDeleteTarget` policy. Gated by the caller on `count > 0`. */
     purgeSource(entityId: EntityID): void;
     /** Apply each relation's `OnDeleteTarget` policy for a destroyed **target**
-     * `targetId` (#473). Walks the registry; for every relation whose reverse
+     * `targetId`. Walks the registry; for every relation whose reverse
      * index has sources pointing at the dead target:
      *
      *  - **`delete`** — append each source to `cascade`; the caller destroys them
@@ -192,7 +192,7 @@ export declare class RelationService {
      * iterating is safe. Gated by the caller on `hasTargetCleanup`, so the
      * whole walk is skipped when no relation opts into a non-`orphan` policy. */
     cleanupTarget(targetId: EntityID, cascade: EntityID[]): void;
-    /** Fourth query-match path (#581): yield the matched entities — the exact
+    /** Fourth query-match path: yield the matched entities — the exact
      * sparse-match intersection (dense mask + sparse require/exclude + the
      * default enabled-row filter) — in canonical **hierarchy depth order** over
      * exclusive relation `R`: depth ascending (parents before children), **entity

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

@@ -33,23 +33,23 @@ export declare class RelationService {
     /** Number of registered relations. */
     get count(): number;
     /** Whether any relation registered a non-`orphan` `onDeleteTarget` policy —
-     * the destroy paths' gate for `cleanupTarget` (#473). */
+     * the destroy paths' gate for `cleanupTarget`. */
     get hasTargetCleanup(): boolean;
     /** Register a relation kind. `exclusive` (the default) → one target per
      * source, stored in a backing `{ target: f64 }` sparse component, so the
-     * forward index rides the sparse store and inherits query membership (#469),
-     * `stateHash` + snapshot/restore (#470) for free. `multi` → a set of
+     * forward index rides the sparse store and inherits query membership,
+     * `stateHash` + snapshot/restore for free. `multi` → a set of
      * targets per source, backed by a sparse tag for membership plus a side
      * forward index the relation owns. The two cardinalities are mutually
      * exclusive. `onDeleteTarget` selects the cleanup policy run when a target
      * is destroyed — `delete` (cascade-destroy sources), `clear` (drop the link,
-     * sources survive), or `orphan` (default: leave it dangling, #473). See
-     * ADR-0011 and `relation.ts`.
+     * sources survive), or `orphan` (default: leave it dangling). See
+     * `relation.ts`.
      *
      * The backing sparse store is resolved and handed to the relation so it can
      * drive forward/membership rows directly — the cardinality-specific
      * interaction is `ExclusiveRelationStore` / `MultiRelationStore`'s, not a
-     * branch here (#498). */
+     * branch here. */
     registerRelation(opts?: RelationOptions): RelationDef;
     private relationOf;
     /** Add a `(R, tgt)` pair to `src`. No archetype transition. Exclusive:
@@ -57,7 +57,7 @@ export declare class RelationService {
      * `tgt` is already the target. Multi: adds `tgt` to the set, a no-op if
      * already present. A dead `src` *or* `tgt` is caller error: it throws in
      * `DEV` and is a no-op in production — symmetric, so a production build
-     * never links a reverse-index entry keyed by a destroyed handle (#495). */
+     * never links a reverse-index entry keyed by a destroyed handle. */
     addRelation(src: EntityID, def: RelationDef, tgt: EntityID): void;
     /** Remove a `(R, tgt)` pair from `src`. No archetype transition. Exclusive:
      * `tgt` is optional and the removal is a no-op when it names a target other
@@ -76,8 +76,8 @@ export declare class RelationService {
     sourcesOf(tgt: EntityID, def: RelationDef): 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 are emitted in **canonical entity-index order** (the #470
+    /** All `(source, target)` pairs of relation `R` — the `(R, *)` wildcard.
+     * Sources are emitted in **canonical entity-index order** (the
      * determinism convention): exclusive relations ride the backing sparse
      * store's `canonicalIndices`, multi relations ride the same
      * `forEachCanonicalTargetSet` traversal `stateHash` / `snapshotRelations`
@@ -87,7 +87,7 @@ export declare class RelationService {
      * point-query forms are `targetOf` / `targetsOf`. */
     pairsOf(def: RelationDef): readonly (readonly [EntityID, EntityID])[];
     /** Every `(relation, source)` pointing at `tgt`, across **all** registered
-     * relation kinds — the `(*, T)` wildcard (#472). Walks the relation registry
+     * relation kinds — the `(*, T)` wildcard. Walks the relation registry
      * in id order (each relation's reverse index already returns sources
      * ascending by id), so the result is ordered by relation id then source id.
      * Empty when nothing targets `tgt`. The single-relation form is
@@ -116,7 +116,7 @@ export declare class RelationService {
     forEachRelationTargetMatch(target: EntityID, include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, sparseInclude: readonly SparseComponentID[], sparseExclude: readonly SparseComponentID[], includeDisabled: boolean, cb: (entityId: EntityID) => void): void;
     /** Reclaim reverse-index memory: drop every relation's reverse entries whose
      * **target** has been destroyed, returning the total dropped across all
-     * relations (#491). Under the default `orphan` policy a destroyed target
+     * relations. Under the default `orphan` policy a destroyed target
      * leaves its reverse entry intact until each source re-targets or dies, so a
      * long-lived source that orphan-points at a churn of short-lived targets and
      * never re-targets accumulates dead-target keys without bound. This cold-path
@@ -171,10 +171,10 @@ export declare class RelationService {
      * intact: the reverse index is keyed by full `EntityID`, so a recycled slot
      * never aliases the dead target's sources. The destroyed entity's **target**
      * role is handled separately by `cleanupTarget` per each relation's
-     * `OnDeleteTarget` policy (#473). Gated by the caller on `count > 0`. */
+     * `OnDeleteTarget` policy. Gated by the caller on `count > 0`. */
     purgeSource(entityId: EntityID): void;
     /** Apply each relation's `OnDeleteTarget` policy for a destroyed **target**
-     * `targetId` (#473). Walks the registry; for every relation whose reverse
+     * `targetId`. Walks the registry; for every relation whose reverse
      * index has sources pointing at the dead target:
      *
      *  - **`delete`** — append each source to `cascade`; the caller destroys them
@@ -192,7 +192,7 @@ export declare class RelationService {
      * iterating is safe. Gated by the caller on `hasTargetCleanup`, so the
      * whole walk is skipped when no relation opts into a non-`orphan` policy. */
     cleanupTarget(targetId: EntityID, cascade: EntityID[]): void;
-    /** Fourth query-match path (#581): yield the matched entities — the exact
+    /** Fourth query-match path: yield the matched entities — the exact
      * sparse-match intersection (dense mask + sparse require/exclude + the
      * default enabled-row filter) — in canonical **hierarchy depth order** over
      * exclusive relation `R`: depth ascending (parents before children), **entity

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

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

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

@@ -8,7 +8,7 @@
  * stores an arbitrary typed value. The key carries the value type as a
  * phantom type parameter, so reads are type-safe at compile time.
  *
- * Lifecycle (#798). A resource is register-once *until removed*: a second
+ * Lifecycle. A resource is register-once *until removed*: a second
  * `registerResource` for a live key throws RESOURCE_ALREADY_REGISTERED, but
  * `removeResource(key)` drops it (failing closed on a missing key) and frees the
  * key to be registered again — the present → absent → present axis. Removal is

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

@@ -8,7 +8,7 @@
  * stores an arbitrary typed value. The key carries the value type as a
  * phantom type parameter, so reads are type-safe at compile time.
  *
- * Lifecycle (#798). A resource is register-once *until removed*: a second
+ * Lifecycle. A resource is register-once *until removed*: a second
  * `registerResource` for a live key throws RESOURCE_ALREADY_REGISTERED, but
  * `removeResource(key)` drops it (failing closed on a missing key) and frees the
  * key to be registered again — the present → absent → present axis. Removal is

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

@@ -1,5 +1,5 @@
 /***
- * ResourceRegistry — the world's symbol-keyed resource dictionary (H1 step 2).
+ * ResourceRegistry — the world's symbol-keyed resource dictionary.
  *
  * Extracted from `Store`, which keeps one-line delegations; fully
  * self-contained (no Store reach-back). Resources stay out of `stateHash` and
@@ -12,7 +12,7 @@ export declare class ResourceRegistry {
     set(key: symbol, value: unknown): void;
     /** Drop a resource from the world. Fails closed on a missing key (mirrors
      * `get` / `set`); afterwards the key is free to `register` again — the
-     * present → absent → present lifecycle (#798). Purely a host-side
+     * present → absent → present lifecycle. Purely a host-side
      * dictionary delete with no determinism-hash effect. */
     remove(key: symbol): void;
     has(key: symbol): boolean;

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

@@ -1,5 +1,5 @@
 /***
- * ResourceRegistry — the world's symbol-keyed resource dictionary (H1 step 2).
+ * ResourceRegistry — the world's symbol-keyed resource dictionary.
  *
  * Extracted from `Store`, which keeps one-line delegations; fully
  * self-contained (no Store reach-back). Resources stay out of `stateHash` and
@@ -12,7 +12,7 @@ export declare class ResourceRegistry {
     set(key: symbol, value: unknown): void;
     /** Drop a resource from the world. Fails closed on a missing key (mirrors
      * `get` / `set`); afterwards the key is free to `register` again — the
-     * present → absent → present lifecycle (#798). Purely a host-side
+     * present → absent → present lifecycle. Purely a host-side
      * dictionary delete with no determinism-hash effect. */
     remove(key: symbol): void;
     has(key: symbol): boolean;

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

@@ -19,7 +19,7 @@ export interface ArchetypeRowState {
     readonly archetypeId: number;
     /** Total live rows (enabled + disabled). */
     readonly length: number;
-    /** Enabled-row partition boundary (#577): rows `[0, enabledCount)` enabled. */
+    /** Enabled-row partition boundary: rows `[0, enabledCount)` enabled. */
     readonly enabledCount: number;
 }
 /** The host-side state a snapshot captures alongside the dense + sparse bytes. */
@@ -65,8 +65,8 @@ export declare function unframeWorldSnapshot(bytes: Uint8Array): WorldSnapshotSe
 /**
  * Fail-closed registration guard, read **directly from the snapshot's dense
  * bytes** so it can run BEFORE the dense backing is touched. `restoreInto`
- * builds the restored store through the live world's in-place allocator
- * (ADR-0008), which reuses the live backing buffer — so validating a
+ * builds the restored store through the live world's in-place allocator,
+ * which reuses the live backing buffer — so validating a
  * *materialised* `ColumnStore` would already have overwritten live column data
  * (the buffer is overwritten inside `restoreColumnStore`, before any post-build
  * check could run). Parsing the descriptors off the raw `dense` `Uint8Array`

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

@@ -19,7 +19,7 @@ export interface ArchetypeRowState {
     readonly archetypeId: number;
     /** Total live rows (enabled + disabled). */
     readonly length: number;
-    /** Enabled-row partition boundary (#577): rows `[0, enabledCount)` enabled. */
+    /** Enabled-row partition boundary: rows `[0, enabledCount)` enabled. */
     readonly enabledCount: number;
 }
 /** The host-side state a snapshot captures alongside the dense + sparse bytes. */
@@ -65,8 +65,8 @@ export declare function unframeWorldSnapshot(bytes: Uint8Array): WorldSnapshotSe
 /**
  * Fail-closed registration guard, read **directly from the snapshot's dense
  * bytes** so it can run BEFORE the dense backing is touched. `restoreInto`
- * builds the restored store through the live world's in-place allocator
- * (ADR-0008), which reuses the live backing buffer — so validating a
+ * builds the restored store through the live world's in-place allocator,
+ * which reuses the live backing buffer — so validating a
  * *materialised* `ColumnStore` would already have overwritten live column data
  * (the buffer is overwritten inside `restoreColumnStore`, before any post-build
  * check could run). Parsing the descriptors off the raw `dense` `Uint8Array`

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

@@ -1 +1 @@
-{"version":3,"file":"resume.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/resume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAUN,KAAK,cAAc,EACnB,MAAM,UAAU,CAAC;AAElB;;kFAEkF;AAClF,eAAO,MAAM,oBAAoB,YAAa,CAAC;AAE/C;qFACqF;AACrF,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;2BAI2B;AAC3B,qBAAa,eAAgB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI3B;AAED,qFAAqF;AACrF,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC9B;AAED,kFAAkF;AAClF,MAAM,WAAW,SAAS;IACzB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;kFAC8E;IAC9E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,yBAAyB;IACzB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;oCACgC;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,mEAAmE;IACnE,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACrD;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAG,UAAU,CAwB5D;AAED;gFACgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAqC3D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,GACd,UAAU,CAaZ;AAED,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC1B;AAED;6EAC6E;AAC7E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAuC7E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,EACzC,uBAAuB,EAAE,MAAM,GAC7B,IAAI,CAoGN"}
+{"version":3,"file":"resume.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/resume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAUN,KAAK,cAAc,EACnB,MAAM,UAAU,CAAC;AAElB;;kFAEkF;AAClF,eAAO,MAAM,oBAAoB,YAAa,CAAC;AAE/C;qFACqF;AACrF,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;2BAI2B;AAC3B,qBAAa,eAAgB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI3B;AAED,qFAAqF;AACrF,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC9B;AAED,kFAAkF;AAClF,MAAM,WAAW,SAAS;IACzB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;kFAC8E;IAC9E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,yBAAyB;IACzB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;oCACgC;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,mEAAmE;IACnE,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACrD;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAG,UAAU,CAwB5D;AAED;gFACgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAqC3D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,GACd,UAAU,CAaZ;AAED,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC1B;AAED;6EAC6E;AAC7E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAuC7E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,EACzC,uBAAuB,EAAE,MAAM,GAC7B,IAAI,CAoGN"}