@oasys/oecs 0.5.4 → 0.6.0

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

@@ -0,0 +1,296 @@
+import { Store } from './store.cjs';
+import { FrameTraceSink } from './frame_trace.cjs';
+import { EntityID } from './entity.cjs';
+import { ComponentDef, AttachValuesArg, SchemaOf, FieldValues } from './component.cjs';
+import { SparseComponentDef, SparseSchemaOf } from './sparse_store.cjs';
+import { RelationDef } from './relation.cjs';
+import { SystemAccess, DeclaredRead, DeclaredWrite, DeclaredAdd, DeclaredRemove, DeclaredSparseRead, DeclaredSparseWrite, DeclaredRelationRead, DeclaredRelationWrite, DeclaredResourceRead, DeclaredResourceWrite, DespawnArg } from './system.cjs';
+import { ComponentCursor, ComponentRef, ReadonlyComponentCursor, ReadonlyComponentRef } from './ref.cjs';
+import { EventKey, EventReader, EventShape, SignalKey } from './event.cjs';
+import { ResourceKey, ResourceValueOf } from './resource.cjs';
+/**
+ * A `BundleOrDef` whose def is constrained to the enclosing system's declared
+ * add surface (system.ts). The bundle branch restates `Bundle`'s shape with
+ * the def slot narrowed, intersecting `Bundle<any> & { def: … }` instead
+ * would put two `ComponentDef` instantiations in one intersection, which TS
+ * relates leniently (see the access-typing notes in system.ts).
+ *
+ * The outer conditional is a deliberate no-op (`[D] extends [unknown]` is
+ * always true): it makes the variance of `D`, and therefore of the access
+ * param `A` threaded through `Commands` and `SystemContext`. Unmeasurable to
+ * the compiler. A measurable (plain-union) definition here gets `A` marked
+ * reliably contravariant, variance-based comparison then rejects
+ * `SystemContext<Narrow> → SystemContext` without the structural fallback,
+ * and every helper taking a bare `SystemContext` stops accepting typed
+ * contexts. Unmeasurable variance forces the structural path, where class
+ * methods compare bivariantly and the conversion holds.
+ *
+ * The inner `D extends ComponentDef ? … : never` Distributes over the declared
+ * add-set union, so each raw-literal branch carries its own def's schema
+ * (`Partial<FieldValues<SchemaOf<D>>>`) rather than the erased
+ * `Partial<Record<string, number>>`. A hand-written `{ def: Vel, values: { x }}`
+ * whose fields don't match its def is then rejected in a declared-access system,
+ * matching the `StrictBundles` guarantee on the `ecs.*` surface. A permissive
+ * context (`add: ComponentDef<any>`, an unnarrowed or `exclusive` system)
+ * keeps the loose shape, which is the point of opting out of narrowing. The
+ * outer no-op is preserved, so the variance invariant above still holds
+ * (verified: the `permissiveHelper(ctx)` assertion still compiles).
+ */
+export type DeclaredBundleOrDef<D> = [D] extends [unknown] ? D extends ComponentDef ? D | {
+    readonly def: D;
+    readonly values: Readonly<Partial<FieldValues<SchemaOf<D>>>>;
+} : never : never;
+/**
+ * Deferred structural-command facade (Bevy `Commands`).
+ * Namespaces the deferred structural ops so the call site is self-documenting:
+ * `ctx.commands.add(e, …)` is *always* deferred (applied at the phase flush),
+ * ending the collision where `ecs.addComponent` (immediate) and a bare
+ * `ctx.addComponent` (deferred) would share a name with opposite timing. Takes
+ * varargs callable bundles, so one shape, `commands.spawn(bundle(Pos,{x,y}), bundle(Vel,{vx:1}))`,
+ * serves spawn and add. This is the only deferred surface: the bare
+ * `ctx.addComponent`, `ctx.removeComponent`, `ctx.disable` and `ctx.enable`
+ * duplicates were removed in 0.5.0, completing the receiver-implies-timing
+ * rule (`ecs.*` immediate, `ctx.commands.*` deferred) that 0.5.0 started for
+ * spawn and despawn.
+ *
+ * `A` narrows the def-taking methods to the enclosing system's declared access
+ * (system.ts). The default is fully permissive.
+ *
+ * `out A` (declared covariance) is deliberate: every use of `A` sits inside a
+ * declared-access conditional, whose variance the compiler cannot measure,
+ * left unannotated, the measured verdict rejects `Commands<Narrow> →
+ * Commands` (the direction every permissive consumer needs). Covariance is
+ * the honest direction: a context with more declared access is usable where
+ * one with less is expected. The checks themselves are per-instantiation, so
+ * the annotation does not weaken them.
+ */
+export declare class Commands<out A extends SystemAccess = SystemAccess> {
+    private readonly _store;
+    constructor(_store: Store);
+    /** Spawn from bundles. The create is immediate, so the id returns now. The
+     *  component attaches are deferred to the phase flush, so until that flush the
+     *  entity exists in its empty and partial archetype and a query running later in
+     *  the same phase can observe it half-built. (Same semantics as
+     *  `ctx.commands.spawn()` followed by `ctx.commands.add`. A fully deferred
+     *  id-reservation spawn, à la Bevy, is a separate follow-up.) */
+    spawn(...items: DeclaredBundleOrDef<A["add"]>[]): EntityID;
+    /** Attach bundles to an existing entity (deferred). Bundles zero-fill
+     * omitted fields. */
+    add(entityId: EntityID, ...items: DeclaredBundleOrDef<A["add"]>[]): this;
+    /** Explicit complete-values attach (deferred), the compile-checked shape
+     * where a typo'd or missing field is a compile error, mirroring the
+     * immediate `ecs.addComponent(e, def, values)`. Tags take no values
+     * argument (`AttachValuesArg`). */
+    add<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredAdd<A, D>, ...values: AttachValuesArg<SchemaOf<D>>): this;
+    /** Remove a component (deferred). */
+    remove<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredRemove<A, D>): this;
+    /** Destroy an entity (deferred). */
+    despawn(entityId: DespawnArg<A>): this;
+    /** Buffer `entityId` to be disabled at the phase flush (idempotent).
+     * Deferred because a toggle is an in-archetype row swap, which would corrupt
+     * a `forEach` SoA loop iterating that archetype if applied mid-system (it
+     * reorders the dense columns being read). A disabled entity is excluded from
+     * default queries. Opt back in per query with `.includeDisabled()`. The
+     * immediate read is `ctx.isDisabled`. */
+    disable(entityId: EntityID): this;
+    /** Buffer `entityId` to be re-enabled at the phase flush (idempotent).
+     * Deferred for the same row-swap reason as `disable`. */
+    enable(entityId: EntityID): this;
+}
+/**
+ * The per-system world facade. `A` is the system's declared access surface
+ * (system.ts): the config-form `registerSystem` computes it from
+ * the literal `reads` and `writes`/… declarations and every guarded method below
+ * checks its handle argument against the matching union at compile time,
+ * the same rules `accessCheck` enforces at runtime in `DEV`. The default
+ * `A = SystemAccess` is fully permissive, so a bare `SystemContext` (helper
+ * functions, host-side code, explicitly-annotated escape hatches) behaves
+ * exactly as before, and every narrowed `SystemContext<…>` is assignable to
+ * it.
+ *
+ * `out A` (declared covariance) is deliberate, see `Commands` above: the
+ * declared-access conditionals are unmeasurable to the compiler, and the
+ * unannotated verdict rejects exactly the `SystemContext<Narrow> →
+ * SystemContext` conversion the whole design depends on.
+ */
+export declare class SystemContext<out A extends SystemAccess = SystemAccess> {
+    private readonly _store;
+    lastRunTick: number;
+    /** Deferred structural-command facade. */
+    readonly commands: Commands<A>;
+    /** The frame tick: the count of `update()` calls so far. Run conditions
+     * read it. The change tick that a write stamps is a separate counter that
+     * advances before every system run, so it does not equal this value. */
+    get ecsTick(): number;
+    /** @internal Advance the change tick for the run that follows and return
+     * the new value. The schedule calls it before each system run and before
+     * each phase flush. Not for a system body. */
+    advanceChangeTick(): number;
+    /** @internal Copy every archetype's live row count into its descriptor.
+     * The schedule calls it before it dispatches a system to a compute backend,
+     * because a module reads the copy and a mutation earlier in the phase leaves
+     * it stale. The store returns on a flag when nothing is dirty, so a phase
+     * with no mutation pays that flag read for each dispatch. Not for a system
+     * body, a host outside the schedule calls `ecs.publishRowCounts()`. */
+    publishRowCounts(): void;
+    /** The world's frame-trace sink, or `null`. Lets the schedule
+     * fire `systemBegin` and `flush*` without reaching into the private store.
+     * Read only under `if (DEV)`. The seam is dead-code-eliminated in prod. */
+    get trace(): FrameTraceSink | null;
+    constructor(_store: Store);
+    isAlive(entityId: EntityID): boolean;
+    hasComponent(entityId: EntityID, def: ComponentDef): boolean;
+    getField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredRead<A, D>, field: string & keyof SchemaOf<D>): number;
+    /** Total sibling of {@link getField}, mirroring `ecs.tryGetField`. It reads
+     * `undefined` when the entity is dead or doesn't hold
+     * the component, instead of a dev throw or a prod garbage read. The safe way
+     * to probe-and-read in one call: `ctx.tryGetField(e, Health, "current") ?? 0`. */
+    tryGetField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredRead<A, D>, field: string & keyof SchemaOf<D>): number | undefined;
+    setField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredWrite<A, D>, field: string & keyof SchemaOf<D>, value: number): void;
+    /** Read-modify-write one field: `updateField(e, Gold, "value", v => v - cost)`
+     * is the one-line form of the `getField` → compute → `setField` round trip.
+     * Returns the written value. Same access-check and observer semantics as the
+     * two calls it composes (inlined here: the declared-access conditionals on
+     * those methods only resolve per `A` instantiation, so a body where `A` is
+     * still generic cannot call them without casts). */
+    updateField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredWrite<A, D>, field: string & keyof SchemaOf<D>, fn: (current: number) => number): number;
+    /**
+     * Record an entity as changed for a component's per-entity `onSet` observer.
+     * The SoA write idiom, `const { x } = cols.mut(D); x[i] = v` in a tight
+     * loop, bypasses the engine, which never sees the per-element writes, so a
+     * per-entity `onSet` consumer records the row by hand. This is the by-id
+     * form: a call, a resolve and a list push per row. The row form,
+     * `cols.ticks(D)[i] = cols.tick`, is one store per row, and the one to
+     * reach for inside a chunk loop. No-op for components without a
+     * per-entity onSet observer. `setField`, `ref` and a cursor record on
+     * their own.
+     */
+    markChanged(entityId: EntityID, def: ComponentDef): void;
+    /**
+     * Create a cached component reference for a single entity. Marks the
+     * component as changed (the mutable default, see `refRead` for the
+     * read-only variant to reach for when you are not mutating), and records
+     * the entity for a per-entity onSet observer. Both happen here, at
+     * creation: the accessor's setters write raw columns and cannot record,
+     * so the record is conservative, as the archetype stamp is. See ref.ts.
+     */
+    ref<D extends ComponentDef<any>>(def: D & DeclaredWrite<A, D>, entityId: EntityID): ComponentRef<SchemaOf<D>>;
+    /**
+     * Create a cached read-only component reference for a single entity. Use
+     * this when you are not mutating. The returned `ReadonlyComponentRef<S>`
+     * is an *advisory* compile-time barrier (no `_changedTick` bump): the
+     * `readonly` typing blocks field writes at the type layer, but the
+     * underlying accessor shares its prototype with `ref()` and can still be
+     * written through a deliberate cast. See ref.ts.
+     */
+    refRead<D extends ComponentDef<any>>(def: D & DeclaredRead<A, D>, entityId: EntityID): ReadonlyComponentRef<SchemaOf<D>>;
+    /**
+     * A re-pointable single-entity cursor over `def`, the in-system twin of
+     * {@link ECS.cursor}, and the accessor to reach for when a system touches many
+     * entities **by id** rather than by query span.
+     *
+     * `ctx.ref` allocates one accessor for each entity. That allocation is the
+     * largest part of the cost of a read of one field by id, because to make an
+     * accessor costs much more than to move one. Make the cursor one time,
+     * outside the loop:
+     *
+     *   const p = ctx.cursor(Pos);
+     *   for (const e of hits) { p.at(e); p.x += p.y * dt; }
+     *
+     * Mutable: every `at()` stamps the change tick. Still prefer `forEachChunk` when
+     * a query can express the entity set, a cursor removes the per-entity
+     * allocation, not the per-entity archetype resolution.
+     */
+    cursor<D extends ComponentDef<any>>(def: D & DeclaredWrite<A, D>): ComponentCursor<SchemaOf<D>>;
+    /** Read-only {@link cursor}: no change-tick stamp on `at()`. Advisory only,
+     * same caveat as `ctx.refRead`. */
+    cursorRead<D extends ComponentDef<any>>(def: D & DeclaredRead<A, D>): ReadonlyComponentCursor<SchemaOf<D>>;
+    /** Whether `entityId` is currently disabled (immediate read). Toggling is
+     * deferred, `ctx.commands.disable` and `ctx.commands.enable`. */
+    isDisabled(entityId: EntityID): boolean;
+    /** Tags take no values argument. Valued schemas require a complete one. */
+    addSparse<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseWrite<A, D>, ...values: AttachValuesArg<SparseSchemaOf<D>>): this;
+    removeSparse<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseWrite<A, D>): this;
+    hasSparse(entityId: EntityID, def: SparseComponentDef): boolean;
+    getSparseField<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseRead<A, D>, field: string & keyof SparseSchemaOf<D>): number;
+    setSparseField<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseWrite<A, D>, field: string & keyof SparseSchemaOf<D>, value: number): void;
+    /** A cursor over a sparse component, the sparse sibling of {@link cursor}
+     * and the fastest read by id in a system: `at()` writes the entity index and
+     * a field access is one load. Mutable. Declare the component in
+     * `sparseWrites`. See `ECS.sparseCursor`. */
+    sparseCursor<D extends SparseComponentDef<any>>(def: D & DeclaredSparseWrite<A, D>): ComponentCursor<SparseSchemaOf<D>>;
+    /** Whether the sparse component of `entityId` changed since the previous
+     * run of this system: its row tick is above `lastRunTick`. The row grain
+     * of change detection for a sparse component, as a pull. Needs row ticks
+     * (`ecs.trackRows(def)`, or an entity-level `onSet`), and throws
+     * `ROW_TICKS_NOT_TRACKED` without them. A non-member reads `false`. */
+    sparseChanged<D extends SparseComponentDef<any>>(def: D & DeclaredSparseRead<A, D>, entityId: EntityID): boolean;
+    /** Read-only {@link sparseCursor}. Declare the component in `sparseReads`.
+     * Advisory only, same caveat as `ctx.cursorRead`. */
+    sparseCursorRead<D extends SparseComponentDef<any>>(def: D & DeclaredSparseRead<A, D>): ReadonlyComponentCursor<SparseSchemaOf<D>>;
+    /** Add a `(R, tgt)` pair to `src` (exclusive replaces, multi adds). */
+    addRelation<D extends RelationDef>(src: EntityID, def: D & DeclaredRelationWrite<A, D>, tgt: EntityID): this;
+    /** Remove a `(R, tgt)` pair from `src`. For multi, omitting `tgt` removes all. */
+    removeRelation<D extends RelationDef>(src: EntityID, def: D & DeclaredRelationWrite<A, D>, tgt?: EntityID): this;
+    /** The single target of `src` under an exclusive relation, or `undefined`. */
+    targetOf<D extends RelationDef<"exclusive">>(src: EntityID, def: D & DeclaredRelationRead<A, D>): EntityID | undefined;
+    /** All targets of `src` under `R`, ascending by id. */
+    targetsOf<D extends RelationDef>(src: EntityID, def: D & DeclaredRelationRead<A, D>): EntityID[];
+    /** Sources pointing at `tgt` under `R` (the reverse index), ascending by id.
+     * `(entity, def)` order, matching `targetOf` and `targetsOf`. */
+    sourcesOf<D extends RelationDef>(tgt: EntityID, def: D & DeclaredRelationRead<A, D>): EntityID[];
+    /** Whether `src` holds any pair under `R`. */
+    hasRelation(src: EntityID, def: RelationDef): boolean;
+    /** Flush all deferred changes: structural (add and remove) first, then
+     *  destructions. Republishes archetype row counts into the SAB
+     *  descriptor at the end so any WASM scan running in the next phase
+     *  sees fresh `row_count` fields. This is one of two publish sites,
+     *  `ECS.update()` also republishes once at tick start, which covers
+     *  host-side mutations between updates. The publish walks
+     *  descriptors only. It doesn't touch column data, so paying it once per
+     *  phase boundary is cheaper than the earlier pattern of paying it for each
+     *  WASM-using system in each tick. The descriptor walk is gated
+     *  on a dirty flag, so a read-only phase skips the walk entirely. */
+    flush(): void;
+    /**
+     * Emit an event (or a payload-less signal) onto its channel. The event is
+     * visible to every system that runs *later* in the same `update()` and is
+     * cleared at the tick's tail, events live exactly one tick, and there is no
+     * acknowledgement. The channel must have been registered at world setup with
+     * `ecs.events.register(key, fields)` or `registerSignal(key)`.
+     *
+     * @example
+     * const Damaged = eventKey<{ target: EntityID; amount: number }>("Damaged");
+     * ecs.events.register(Damaged, ["target", "amount"]);
+     * // inside a system:
+     * ctx.emit(Damaged, { target: e, amount: 10 });
+     */
+    emit(key: SignalKey): void;
+    emit<S extends EventShape<S>>(key: EventKey<S>, values: NoInfer<S>): void;
+    /**
+     * Read this tick's events on a channel. Returns an SoA reader over
+     * everything emitted *earlier in the same `update()`*, order systems so
+     * readers run after emitters, or they see an empty reader.
+     *
+     * @example
+     * const dmg = ctx.readEvents(Damaged); // SoA columns, one per field
+     * for (let i = 0; i < dmg.length; i++) {
+     *   applyDamage(dmg.target[i], dmg.amount[i]);
+     * }
+     */
+    readEvents<S extends EventShape<S>>(key: EventKey<S>): EventReader<S>;
+    /** Read a resource (declared in `resourceReads`). The flat `ctx` surface verbs
+     * its accessors, `getResource`, `setResource`, `removeResource` and `hasResource`,
+     * matching `getField`, `setField` and `hasComponent`. The grouped `ecs.resources`
+     * facade drops the noun (`get`, `set`, `remove` and `has`) because its receiver
+     * already names it. */
+    getResource<K extends ResourceKey<any>>(key: K & DeclaredResourceRead<A, K>): ResourceValueOf<K>;
+    setResource<K extends ResourceKey<any>>(key: K & DeclaredResourceWrite<A, K>, value: ResourceValueOf<NoInfer<K>>): void;
+    /** Drop a resource mid-tick. A lifecycle mutation, so it is access-
+     * checked as a *write*, the system must declare the key in `resourceWrites`,
+     * which serialises it against readers and writers of the same resource. Fails
+     * closed on a missing key. */
+    removeResource<K extends ResourceKey<any>>(key: K & DeclaredResourceWrite<A, K>): void;
+    hasResource<T>(key: ResourceKey<T>): boolean;
+}
+//# sourceMappingURL=system_context.d.ts.map

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

@@ -0,0 +1,296 @@
+import { Store } from './store.js';
+import { FrameTraceSink } from './frame_trace.js';
+import { EntityID } from './entity.js';
+import { ComponentDef, AttachValuesArg, SchemaOf, FieldValues } from './component.js';
+import { SparseComponentDef, SparseSchemaOf } from './sparse_store.js';
+import { RelationDef } from './relation.js';
+import { SystemAccess, DeclaredRead, DeclaredWrite, DeclaredAdd, DeclaredRemove, DeclaredSparseRead, DeclaredSparseWrite, DeclaredRelationRead, DeclaredRelationWrite, DeclaredResourceRead, DeclaredResourceWrite, DespawnArg } from './system.js';
+import { ComponentCursor, ComponentRef, ReadonlyComponentCursor, ReadonlyComponentRef } from './ref.js';
+import { EventKey, EventReader, EventShape, SignalKey } from './event.js';
+import { ResourceKey, ResourceValueOf } from './resource.js';
+/**
+ * A `BundleOrDef` whose def is constrained to the enclosing system's declared
+ * add surface (system.ts). The bundle branch restates `Bundle`'s shape with
+ * the def slot narrowed, intersecting `Bundle<any> & { def: … }` instead
+ * would put two `ComponentDef` instantiations in one intersection, which TS
+ * relates leniently (see the access-typing notes in system.ts).
+ *
+ * The outer conditional is a deliberate no-op (`[D] extends [unknown]` is
+ * always true): it makes the variance of `D`, and therefore of the access
+ * param `A` threaded through `Commands` and `SystemContext`. Unmeasurable to
+ * the compiler. A measurable (plain-union) definition here gets `A` marked
+ * reliably contravariant, variance-based comparison then rejects
+ * `SystemContext<Narrow> → SystemContext` without the structural fallback,
+ * and every helper taking a bare `SystemContext` stops accepting typed
+ * contexts. Unmeasurable variance forces the structural path, where class
+ * methods compare bivariantly and the conversion holds.
+ *
+ * The inner `D extends ComponentDef ? … : never` Distributes over the declared
+ * add-set union, so each raw-literal branch carries its own def's schema
+ * (`Partial<FieldValues<SchemaOf<D>>>`) rather than the erased
+ * `Partial<Record<string, number>>`. A hand-written `{ def: Vel, values: { x }}`
+ * whose fields don't match its def is then rejected in a declared-access system,
+ * matching the `StrictBundles` guarantee on the `ecs.*` surface. A permissive
+ * context (`add: ComponentDef<any>`, an unnarrowed or `exclusive` system)
+ * keeps the loose shape, which is the point of opting out of narrowing. The
+ * outer no-op is preserved, so the variance invariant above still holds
+ * (verified: the `permissiveHelper(ctx)` assertion still compiles).
+ */
+export type DeclaredBundleOrDef<D> = [D] extends [unknown] ? D extends ComponentDef ? D | {
+    readonly def: D;
+    readonly values: Readonly<Partial<FieldValues<SchemaOf<D>>>>;
+} : never : never;
+/**
+ * Deferred structural-command facade (Bevy `Commands`).
+ * Namespaces the deferred structural ops so the call site is self-documenting:
+ * `ctx.commands.add(e, …)` is *always* deferred (applied at the phase flush),
+ * ending the collision where `ecs.addComponent` (immediate) and a bare
+ * `ctx.addComponent` (deferred) would share a name with opposite timing. Takes
+ * varargs callable bundles, so one shape, `commands.spawn(bundle(Pos,{x,y}), bundle(Vel,{vx:1}))`,
+ * serves spawn and add. This is the only deferred surface: the bare
+ * `ctx.addComponent`, `ctx.removeComponent`, `ctx.disable` and `ctx.enable`
+ * duplicates were removed in 0.5.0, completing the receiver-implies-timing
+ * rule (`ecs.*` immediate, `ctx.commands.*` deferred) that 0.5.0 started for
+ * spawn and despawn.
+ *
+ * `A` narrows the def-taking methods to the enclosing system's declared access
+ * (system.ts). The default is fully permissive.
+ *
+ * `out A` (declared covariance) is deliberate: every use of `A` sits inside a
+ * declared-access conditional, whose variance the compiler cannot measure,
+ * left unannotated, the measured verdict rejects `Commands<Narrow> →
+ * Commands` (the direction every permissive consumer needs). Covariance is
+ * the honest direction: a context with more declared access is usable where
+ * one with less is expected. The checks themselves are per-instantiation, so
+ * the annotation does not weaken them.
+ */
+export declare class Commands<out A extends SystemAccess = SystemAccess> {
+    private readonly _store;
+    constructor(_store: Store);
+    /** Spawn from bundles. The create is immediate, so the id returns now. The
+     *  component attaches are deferred to the phase flush, so until that flush the
+     *  entity exists in its empty and partial archetype and a query running later in
+     *  the same phase can observe it half-built. (Same semantics as
+     *  `ctx.commands.spawn()` followed by `ctx.commands.add`. A fully deferred
+     *  id-reservation spawn, à la Bevy, is a separate follow-up.) */
+    spawn(...items: DeclaredBundleOrDef<A["add"]>[]): EntityID;
+    /** Attach bundles to an existing entity (deferred). Bundles zero-fill
+     * omitted fields. */
+    add(entityId: EntityID, ...items: DeclaredBundleOrDef<A["add"]>[]): this;
+    /** Explicit complete-values attach (deferred), the compile-checked shape
+     * where a typo'd or missing field is a compile error, mirroring the
+     * immediate `ecs.addComponent(e, def, values)`. Tags take no values
+     * argument (`AttachValuesArg`). */
+    add<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredAdd<A, D>, ...values: AttachValuesArg<SchemaOf<D>>): this;
+    /** Remove a component (deferred). */
+    remove<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredRemove<A, D>): this;
+    /** Destroy an entity (deferred). */
+    despawn(entityId: DespawnArg<A>): this;
+    /** Buffer `entityId` to be disabled at the phase flush (idempotent).
+     * Deferred because a toggle is an in-archetype row swap, which would corrupt
+     * a `forEach` SoA loop iterating that archetype if applied mid-system (it
+     * reorders the dense columns being read). A disabled entity is excluded from
+     * default queries. Opt back in per query with `.includeDisabled()`. The
+     * immediate read is `ctx.isDisabled`. */
+    disable(entityId: EntityID): this;
+    /** Buffer `entityId` to be re-enabled at the phase flush (idempotent).
+     * Deferred for the same row-swap reason as `disable`. */
+    enable(entityId: EntityID): this;
+}
+/**
+ * The per-system world facade. `A` is the system's declared access surface
+ * (system.ts): the config-form `registerSystem` computes it from
+ * the literal `reads` and `writes`/… declarations and every guarded method below
+ * checks its handle argument against the matching union at compile time,
+ * the same rules `accessCheck` enforces at runtime in `DEV`. The default
+ * `A = SystemAccess` is fully permissive, so a bare `SystemContext` (helper
+ * functions, host-side code, explicitly-annotated escape hatches) behaves
+ * exactly as before, and every narrowed `SystemContext<…>` is assignable to
+ * it.
+ *
+ * `out A` (declared covariance) is deliberate, see `Commands` above: the
+ * declared-access conditionals are unmeasurable to the compiler, and the
+ * unannotated verdict rejects exactly the `SystemContext<Narrow> →
+ * SystemContext` conversion the whole design depends on.
+ */
+export declare class SystemContext<out A extends SystemAccess = SystemAccess> {
+    private readonly _store;
+    lastRunTick: number;
+    /** Deferred structural-command facade. */
+    readonly commands: Commands<A>;
+    /** The frame tick: the count of `update()` calls so far. Run conditions
+     * read it. The change tick that a write stamps is a separate counter that
+     * advances before every system run, so it does not equal this value. */
+    get ecsTick(): number;
+    /** @internal Advance the change tick for the run that follows and return
+     * the new value. The schedule calls it before each system run and before
+     * each phase flush. Not for a system body. */
+    advanceChangeTick(): number;
+    /** @internal Copy every archetype's live row count into its descriptor.
+     * The schedule calls it before it dispatches a system to a compute backend,
+     * because a module reads the copy and a mutation earlier in the phase leaves
+     * it stale. The store returns on a flag when nothing is dirty, so a phase
+     * with no mutation pays that flag read for each dispatch. Not for a system
+     * body, a host outside the schedule calls `ecs.publishRowCounts()`. */
+    publishRowCounts(): void;
+    /** The world's frame-trace sink, or `null`. Lets the schedule
+     * fire `systemBegin` and `flush*` without reaching into the private store.
+     * Read only under `if (DEV)`. The seam is dead-code-eliminated in prod. */
+    get trace(): FrameTraceSink | null;
+    constructor(_store: Store);
+    isAlive(entityId: EntityID): boolean;
+    hasComponent(entityId: EntityID, def: ComponentDef): boolean;
+    getField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredRead<A, D>, field: string & keyof SchemaOf<D>): number;
+    /** Total sibling of {@link getField}, mirroring `ecs.tryGetField`. It reads
+     * `undefined` when the entity is dead or doesn't hold
+     * the component, instead of a dev throw or a prod garbage read. The safe way
+     * to probe-and-read in one call: `ctx.tryGetField(e, Health, "current") ?? 0`. */
+    tryGetField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredRead<A, D>, field: string & keyof SchemaOf<D>): number | undefined;
+    setField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredWrite<A, D>, field: string & keyof SchemaOf<D>, value: number): void;
+    /** Read-modify-write one field: `updateField(e, Gold, "value", v => v - cost)`
+     * is the one-line form of the `getField` → compute → `setField` round trip.
+     * Returns the written value. Same access-check and observer semantics as the
+     * two calls it composes (inlined here: the declared-access conditionals on
+     * those methods only resolve per `A` instantiation, so a body where `A` is
+     * still generic cannot call them without casts). */
+    updateField<D extends ComponentDef<any>>(entityId: EntityID, def: D & DeclaredWrite<A, D>, field: string & keyof SchemaOf<D>, fn: (current: number) => number): number;
+    /**
+     * Record an entity as changed for a component's per-entity `onSet` observer.
+     * The SoA write idiom, `const { x } = cols.mut(D); x[i] = v` in a tight
+     * loop, bypasses the engine, which never sees the per-element writes, so a
+     * per-entity `onSet` consumer records the row by hand. This is the by-id
+     * form: a call, a resolve and a list push per row. The row form,
+     * `cols.ticks(D)[i] = cols.tick`, is one store per row, and the one to
+     * reach for inside a chunk loop. No-op for components without a
+     * per-entity onSet observer. `setField`, `ref` and a cursor record on
+     * their own.
+     */
+    markChanged(entityId: EntityID, def: ComponentDef): void;
+    /**
+     * Create a cached component reference for a single entity. Marks the
+     * component as changed (the mutable default, see `refRead` for the
+     * read-only variant to reach for when you are not mutating), and records
+     * the entity for a per-entity onSet observer. Both happen here, at
+     * creation: the accessor's setters write raw columns and cannot record,
+     * so the record is conservative, as the archetype stamp is. See ref.ts.
+     */
+    ref<D extends ComponentDef<any>>(def: D & DeclaredWrite<A, D>, entityId: EntityID): ComponentRef<SchemaOf<D>>;
+    /**
+     * Create a cached read-only component reference for a single entity. Use
+     * this when you are not mutating. The returned `ReadonlyComponentRef<S>`
+     * is an *advisory* compile-time barrier (no `_changedTick` bump): the
+     * `readonly` typing blocks field writes at the type layer, but the
+     * underlying accessor shares its prototype with `ref()` and can still be
+     * written through a deliberate cast. See ref.ts.
+     */
+    refRead<D extends ComponentDef<any>>(def: D & DeclaredRead<A, D>, entityId: EntityID): ReadonlyComponentRef<SchemaOf<D>>;
+    /**
+     * A re-pointable single-entity cursor over `def`, the in-system twin of
+     * {@link ECS.cursor}, and the accessor to reach for when a system touches many
+     * entities **by id** rather than by query span.
+     *
+     * `ctx.ref` allocates one accessor for each entity. That allocation is the
+     * largest part of the cost of a read of one field by id, because to make an
+     * accessor costs much more than to move one. Make the cursor one time,
+     * outside the loop:
+     *
+     *   const p = ctx.cursor(Pos);
+     *   for (const e of hits) { p.at(e); p.x += p.y * dt; }
+     *
+     * Mutable: every `at()` stamps the change tick. Still prefer `forEachChunk` when
+     * a query can express the entity set, a cursor removes the per-entity
+     * allocation, not the per-entity archetype resolution.
+     */
+    cursor<D extends ComponentDef<any>>(def: D & DeclaredWrite<A, D>): ComponentCursor<SchemaOf<D>>;
+    /** Read-only {@link cursor}: no change-tick stamp on `at()`. Advisory only,
+     * same caveat as `ctx.refRead`. */
+    cursorRead<D extends ComponentDef<any>>(def: D & DeclaredRead<A, D>): ReadonlyComponentCursor<SchemaOf<D>>;
+    /** Whether `entityId` is currently disabled (immediate read). Toggling is
+     * deferred, `ctx.commands.disable` and `ctx.commands.enable`. */
+    isDisabled(entityId: EntityID): boolean;
+    /** Tags take no values argument. Valued schemas require a complete one. */
+    addSparse<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseWrite<A, D>, ...values: AttachValuesArg<SparseSchemaOf<D>>): this;
+    removeSparse<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseWrite<A, D>): this;
+    hasSparse(entityId: EntityID, def: SparseComponentDef): boolean;
+    getSparseField<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseRead<A, D>, field: string & keyof SparseSchemaOf<D>): number;
+    setSparseField<D extends SparseComponentDef<any>>(entityId: EntityID, def: D & DeclaredSparseWrite<A, D>, field: string & keyof SparseSchemaOf<D>, value: number): void;
+    /** A cursor over a sparse component, the sparse sibling of {@link cursor}
+     * and the fastest read by id in a system: `at()` writes the entity index and
+     * a field access is one load. Mutable. Declare the component in
+     * `sparseWrites`. See `ECS.sparseCursor`. */
+    sparseCursor<D extends SparseComponentDef<any>>(def: D & DeclaredSparseWrite<A, D>): ComponentCursor<SparseSchemaOf<D>>;
+    /** Whether the sparse component of `entityId` changed since the previous
+     * run of this system: its row tick is above `lastRunTick`. The row grain
+     * of change detection for a sparse component, as a pull. Needs row ticks
+     * (`ecs.trackRows(def)`, or an entity-level `onSet`), and throws
+     * `ROW_TICKS_NOT_TRACKED` without them. A non-member reads `false`. */
+    sparseChanged<D extends SparseComponentDef<any>>(def: D & DeclaredSparseRead<A, D>, entityId: EntityID): boolean;
+    /** Read-only {@link sparseCursor}. Declare the component in `sparseReads`.
+     * Advisory only, same caveat as `ctx.cursorRead`. */
+    sparseCursorRead<D extends SparseComponentDef<any>>(def: D & DeclaredSparseRead<A, D>): ReadonlyComponentCursor<SparseSchemaOf<D>>;
+    /** Add a `(R, tgt)` pair to `src` (exclusive replaces, multi adds). */
+    addRelation<D extends RelationDef>(src: EntityID, def: D & DeclaredRelationWrite<A, D>, tgt: EntityID): this;
+    /** Remove a `(R, tgt)` pair from `src`. For multi, omitting `tgt` removes all. */
+    removeRelation<D extends RelationDef>(src: EntityID, def: D & DeclaredRelationWrite<A, D>, tgt?: EntityID): this;
+    /** The single target of `src` under an exclusive relation, or `undefined`. */
+    targetOf<D extends RelationDef<"exclusive">>(src: EntityID, def: D & DeclaredRelationRead<A, D>): EntityID | undefined;
+    /** All targets of `src` under `R`, ascending by id. */
+    targetsOf<D extends RelationDef>(src: EntityID, def: D & DeclaredRelationRead<A, D>): EntityID[];
+    /** Sources pointing at `tgt` under `R` (the reverse index), ascending by id.
+     * `(entity, def)` order, matching `targetOf` and `targetsOf`. */
+    sourcesOf<D extends RelationDef>(tgt: EntityID, def: D & DeclaredRelationRead<A, D>): EntityID[];
+    /** Whether `src` holds any pair under `R`. */
+    hasRelation(src: EntityID, def: RelationDef): boolean;
+    /** Flush all deferred changes: structural (add and remove) first, then
+     *  destructions. Republishes archetype row counts into the SAB
+     *  descriptor at the end so any WASM scan running in the next phase
+     *  sees fresh `row_count` fields. This is one of two publish sites,
+     *  `ECS.update()` also republishes once at tick start, which covers
+     *  host-side mutations between updates. The publish walks
+     *  descriptors only. It doesn't touch column data, so paying it once per
+     *  phase boundary is cheaper than the earlier pattern of paying it for each
+     *  WASM-using system in each tick. The descriptor walk is gated
+     *  on a dirty flag, so a read-only phase skips the walk entirely. */
+    flush(): void;
+    /**
+     * Emit an event (or a payload-less signal) onto its channel. The event is
+     * visible to every system that runs *later* in the same `update()` and is
+     * cleared at the tick's tail, events live exactly one tick, and there is no
+     * acknowledgement. The channel must have been registered at world setup with
+     * `ecs.events.register(key, fields)` or `registerSignal(key)`.
+     *
+     * @example
+     * const Damaged = eventKey<{ target: EntityID; amount: number }>("Damaged");
+     * ecs.events.register(Damaged, ["target", "amount"]);
+     * // inside a system:
+     * ctx.emit(Damaged, { target: e, amount: 10 });
+     */
+    emit(key: SignalKey): void;
+    emit<S extends EventShape<S>>(key: EventKey<S>, values: NoInfer<S>): void;
+    /**
+     * Read this tick's events on a channel. Returns an SoA reader over
+     * everything emitted *earlier in the same `update()`*, order systems so
+     * readers run after emitters, or they see an empty reader.
+     *
+     * @example
+     * const dmg = ctx.readEvents(Damaged); // SoA columns, one per field
+     * for (let i = 0; i < dmg.length; i++) {
+     *   applyDamage(dmg.target[i], dmg.amount[i]);
+     * }
+     */
+    readEvents<S extends EventShape<S>>(key: EventKey<S>): EventReader<S>;
+    /** Read a resource (declared in `resourceReads`). The flat `ctx` surface verbs
+     * its accessors, `getResource`, `setResource`, `removeResource` and `hasResource`,
+     * matching `getField`, `setField` and `hasComponent`. The grouped `ecs.resources`
+     * facade drops the noun (`get`, `set`, `remove` and `has`) because its receiver
+     * already names it. */
+    getResource<K extends ResourceKey<any>>(key: K & DeclaredResourceRead<A, K>): ResourceValueOf<K>;
+    setResource<K extends ResourceKey<any>>(key: K & DeclaredResourceWrite<A, K>, value: ResourceValueOf<NoInfer<K>>): void;
+    /** Drop a resource mid-tick. A lifecycle mutation, so it is access-
+     * checked as a *write*, the system must declare the key in `resourceWrites`,
+     * which serialises it against readers and writers of the same resource. Fails
+     * closed on a missing key. */
+    removeResource<K extends ResourceKey<any>>(key: K & DeclaredResourceWrite<A, K>): void;
+    hasResource<T>(key: ResourceKey<T>): boolean;
+}
+//# sourceMappingURL=system_context.d.ts.map

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

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