@oasys/oecs 0.5.4 → 0.6.0

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

@@ -1,9 +1,8 @@
-import { Brand } from '../../type_primitives/index.js';
+import { Brand, BitSet, TypedArrayTag } from '../../type_primitives/index.js';
 import { EntityID } from './entity.js';
-import { SparseComponentDef, SparseComponentStore } from './sparse_store.js';
-/** Relation handle id. A separate id space from `ComponentID` and
- * `SparseComponentID` — it indexes the `RelationService` registry. The numeric
- * value is the registration order, stable for the lifetime of the ECS. */
+import { Archetype } from './archetype.js';
+import { QueryTerms } from './query_terms.js';
+import { SparseComponentDef, SparseComponentID, SparseComponentStore } from './sparse_store.js';
 export type RelationID = Brand<number, "relation_id">;
 declare const __relationBrand: unique symbol;
 /** A relation's registration-time cardinality: `exclusive` = one target per
@@ -17,9 +16,9 @@ export type RelationDef<C extends RelationCardinality = RelationCardinality> = R
 /** Access sentinel for the `(*, T)` wildcard query iteration
  * (`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
+ * relation in `relationReads` the way `andRelation(R)` (`(R, *)`) can. A
  * system that iterates a `(*, T)` wildcard lists `ANY_RELATION` in `relationReads`
- * instead; `accessCheck.checkRelationReadAny` honors it. The numeric value is a
+ * instead. `accessCheck.assertRelationReadAny` honors it. The numeric value is a
  * reserved sentinel far past any real registration-order relation id (relations are
  * minted from 0 upward), so it can never collide with a registered relation. */
 export declare const ANY_RELATION: RelationDef;
@@ -27,21 +26,21 @@ export declare const ANY_RELATION: RelationDef;
  * **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,
- *     recursively for chains/trees (the canonical ChildOf case).
- *   - **`clear`** — remove the relation from every source; the sources survive.
- *   - **`orphan`** — leave the link intact but dangling. Reads stay safe (the
+ *   - **`delete`**, cascade: destroy every source of the dead target too,
+ *     recursively for chains and trees (the canonical ChildOf case).
+ *   - **`clear`**, remove the relation from every source. The sources survive.
+ *   - **`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
+ *     recycled slot). `targetOf` returns a dead handle until the source
  *     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 (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;
- * pass `{ multi: true }` for a multi-target relation. The two are mutually
- * exclusive — the union makes `{ exclusive: true, multi: true }` a compile
+/** Registration options. `exclusive` (one target per source) is the default.
+ * Pass `{ multi: true }` for a multi-target relation. The two are mutually
+ * exclusive, the union makes `{ exclusive: true, multi: true }` a compile
  * error (it also throws at runtime, for JS callers). `onDeleteTarget` selects
  * the cleanup policy applied to sources when a target is destroyed (default
  * `orphan`). */
@@ -58,186 +57,106 @@ export type RelationOptions = {
  * sparse component. Field 0 of a single-field schema. */
 export declare const RELATION_TARGET_FIELD = "target";
 /** Receives one canonical `(source index, sorted targets)` set during a fold
- * over a multi relation's forward sets. Targets are ascending by id; empty sets
+ * over a multi relation's forward sets. Targets are ascending by id. Empty sets
  * are never yielded (see `forEachCanonicalTargetSet`). */
 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 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:** 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
- * its sparse interaction are owned by the concrete `ExclusiveRelationStore` /
- * `MultiRelationStore` (built by `makeRelationStore`).
+/** One relation's side state, as the digest and the snapshot codec see it.
  *
- * The registry level (`Store` + `RelationService`) owns what is genuinely its
- * own — entity liveness, registration, and destroy orchestration — and drives
- * a relation through the virtual `link` /
- * `unlink` / `purgeSource` / `forEachCanonicalPair` / … without ever
- * branching on cardinality. Each cardinality keeps forward link + reverse index
- * + sparse membership in lockstep inside one method on one class, so the
- * lockstep can't be broken by missing a scattered `if (rs.exclusive)` site. */
-export declare abstract class RelationStore {
-    /** `true` → one target per source (target in the sparse field); `false` →
-     * a set of targets per source. The cardinality discriminant survives as a
-     * field because it is part of the snapshot header and the traversal/`targetOf`
-     * mode guards — but the forward *mechanics* are virtual, not branched on it. */
+ * The relations plugin owns the class. Two core-adjacent readers walk it and
+ * neither needs the forward mutators: `Store.stateHash` folds the multi target
+ * sets, and the snapshot service serializes and rebuilds them. The narrow view
+ * is what lets those two speak about a relation store without the plugin. */
+export interface RelationStoreView {
+    /** `true` → one target per source, and the target rides the backing sparse
+     * field. `false` → a target set per source, held beside the sparse tag. */
     readonly exclusive: boolean;
-    /** Backing sparse component def: `{ target: f64 }` when exclusive, a tag when
-     * multi. Carries membership (and the target, when exclusive). */
-    readonly sparse: SparseComponentDef;
-    /** Cleanup policy applied to this relation's sources when a target is
-     * 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. */
-    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.
-     * An entry is dropped the moment its set empties (`unlinkReverse`). */
-    private readonly _reverse;
-    constructor(exclusive: boolean, sparse: SparseComponentDef, store: SparseComponentStore, onDeleteTarget: OnDeleteTarget);
-    /** Record that `src` points at `tgt` in the reverse index. */
-    protected linkReverse(tgt: EntityID, src: EntityID): void;
-    /** Drop the `src → tgt` edge from the reverse index, removing the target's
-     * entry entirely once its last source is gone (so a dead-target key doesn't
-     * 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. 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
-     * without bound. This is the reclaim primitive behind `Store.compactRelations`
-     * — a cold path the host calls at scene/snapshot boundaries. It is
-     * cardinality-free (reverse-index only), so it lives on the base unchanged.
-     *
-     * Pure index reclaim: the **forward** links (the exclusive sparse target
-     * field, the multi forward set) are left untouched, so `targetOf` /
-     * `targetsOf` still return the dangling dead handle exactly as `orphan`
-     * promises. The reverse index is derived, so dropping a dead-target entry
-     * changes nothing observable except `sourcesOf` on that dead handle (which
-     * goes from the dangling sources to `[]` — meaningless either way, the target
-     * is gone) and is faithfully rebuilt by snapshot/restore from the surviving
-     * forward links. Only the **target** role can leak here: a destroyed *source*
-     * is already unlinked from every reverse set by `purgeSource`, so a live
-     * target's set never holds a dead source. `isAlive` is supplied by `Store`,
-     * which owns entity liveness. Deleting during `Map` key iteration is
-     * well-defined — already-visited and not-yet-reached keys are unaffected. */
-    pruneDeadReverse(isAlive: (id: EntityID) => boolean): number;
-    /** Sources that point at `tgt`, ascending by id (deterministic, cold-path
-     * sort) — empty when none. */
-    sourcesOf(tgt: EntityID): EntityID[];
-    /** Drop every derived side index — the reverse index and (for multi) the
-     * forward target sets. Restore path only (`restoreRelations`): the side
-     * indices are rebuilt from scratch, so they're cleared first to stay
-     * idempotent when restoring into a dirty world. The backing sparse store is
-     * cleared separately by `restoreSparseStores`. */
+    /** Fold `cb` over the multi forward target sets in canonical order, and do
+     * nothing for an exclusive relation. */
+    forEachCanonicalTargetSet(cb: CanonicalTargetSetFn): void;
+    /** Drop every derived side index. The restore path clears before it
+     * rebuilds, so restoring into a dirty world is idempotent. */
     resetIndices(): void;
-    /** Clear this relation's forward representation (multi: the side map;
-     * exclusive: nothing — its forward links live in the sparse store, cleared by
-     * `restoreSparseStores`). */
-    protected abstract _resetForward(): void;
-    /** Add a `(R, tgt)` link from `src`, keeping forward link + membership +
-     * 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. */
-    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
-     * no-op when the link isn't present. */
-    abstract unlink(src: EntityID, tgt?: EntityID): void;
-    /** Purge a destroyed **source**: drop its forward link(s) and unlink it from
-     * every target's reverse set, but leave the sparse **membership** row alone —
-     * `Store._purgeSparse` drops that (for every store) right after, so this
-     * runs first and must not double-remove. */
-    abstract purgeSource(src: EntityID): void;
-    /** The single target of source `index`, or `undefined`. Exclusive reads the
-     * sparse field; multi has no single target and returns `undefined` (matching
-     * the production `targetOf`-on-multi read, which the `DEV` guard rejects). */
-    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`. */
-    abstract targetsOf(index: number): EntityID[];
-    /** Whether source `index` holds any target under this relation (sparse
-     * membership). */
-    abstract has(index: number): boolean;
-    /** 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`.
-     * 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. `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;
-    /** Rebuild the reverse index from the forward links after a restore.
-     * Exclusive reads it back from the just-restored sparse target field (the
-     * reverse index is never serialized); multi already rebuilt its reverse edges
-     * in `restoreAddTarget`, so this is a no-op for it. `makeId` maps a source
-     * index to its full `EntityID`. */
-    abstract rebuildReverseFromForward(makeId: MakeSourceID): void;
-    /** Restore one decoded multi forward edge `(source index → tgt)` plus its
-     * reverse edge (the source's full `EntityID` is `src`). Multi only — the
-     * snapshot header guards exclusive relations out before this is reached, so
-     * the exclusive override throws defensively. */
-    abstract restoreAddTarget(index: number, tgt: EntityID, src: EntityID): void;
+    /** Restore one decoded multi forward edge and its reverse edge. */
+    restoreAddTarget(index: number, tgt: EntityID, src: EntityID): void;
+    /** Rebuild the reverse index from the forward links after a restore. */
+    rebuildReverse(createId: MakeSourceID): void;
 }
-/** Build the right `RelationStore` for a cardinality. The only construction
- * site is `Store.registerRelation`, which resolves the backing sparse store and
- * hands it in so the relation can drive forward/membership rows directly. */
-export declare function makeRelationStore(exclusive: boolean, sparse: SparseComponentDef, store: SparseComponentStore, onDeleteTarget: OnDeleteTarget): RelationStore;
-/** Serialize the relation side data that does **not** live in the sparse store
- * — i.e. each **multi** relation's forward target sets (`Map<source index,
- * Set<target>>`). Exclusive relations store their target in the backing sparse
- * field, so they ride `snapshotSparseStores` and contribute only a header
- * here. The reverse index is fully derivable (from the sparse store for
- * exclusive, from these sets for multi), so it is never serialized — it is
- * rebuilt by `restoreRelations` + the caller's exclusive-reverse pass.
- *
- * 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. Layout (integers little-endian):
- *
- *   u32 relationCount
- *   repeat relationCount times (registration / id order):
- *     u32 isMulti
- *     if multi:
- *       u32 sourceCount
- *       repeat sourceCount times (ascending source index):
- *         u32 sourceIndex
- *         u32 targetCount
- *         f64 × targetCount   (target EntityIDs, ascending) */
-export declare function snapshotRelations(relations: readonly RelationStore[]): Uint8Array;
-/** Rebuild every relation's side indices from a `snapshotRelations` buffer and
- * the already-restored sparse stores. Each relation's indices are reset first
- * (idempotent into a dirty world), then:
+/** What the relation service needs from `Store`, nothing more. The accessor
+ * members re-read the live field on every call, so capacity growth that
+ * reallocates `generations`, `entityArchetypes` or `entityRows` is always
+ * observed. Never cache their return values across mutations. */
+export interface RelationServiceHost {
+    isAlive(id: EntityID): boolean;
+    hasSparse(entityId: EntityID, def: SparseComponentDef): boolean;
+    pushSparseStore(fieldNames: string[], fieldTypes: TypedArrayTag[]): SparseComponentDef;
+    sparseStoreOf(def: SparseComponentDef): SparseComponentStore;
+    sparseStores(): readonly SparseComponentStore[];
+    generations(): Int32Array;
+    entityArchetypes(): Int32Array;
+    entityRows(): Int32Array;
+    archetypes(): readonly Archetype[];
+    forEachSparseMatch(include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, terms: QueryTerms, denseArchetypes: readonly Archetype[], cb: (entityId: EntityID) => void): void;
+}
+/** The relation service, as everything outside the plugin sees it.
  *
- *  - **multi** — forward target sets and their reverse edges are rebuilt from
- *    `bytes` (the sets aren't in the sparse store, so the bytes are the only
- *    source). `makeId` maps a source entity index to its full `EntityID`
- *    (generation from the live slot) so reverse edges key correctly.
- *  - **exclusive** — only the reset happens here; the reverse index is rebuilt
- *    by the caller from the backing sparse store (which already round-tripped
- *    through `restoreSparseStores`), since this function can't read it.
+ * `Store.relations` is public, so this is the whole crossing surface and not
+ * the world's half alone. The plugin's class implements it, and the compiler
+ * holds the two in step.
  *
- * Throws `SparseRestoreError` on any shape mismatch (relation count, an
- * exclusive/multi flag that disagrees with the registered relation, a multi
- * source index past `MAX_INDEX`, or a truncated / over-long buffer) rather than
- * silently building a corrupt index. */
-export declare function restoreRelations(relations: readonly RelationStore[], bytes: Uint8Array, makeId: (index: number) => EntityID): void;
+ * `purgeSource` and `cleanupTarget` are the one hot coupling: a dying entity
+ * loses its source role, and a target-death policy may cascade. Both sit
+ * behind a null test the destroy loop hoists, so a world without the plugin
+ * pays neither. Everything else is registration, a query driver or a `ctx`
+ * call, and cold. */
+export interface RelationHooks {
+    /** The registry, in registration order. `Store.stateHash` and the snapshot
+     * service walk it. */
+    readonly stores: readonly RelationStoreView[];
+    /** Registered relation kinds. The destroy paths gate on this. */
+    readonly count: number;
+    /** Whether any relation registered a non-`orphan` `onDeleteTarget`. The
+     * destroy paths gate the reverse-index walk on it. */
+    readonly hasTargetCleanup: boolean;
+    /** Drop a destroyed entity's forward links and its reverse edges, and leave
+     * the sparse membership row to `Store`. Runs before the sparse purge. */
+    purgeSource(entityId: EntityID): void;
+    /** Apply each relation's target-death policy to the sources of a destroyed
+     * target. A `delete` policy appends the doomed sources to `cascade`. */
+    cleanupTarget(targetId: EntityID, cascade: EntityID[]): void;
+    /** Register a relation kind. The facade's typed overloads sit on top. */
+    registerRelation(opts?: RelationOptions): RelationDef;
+    addRelation(src: EntityID, def: RelationDef, tgt: EntityID): void;
+    removeRelation(src: EntityID, def: RelationDef, tgt?: EntityID): void;
+    targetOf(src: EntityID, def: RelationDef): EntityID | undefined;
+    targetsOf(src: EntityID, def: RelationDef): EntityID[];
+    sourcesOf(tgt: EntityID, def: RelationDef): EntityID[];
+    hasRelation(src: EntityID, def: RelationDef): boolean;
+    /** Every `(source, target)` pair of one relation, the `(R, *)` wildcard. */
+    pairsOf(def: RelationDef): readonly (readonly [EntityID, EntityID])[];
+    /** Every `(relation, source)` pointing at `tgt`, the `(*, T)` wildcard. */
+    sourcesOfAny(tgt: EntityID): readonly (readonly [RelationDef, EntityID])[];
+    /** The chain from `src` up to its root, nearest ancestor first. */
+    ancestorsOf(src: EntityID, def: RelationDef): EntityID[];
+    /** The root of the chain `src` sits on. */
+    rootOf(src: EntityID, def: RelationDef): EntityID;
+    /** The subtree under `root`, breadth-first, parents before children. */
+    cascadeOf(root: EntityID, def: RelationDef): EntityID[];
+    /** Drop every reverse entry whose target died, and report the count. */
+    compactRelations(): number;
+    /** The backing sparse component of a relation, which the query terms
+     * compose against. */
+    relationBackingSparseId(def: RelationDef): SparseComponentID;
+    /** Drive a `(*, T)` wildcard query. */
+    forEachTargetMatch(target: EntityID, include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, terms: QueryTerms, cb: (entityId: EntityID) => void): void;
+    /** Drive a `hierarchy(R)` query, parents before children. */
+    forEachHierarchyMatch(include: BitSet, exclude: BitSet | null, anyOf: BitSet | null, terms: QueryTerms, denseArchetypes: readonly Archetype[], relation: RelationDef, maxDepth: number, cb: (entityId: EntityID) => void): void;
+}
 export {};
 //# sourceMappingURL=relation.d.ts.map

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/resource.d.cts

@@ -1,5 +1,5 @@
 /***
- * Resource — Typed singleton key-value storage.
+ * Resource. Typed singleton key-value storage.
  *
  * Resources are global singletons that don't belong to any entity.
  * Think: time, input state, camera config, game settings.
@@ -9,11 +9,11 @@
  * phantom type parameter, so reads are type-safe at compile time.
  *
  * 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
+ * `ecs.resources.register` for a live key throws RESOURCE_ALREADY_REGISTERED,
+ * but `ecs.resources.remove(key)` drops it (failing closed on a missing key)
+ * and frees the key to be registered again, the present → absent → present axis. Removal is
  * access-checked as a *write* (a system must declare the key in `resourceWrites`),
- * and resources stay out of `stateHash` and snapshot/resume regardless, so a
+ * and resources stay out of `stateHash` and snapshot and resume regardless, so a
  * lifecycle change never perturbs the determinism hash.
  *
  * Usage:
@@ -27,16 +27,16 @@
  *
  ***/
 /**
- * `T` is deliberately INVARIANT (via the function-typed phantom — an `in out`
+ * `T` is deliberately invariant (via the function-typed phantom, an `in out`
  * annotation is not legal on an intersection alias, so the structure carries
- * the variance): a key is used for both reads (`resource`, covariant) and
+ * the variance). A key is used for both reads (`resource`, covariant) and
  * writes (`setResource`, contravariant), so either one-sided variance is a
- * soundness hole — a covariant `T` let `ResourceKey<Cat>` widen to
- * `ResourceKey<Animal>` and `setResource` then stored a `Dog` behind a `Cat`
+ * soundness hole. A covariant `T` let `ResourceKey<Cat>` widen to
+ * `ResourceKey<Animal>`, and `setResource` then stored a `Dog` behind a `Cat`
  * key. Invariance also makes keys with different `T` mutually unassignable,
- * which is what the typed system seam's `resourceReads`/`resourceWrites`
- * narrowing keys on (§typestate). Schema-erased positions (access checks,
- * declaration lists) must use `ResourceKey<any>` — `ResourceKey<unknown>` no
+ * which is what the typed system seam's `resourceReads` and `resourceWrites`
+ * narrowing keys on (system.ts). Schema-erased positions (access checks,
+ * declaration lists) must use `ResourceKey<any>`, `ResourceKey<unknown>` no
  * longer erases.
  */
 declare const __resourceValue: unique symbol;
@@ -45,7 +45,7 @@ export type ResourceKey<T> = symbol & {
 };
 export declare function resourceKey<T>(name: string): ResourceKey<T>;
 /** Recover a key's value type: `ResourceValueOf<typeof TimeRes>` is the Time
- * shape. The typed `SystemContext` resource surface infers the KEY type (to
+ * shape. The typed `SystemContext` resource surface infers the key type (to
  * check it against the declared-access union) and recovers `T` through this,
  * instead of taking `ResourceKey<T>` directly. */
 export type ResourceValueOf<K> = K extends ResourceKey<infer T> ? T : never;

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

@@ -1,5 +1,5 @@
 /***
- * Resource — Typed singleton key-value storage.
+ * Resource. Typed singleton key-value storage.
  *
  * Resources are global singletons that don't belong to any entity.
  * Think: time, input state, camera config, game settings.
@@ -9,11 +9,11 @@
  * phantom type parameter, so reads are type-safe at compile time.
  *
  * 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
+ * `ecs.resources.register` for a live key throws RESOURCE_ALREADY_REGISTERED,
+ * but `ecs.resources.remove(key)` drops it (failing closed on a missing key)
+ * and frees the key to be registered again, the present → absent → present axis. Removal is
  * access-checked as a *write* (a system must declare the key in `resourceWrites`),
- * and resources stay out of `stateHash` and snapshot/resume regardless, so a
+ * and resources stay out of `stateHash` and snapshot and resume regardless, so a
  * lifecycle change never perturbs the determinism hash.
  *
  * Usage:
@@ -27,16 +27,16 @@
  *
  ***/
 /**
- * `T` is deliberately INVARIANT (via the function-typed phantom — an `in out`
+ * `T` is deliberately invariant (via the function-typed phantom, an `in out`
  * annotation is not legal on an intersection alias, so the structure carries
- * the variance): a key is used for both reads (`resource`, covariant) and
+ * the variance). A key is used for both reads (`resource`, covariant) and
  * writes (`setResource`, contravariant), so either one-sided variance is a
- * soundness hole — a covariant `T` let `ResourceKey<Cat>` widen to
- * `ResourceKey<Animal>` and `setResource` then stored a `Dog` behind a `Cat`
+ * soundness hole. A covariant `T` let `ResourceKey<Cat>` widen to
+ * `ResourceKey<Animal>`, and `setResource` then stored a `Dog` behind a `Cat`
  * key. Invariance also makes keys with different `T` mutually unassignable,
- * which is what the typed system seam's `resourceReads`/`resourceWrites`
- * narrowing keys on (§typestate). Schema-erased positions (access checks,
- * declaration lists) must use `ResourceKey<any>` — `ResourceKey<unknown>` no
+ * which is what the typed system seam's `resourceReads` and `resourceWrites`
+ * narrowing keys on (system.ts). Schema-erased positions (access checks,
+ * declaration lists) must use `ResourceKey<any>`, `ResourceKey<unknown>` no
  * longer erases.
  */
 declare const __resourceValue: unique symbol;
@@ -45,7 +45,7 @@ export type ResourceKey<T> = symbol & {
 };
 export declare function resourceKey<T>(name: string): ResourceKey<T>;
 /** Recover a key's value type: `ResourceValueOf<typeof TimeRes>` is the Time
- * shape. The typed `SystemContext` resource surface infers the KEY type (to
+ * shape. The typed `SystemContext` resource surface infers the key type (to
  * check it against the declared-access union) and recovers `T` through this,
  * instead of taking `ResourceKey<T>` directly. */
 export type ResourceValueOf<K> = K extends ResourceKey<infer T> ? T : never;

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

@@ -1,17 +1,17 @@
 /***
- * ResourceRegistry — the world's symbol-keyed resource dictionary.
+ * ResourceRegistry, the world's symbol-keyed resource dictionary.
  *
- * Extracted from `Store`, which keeps one-line delegations; fully
+ * Extracted from `Store`, which keeps one-line delegations. Fully
  * self-contained (no Store reach-back). Resources stay out of `stateHash` and
- * out of snapshot/resume — this is host-side state, not simulation state.
+ * out of snapshot and resume. This is host-side state, not simulation state.
  ***/
 export declare class ResourceRegistry {
-    private readonly map;
+    private readonly _values;
     register(key: symbol, value: unknown): void;
     get(key: symbol): unknown;
     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
+     * `get` and `set`). Afterwards the key is free to `register` again, the
      * present → absent → present lifecycle. Purely a host-side
      * dictionary delete with no determinism-hash effect. */
     remove(key: symbol): void;

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

@@ -1,17 +1,17 @@
 /***
- * ResourceRegistry — the world's symbol-keyed resource dictionary.
+ * ResourceRegistry, the world's symbol-keyed resource dictionary.
  *
- * Extracted from `Store`, which keeps one-line delegations; fully
+ * Extracted from `Store`, which keeps one-line delegations. Fully
  * self-contained (no Store reach-back). Resources stay out of `stateHash` and
- * out of snapshot/resume — this is host-side state, not simulation state.
+ * out of snapshot and resume. This is host-side state, not simulation state.
  ***/
 export declare class ResourceRegistry {
-    private readonly map;
+    private readonly _values;
     register(key: symbol, value: unknown): void;
     get(key: symbol): unknown;
     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
+     * `get` and `set`). Afterwards the key is free to `register` again, the
      * present → absent → present lifecycle. Purely a host-side
      * dictionary delete with no determinism-hash effect. */
     remove(key: symbol): void;

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

@@ -1 +1 @@
-{"version":3,"file":"resource_registry.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/resource_registry.ts"],"names":[],"mappings":"AAAA;;;;;;KAMK;AAIL,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAmC;IAEhD,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAW3C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAWzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAW7C;;;4DAGwD;IACjD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAWzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAGhC"}
+{"version":3,"file":"resource_registry.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/resource_registry.ts"],"names":[],"mappings":"AAAA;;;;;;KAMK;AAIL,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAEpD,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAW3C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAWzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAW7C;;;4DAGwD;IACjD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAWzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAGhC"}

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

@@ -0,0 +1,24 @@
+import { AnyTypedArray } from '../../type_primitives/index.cjs';
+/** A view of `buf`'s bytes whose class depends on the element width alone. The
+ * unsigned class of each width, and `Float64Array` for eight bytes. A column
+ * that already has that class is returned as is. The view has an explicit
+ * length, so it is a fixed-length view on every backing. */
+export declare function widthView(kind: number, buf: AnyTypedArray): AnyTypedArray;
+/** The stored representation of `v` in a column of kind `kind`, as the
+ * width-canonical view of that column (`widthView`) reads it back. A store of
+ * the result through that view leaves the same bytes as a store of `v` through
+ * the true view: the integer kinds keep the low bits of `ToInt32(v)`, which is
+ * what each typed array keeps. `f32` rounds through a scratch `Float32Array`
+ * `f64` is itself. */
+export declare function toWidthBits(kind: number, v: number): number;
+/** Read one element through the access site of the column's class, found from
+ * the column itself. For the mixed-type accessor in ref.ts, which knows the
+ * column but not its tag. */
+export declare function readElemOf(buf: AnyTypedArray, row: number): number;
+/** The pair of `readElemOf`. */
+export declare function writeElemOf(buf: AnyTypedArray, row: number, v: number): void;
+/** Write one element through the access site of its kind. For the per-field
+ * paths (`writeFields`, `writeFlatElem`), where the column is known one at a
+ * time. */
+export declare function writeElem(kind: number, buf: AnyTypedArray, row: number, v: number): void;
+//# sourceMappingURL=row_kinds.d.ts.map

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

@@ -0,0 +1,24 @@
+import { AnyTypedArray } from '../../type_primitives/index.js';
+/** A view of `buf`'s bytes whose class depends on the element width alone. The
+ * unsigned class of each width, and `Float64Array` for eight bytes. A column
+ * that already has that class is returned as is. The view has an explicit
+ * length, so it is a fixed-length view on every backing. */
+export declare function widthView(kind: number, buf: AnyTypedArray): AnyTypedArray;
+/** The stored representation of `v` in a column of kind `kind`, as the
+ * width-canonical view of that column (`widthView`) reads it back. A store of
+ * the result through that view leaves the same bytes as a store of `v` through
+ * the true view: the integer kinds keep the low bits of `ToInt32(v)`, which is
+ * what each typed array keeps. `f32` rounds through a scratch `Float32Array`
+ * `f64` is itself. */
+export declare function toWidthBits(kind: number, v: number): number;
+/** Read one element through the access site of the column's class, found from
+ * the column itself. For the mixed-type accessor in ref.ts, which knows the
+ * column but not its tag. */
+export declare function readElemOf(buf: AnyTypedArray, row: number): number;
+/** The pair of `readElemOf`. */
+export declare function writeElemOf(buf: AnyTypedArray, row: number, v: number): void;
+/** Write one element through the access site of its kind. For the per-field
+ * paths (`writeFields`, `writeFlatElem`), where the column is known one at a
+ * time. */
+export declare function writeElem(kind: number, buf: AnyTypedArray, row: number, v: number): void;
+//# sourceMappingURL=row_kinds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"row_kinds.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/row_kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqCK;AAEL,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAgB3D;;;4DAG4D;AAC5D,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG,aAAa,CAYzE;AAOD;;;;;sBAKsB;AACtB,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB3D;AAED;;6BAE6B;AAC7B,wBAAgB,UAAU,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAmBlE;AAED,gCAAgC;AAChC,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CA2B5E;AAED;;WAEW;AACX,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CA2BxF"}