@oasys/oecs 0.3.1 → 0.4.0

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

@@ -0,0 +1,231 @@
+import { Brand } from '../../type_primitives';
+import { EntityID } from './entity';
+import { SparseComponentDef, SparseComponentStore } from './sparse_store';
+/** Relation handle id. A separate id space from `ComponentID` and
+ * `SparseComponentID` — it indexes `Store`'s relation registry. The numeric
+ * value is the registration order, stable for the lifetime of the ECS. */
+export type RelationID = Brand<number, "relation_id">;
+declare const __relationBrand: unique symbol;
+export type RelationDef = RelationID & {
+    readonly [__relationBrand]: "relation";
+};
+/** Access sentinel for the `(*, T)` wildcard query iteration
+ * (`Query.forEachRelatedTo`, #579). 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`
+ * instead; `accessCheck.checkRelationReadAny` 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;
+/** Cleanup policy applied to a relation's **sources** when one of its
+ * **targets** is destroyed (#473). 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
+ *     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.
+ */
+export type OnDeleteTarget = "delete" | "clear" | "orphan";
+/** Default on-target-delete policy: leave the link dangling (pre-#473
+ * 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 — passing both throws. `onDeleteTarget` selects the cleanup
+ * policy applied to sources when a target is destroyed (default `orphan`). */
+export interface RelationOptions {
+    readonly exclusive?: boolean;
+    readonly multi?: boolean;
+    readonly onDeleteTarget?: OnDeleteTarget;
+}
+/** Field name carrying the target `EntityID` on an exclusive relation's backing
+ * 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
+ * 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 #470 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
+ * 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`).
+ *
+ * `Store` 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. */
+    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 (#473). `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). */
+    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 (#491). 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`. */
+    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 (#495). */
+    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` (#498 item 4). */
+    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`
+     * (#498 item 1). 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
+     * 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;
+}
+/** 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 (#470). 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:
+ *
+ *  - **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.
+ *
+ * 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;
+export {};
+//# sourceMappingURL=relation.d.ts.map

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

@@ -0,0 +1 @@
+{"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.ts

@@ -0,0 +1,33 @@
+/***
+ * 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.
+ *
+ * Each resource is identified by a unique symbol (ResourceKey<T>) and
+ * 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
+ * `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
+ * 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
+ * lifecycle change never perturbs the determinism hash.
+ *
+ * Usage:
+ *
+ *   const TimeRes = resourceKey<{ delta: number; elapsed: number }>("Time");
+ *   world.registerResource(TimeRes, { delta: 0, elapsed: 0 });
+ *   const time = world.resource(TimeRes);
+ *   // time.delta → number, time.elapsed → number
+ *   world.removeResource(TimeRes);                             // present → absent
+ *   world.registerResource(TimeRes, { delta: 0, elapsed: 0 }); // → present again
+ *
+ ***/
+export type ResourceKey<T> = symbol & {
+    readonly __phantom: T;
+};
+export declare function resourceKey<T>(name: string): ResourceKey<T>;
+//# sourceMappingURL=resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/resource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BK;AAIL,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,MAAM,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAA;CAAE,CAAC;AAEhE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAE3D"}

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

@@ -0,0 +1,85 @@
+import { ArchetypeViews } from '../store';
+/** Magic for the combined world-snapshot frame (`"WRS0"` little-endian). Distinct
+ * from the SAB `STORE_MAGIC` so a bare dense snapshot fed to `restoreInto` is
+ * rejected with a clear error instead of being mis-parsed as a combined frame. */
+export declare const WORLD_SNAPSHOT_MAGIC = 810766935;
+/** Combined-frame format version. Bumped if the section framing or host-state
+ * layout changes. Independent of `SIM_ABI_VERSION` (which gates the dense bytes). */
+export declare const WORLD_SNAPSHOT_VERSION = 1;
+/** Thrown by `Store.restoreInto` (and the helpers here) when a combined snapshot
+ * is malformed, carries the wrong magic/version, or targets a world whose
+ * archetype/component registration doesn't match the snapshot. Mirrors
+ * `StoreRestoreError` / `SparseRestoreError` so callers see one error class per
+ * restore failure mode. */
+export declare class WorldRestoreError extends Error {
+    constructor(message: string);
+}
+/** Per-archetype host-side row bookkeeping the SAB doesn't carry authoritatively. */
+export interface ArchetypeRowState {
+    readonly archetypeId: number;
+    /** Total live rows (enabled + disabled). */
+    readonly length: number;
+    /** Enabled-row partition boundary (#577): rows `[0, enabledCount)` enabled. */
+    readonly enabledCount: number;
+}
+/** The host-side state a snapshot captures alongside the dense + sparse bytes. */
+export interface HostState {
+    /** World tick at snapshot time (`Store._tick`). */
+    readonly tick: number;
+    /** Entity-index high-water (count of slots ever issued). Also mirrored in the
+     * SAB region's `length` header; carried here for a cross-check on restore. */
+    readonly entityHighWater: number;
+    /** Live entity count. */
+    readonly entityAliveCount: number;
+    /** Recycle free-list in live order (LIFO: the last element is the next slot
+     * `createEntity` hands out). */
+    readonly freeIndices: readonly number[];
+    /** Per-archetype row state, one entry per SAB-backed archetype. */
+    readonly archetypeRows: readonly ArchetypeRowState[];
+}
+/** Serialize host-state to a self-contained little-endian byte buffer. Layout:
+ *
+ *   [u32 tick][u32 highWater][u32 alive_count]
+ *   [u32 freeCount][u32 free_index × freeCount]
+ *   [u32 archCount][(u32 id, u32 length, u32 enabled_count) × archCount]
+ */
+export declare function serializeHostState(hs: HostState): Uint8Array;
+/** Parse host-state bytes produced by `serializeHostState`. Throws
+ * `WorldRestoreError` on truncation or a trailing-byte (non-canonical) buffer. */
+export declare function parseHostState(bytes: Uint8Array): HostState;
+/** Assemble the combined world-snapshot frame from its three sections. Layout:
+ *
+ *   [u32 magic][u32 version][u32 denseLen][u32 sparseLen][u32 hostLen]
+ *   [dense][sparse][host]
+ */
+export declare function frameWorldSnapshot(dense: Uint8Array, sparse: Uint8Array, host: Uint8Array): Uint8Array;
+/** The three sections of a combined frame, as zero-copy subviews over `bytes`. */
+export interface WorldSnapshotSections {
+    readonly dense: Uint8Array;
+    readonly sparse: Uint8Array;
+    readonly host: Uint8Array;
+}
+/** Split a combined frame back into its sections. Validates magic, version, and
+ * an exact (no trailing bytes) frame; throws `WorldRestoreError` otherwise. */
+export declare function unframeWorldSnapshot(bytes: Uint8Array): WorldSnapshotSections;
+/**
+ * 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
+ * *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`
+ * keeps the check non-mutating, so a mismatch leaves the live world untouched.
+ *
+ * Asserts: the dense section's SAB magic + ABI, that its archetype set +
+ * per-archetype `componentMask` + per-column `(componentId, fieldId, typeTag)`
+ * match the live store's exactly (so every live `Archetype.refreshViews` finds
+ * its region and no snapshot archetype is orphaned), and that the entity-index
+ * capacity matches (the region is sized once at construction). The archetype
+ * graph is rebuilt from registration code, not the snapshot (mirroring
+ * `restoreSparse`'s "registered in the same order" contract). Throws
+ * `WorldRestoreError` on any mismatch / malformed section.
+ */
+export declare function assertDenseLayoutMatchesLive(dense: Uint8Array, live: ReadonlyMap<number, ArchetypeViews>, liveEntityIndexCapacity: number): void;
+//# sourceMappingURL=resume.d.ts.map

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

@@ -0,0 +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,sBAAsB,IAAI,CAAC;AAExC;;;;2BAI2B;AAC3B,qBAAa,iBAAkB,SAAQ,KAAK;gBAC/B,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;kFACkF;AAClF,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;+EAC+E;AAC/E,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"}

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

@@ -0,0 +1,75 @@
+import { ComponentDef } from './component';
+import { ResourceKey } from './resource';
+import { Query } from './query';
+/**
+ * The read-only slice of `SystemContext` a run condition is handed. Deliberately
+ * narrow — a condition can read the ECS tick and resources, but has no path to
+ * mutate the world or read component columns directly (component reads go
+ * through a captured `Query`). `SystemContext` structurally satisfies this, so
+ * the schedule passes the live context unchanged.
+ */
+export interface ConditionContext {
+    /** Current ECS tick — the deterministic clock built-ins key off. */
+    readonly ecsTick: number;
+    /** Read a resource value (checked against `resourceReads` in `__DEV__`). */
+    resource<T>(key: ResourceKey<T>): T;
+    /** Membership probe for a resource — unchecked, mirrors `hasComponent`. */
+    hasResource<T>(key: ResourceKey<T>): boolean;
+}
+/**
+ * A per-tick gate. `evaluate` returns `true` to run the gated system(s), `false`
+ * to skip them this tick. `reads` / `resourceReads` declare the predicate's
+ * read surface for `accessCheck` (dev) and the future parallel scheduler's
+ * read-edge graph; both are optional (absent reads as empty).
+ */
+export interface RunCondition {
+    /** Human-readable label, surfaced in dev access-violation diagnostics. */
+    readonly name: string;
+    /** Pure, deterministic predicate. See the two hard rules in the file header. */
+    readonly evaluate: (ctx: ConditionContext) => boolean;
+    /** Components the predicate reads (via a captured query). Forward-looking
+     *  metadata — `ConditionContext` exposes no direct column read, so this is
+     *  not runtime-checkable today, but it is the read-edge a parallel scheduler
+     *  will consume. */
+    readonly reads?: readonly ComponentDef[];
+    /** Resources the predicate reads. Validated at runtime in `__DEV__` when the
+     *  condition evaluates inside `accessCheck.enterCondition`. */
+    readonly resourceReads?: readonly ResourceKey<unknown>[];
+}
+/**
+ * Run the gated system(s) only while a resource equals `expected` (strict `===`,
+ * so reference identity for objects). The canonical "feature flag / game phase"
+ * gate — flip `world.setResource(key, …)` and the whole group toggles.
+ */
+export declare function runIfResourceEq<T>(key: ResourceKey<T>, expected: T): RunCondition;
+/**
+ * Run the gated system(s) once every `n` ticks — on ticks congruent to `offset`
+ * mod `n`. Keyed off the deterministic ECS tick, so it carries no private
+ * state and replays bit-identically. `offset` is a **phase shift taken mod `n`**
+ * (default `0` ⇒ fires on tick 0, n, 2n, …; `offset` and `offset + n` are the
+ * same phase, and a negative offset wraps), normalized once here into `[0, n)`.
+ * `n` must be a positive integer and `offset` an integer.
+ *
+ * The normalization isn't cosmetic: `(ecsTick - offset) % n` with a raw
+ * `offset ≥ n` (or negative) leans on JS's signed `%` yielding `-0` for a
+ * negative multiple (and `-0 === 0`) to stay congruent — correct, but load-
+ * bearing on a quirk. Folding `offset` into `[0, n)` up front makes the phase
+ * explicit: the per-tick dividend `ecsTick - phase` may still be negative
+ * (when `ecsTick < phase`), but with `phase ∈ [0, n)` it is never a *negative
+ * multiple* of `n` — it lands in `[-(n-1), -1]`, which holds no multiple of `n`
+ * — so `%` never produces `-0` and the check needs no signed-zero reliance.
+ */
+export declare function runEveryNTicks(n: number, offset?: number): RunCondition;
+/**
+ * Run the gated system(s) only when a query matches at least one (enabled)
+ * entity — flecs `runIf` over a query. The query is captured at config time;
+ * its component defs are declared as `reads`. `count()` is a membership sum over
+ * matching archetypes (no column reads), so it trips no `accessCheck` read.
+ *
+ * The query must be **dense-only**: `count()` asserts this in `__DEV__`
+ * (`_assertDenseOnly`), so pass a plain `world.query(...)` — a query carrying
+ * `.optional(...)` or sparse terms throws. Gate on sparse membership with a
+ * custom predicate over `forEachEntity` instead.
+ */
+export declare function runIfAnyMatch(query: Query<readonly ComponentDef[]>): RunCondition;
+//# sourceMappingURL=run_condition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run_condition.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/run_condition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BK;AAEL,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACpC,2EAA2E;IAC3E,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;CAC7C;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IACtD;;;wBAGoB;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC;mEAC+D;IAC/D,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACzD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAMjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,YAAY,CAclE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,YAAY,EAAE,CAAC,GAAG,YAAY,CAMjF"}

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

@@ -0,0 +1,133 @@
+import { SystemContext } from './query';
+import { SystemDescriptor } from './system';
+import { ComputeBackend } from './compute_backend';
+import { RunCondition } from './run_condition';
+export declare enum SCHEDULE {
+    PRE_STARTUP = "PRE_STARTUP",
+    STARTUP = "STARTUP",
+    POST_STARTUP = "POST_STARTUP",
+    FIXED_UPDATE = "FIXED_UPDATE",
+    PRE_UPDATE = "PRE_UPDATE",
+    UPDATE = "UPDATE",
+    POST_UPDATE = "POST_UPDATE"
+}
+/**
+ * An opaque handle for a named group of systems (#576). A set carries a shared
+ * run condition and shared ordering that every member inherits. Sets are
+ * identified by **object identity**, not by name — create one with
+ * `systemSet(name)`, hold the handle, and reuse it across `addSystems`
+ * (`SystemEntry.set`) and `Schedule.configureSet`. The `name` is for
+ * diagnostics only.
+ */
+export interface SystemSet {
+    readonly name: string;
+}
+/** Create a `SystemSet` handle (#576). Two calls with the same name are two
+ * distinct sets — keep the returned handle and pass it around. */
+export declare function systemSet(name: string): SystemSet;
+/** A `before`/`after` ordering target: either a concrete system or a whole set
+ * (expanded to its members within the same phase at sort time). */
+export type SystemOrderingTarget = SystemDescriptor | SystemSet;
+/** Shared configuration applied to a `SystemSet` via `configureSet` (#576).
+ * Accumulates across calls — conditions AND together, ordering targets union. */
+export interface SystemSetConfig {
+    /** Condition(s) every member is gated by (ANDed with each member's own). */
+    runIf?: RunCondition | readonly RunCondition[];
+    /** Every member runs before each of these targets. */
+    before?: readonly SystemOrderingTarget[];
+    /** Every member runs after each of these targets. */
+    after?: readonly SystemOrderingTarget[];
+}
+export interface SystemOrdering {
+    before?: readonly SystemOrderingTarget[];
+    after?: readonly SystemOrderingTarget[];
+}
+export interface SystemEntry {
+    system: SystemDescriptor;
+    ordering?: SystemOrdering;
+    /** Run condition(s) gating just this system — ANDed with any set conditions
+     * it inherits (#576). A `false` verdict skips the body that tick. */
+    runIf?: RunCondition | readonly RunCondition[];
+    /** Set membership — the system inherits each set's shared condition and
+     * ordering (#576). */
+    set?: SystemSet | readonly SystemSet[];
+}
+export declare class Schedule {
+    private readonly labelSystems;
+    private readonly sortedCache;
+    private readonly systemIndex;
+    private readonly systemLastRun;
+    private readonly gatedSystems;
+    private readonly setConditions;
+    private readonly setOrdering;
+    private nextInsertionOrder;
+    private _backend;
+    constructor();
+    addSystems(label: SCHEDULE, ...entries: (SystemDescriptor | SystemEntry)[]): void;
+    /**
+     * Configure a `SystemSet` (#576) — its shared run condition(s) and/or
+     * ordering, inherited by every member. Additive and order-independent w.r.t.
+     * `addSystems`: conditions accumulate (ANDed), ordering targets union, and
+     * a member added before or after this call picks the configuration up.
+     */
+    configureSet(set: SystemSet, config: SystemSetConfig): void;
+    removeSystem(system: SystemDescriptor): void;
+    /** Attach (or, with `null`, detach) the opt-in compute backend (#622). Driven
+     * by `ECS.attachBackend`; routes any scheduled system carrying a
+     * `backendHandle` to `backend.run(handle)` in place of its `fn`. */
+    setBackend(backend: ComputeBackend | null): void;
+    runStartup(ctx: SystemContext, tick: number): void;
+    runUpdate(ctx: SystemContext, deltaTime: number, tick: number): void;
+    runFixedUpdate(ctx: SystemContext, fixedDt: number, tick: number): void;
+    hasFixedSystems(): boolean;
+    getAllSystems(): SystemDescriptor[];
+    hasSystem(system: SystemDescriptor): boolean;
+    clear(): void;
+    private runLabel;
+    /**
+     * Whether a gated system runs this tick — the AND of its own conditions and
+     * every set it belongs to. A set's conditions are evaluated at most once per
+     * phase (memoized in `setVerdicts`) and the verdict gates every member of the
+     * set uniformly; a `configureSet` between phases is still honored because the
+     * memo lives only for a single `runLabel` pass. Short-circuits on the first
+     * `false`. The system's own conditions evaluate per system, in canonical order.
+     */
+    private shouldRun;
+    /** Evaluate a condition list with AND semantics. Each predicate runs inside a
+     * reads-only `accessCheck` span (dev), so a condition that reads an
+     * undeclared resource — or attempts any mutation — throws. */
+    private evalConditions;
+    private getSorted;
+    /**
+     * Delegates to the shared topologicalSort utility.
+     * Builds the dependency edge map from before/after constraints, then
+     * catches any cycle TypeError and re-throws as ECSError.
+     */
+    private sortSystems;
+    /**
+     * Add the topo edges for one ordering list (#576). For `"before"` the source
+     * runs before each target (edge source→target); for `"after"` it runs after
+     * each target (edge target→source). A `SystemSet` target expands to every
+     * member within this phase (self-edges skipped, so a member ordered against
+     * its own set is a no-op); a descriptor target absent from this phase is
+     * dropped — with a dev warning only for a concrete system, since a set
+     * legitimately expands to nothing when its members live in another phase.
+     */
+    private resolveEdges;
+    /** Push one directed edge into the adjacency map. Both endpoints are known to
+     * be in this phase (callers guard), so `edges.get(...)` is non-null. */
+    private addDirectedEdge;
+    /**
+     * Dev-only diagnostic for an ordering edge that was dropped during sort.
+     *
+     * Cross-label ordering is impossible by design (`nodeSet` is per-label), so
+     * a target registered in *another* phase is skipped silently — that's the
+     * intended isolation. But a target unknown to *every* phase is almost
+     * certainly a typo or a system that was never scheduled; without this warning
+     * the constraint vanishes and the system runs in insertion-order tiebreak as
+     * if unconstrained, with nothing to distinguish mistake from intent. Compiled
+     * out of production builds by the `__DEV__` guards at the call sites.
+     */
+    private warnDroppedEdge;
+}
+//# sourceMappingURL=schedule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/schedule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmCK;AAIL,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKpD,oBAAY,QAAQ;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,YAAY,iBAAiB;IAC7B,UAAU,eAAe;IACzB,MAAM,WAAW;IACjB,WAAW,gBAAgB;CAC3B;AAMD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;kEACkE;AAClE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAEjD;AAED;mEACmE;AACnE,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG,SAAS,CAAC;AAEhE;iFACiF;AACjF,MAAM,WAAW,eAAe;IAC/B,4EAA4E;IAC5E,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,CAAC;IAC/C,sDAAsD;IACtD,MAAM,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzC,qDAAqD;IACrD,KAAK,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC9B,MAAM,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzC,KAAK,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,WAAW;IAC3B,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;yEACqE;IACrE,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,CAAC;IAC/C;0BACsB;IACtB,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,SAAS,EAAE,CAAC;CACvC;AA8BD,qBAAa,QAAQ;IACpB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0C;IACvE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgD;IAC5E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8C;IAC1E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4C;IAI1E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgD;IAG7E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6C;IAC3E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAGd;IACd,OAAO,CAAC,kBAAkB,CAAK;IAM/B,OAAO,CAAC,QAAQ,CAA+B;;IAYxC,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,gBAAgB,GAAG,WAAW,CAAC,EAAE,GAAG,IAAI;IAwCxF;;;;;OAKG;IACI,YAAY,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI;IA0B3D,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IA+BnD;;wEAEoE;IAC7D,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI;IAIhD,UAAU,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAMlD,SAAS,CAAC,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAMpE,cAAc,CAAC,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIvE,eAAe,IAAI,OAAO;IAK1B,aAAa,IAAI,gBAAgB,EAAE;IAUnC,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO;IAI5C,KAAK,IAAI,IAAI;IAYpB,OAAO,CAAC,QAAQ;IA6DhB;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAwBjB;;kEAE8D;IAC9D,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,SAAS;IAWjB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IA2FnB;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;IA4BpB;4EACwE;IACxE,OAAO,CAAC,eAAe;IAevB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,eAAe;CAiBvB"}