@oasys/oecs 0.5.4 → 0.6.0

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

@@ -3,24 +3,24 @@ import { ResourceKey } from './resource.cjs';
 import { Query } from './query.cjs';
 /**
  * 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
+ * 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. */
+    /** Current ECS tick, the deterministic clock built-ins key off. */
     readonly ecsTick: number;
     /** Read a resource value (checked against `resourceReads` in `DEV`). */
     getResource<T>(key: ResourceKey<T>): T;
-    /** Membership probe for a resource — unchecked, mirrors `hasComponent`. */
+    /** 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
+ * to skip them this tick. `reads` and `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).
+ * read-edge graph. Both are optional (absent reads as empty).
  */
 export interface RunCondition {
     /** Human-readable label, surfaced in dev access-violation diagnostics. */
@@ -28,7 +28,7 @@ export interface RunCondition {
     /** 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
+     *  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[];
@@ -38,44 +38,44 @@ export interface RunCondition {
 }
 /**
  * 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 `ecs.resources.set(key, …)` and the whole group toggles.
+ * so reference identity for objects). The canonical gate for a feature flag or
+ * a game phase. Flip `ecs.resources.set(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`
+ * 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
+ * (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
+ * negative multiple (and `-0 === 0`) to stay congruent, correct, but load-
+ * bearing on a quirk. Folding `offset` into `[0, n)` up front makes the folded offset
  * 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.
+ * 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.
+ * entity, flecs `runIf` over a query. The query is captured at config time, and
+ * its component defs are declared as `reads`. `entityCount` is a membership sum
+ * over matching archetypes and reads no column, so it trips no `accessCheck` read.
  *
  * The query must be **dense-only**: `entityCount` asserts this in `DEV`
- * (`_assertDenseOnly`), so pass a plain `ecs.query(...)` — a query carrying
+ * (`_assertDenseOnly`), so pass a plain `ecs.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;
 /** Invert a condition: run exactly when `cond` would skip. */
-export declare function not(cond: RunCondition): RunCondition;
-/** Run only when EVERY condition passes (`&&`, short-circuit). */
-export declare function allOf(...conds: RunCondition[]): RunCondition;
-/** Run when ANY condition passes (`||`, short-circuit). */
-export declare function anyOf(...conds: RunCondition[]): RunCondition;
+export declare function runIfNot(cond: RunCondition): RunCondition;
+/** Run only when every condition passes (`&&`, short-circuit). */
+export declare function runIfAll(...conds: RunCondition[]): RunCondition;
+/** Run when any condition passes (`||`, short-circuit). */
+export declare function runIfAny(...conds: RunCondition[]): RunCondition;
 //# sourceMappingURL=run_condition.d.ts.map

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

@@ -3,24 +3,24 @@ import { ResourceKey } from './resource.js';
 import { Query } from './query.js';
 /**
  * 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
+ * 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. */
+    /** Current ECS tick, the deterministic clock built-ins key off. */
     readonly ecsTick: number;
     /** Read a resource value (checked against `resourceReads` in `DEV`). */
     getResource<T>(key: ResourceKey<T>): T;
-    /** Membership probe for a resource — unchecked, mirrors `hasComponent`. */
+    /** 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
+ * to skip them this tick. `reads` and `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).
+ * read-edge graph. Both are optional (absent reads as empty).
  */
 export interface RunCondition {
     /** Human-readable label, surfaced in dev access-violation diagnostics. */
@@ -28,7 +28,7 @@ export interface RunCondition {
     /** 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
+     *  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[];
@@ -38,44 +38,44 @@ export interface RunCondition {
 }
 /**
  * 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 `ecs.resources.set(key, …)` and the whole group toggles.
+ * so reference identity for objects). The canonical gate for a feature flag or
+ * a game phase. Flip `ecs.resources.set(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`
+ * 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
+ * (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
+ * negative multiple (and `-0 === 0`) to stay congruent, correct, but load-
+ * bearing on a quirk. Folding `offset` into `[0, n)` up front makes the folded offset
  * 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.
+ * 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.
+ * entity, flecs `runIf` over a query. The query is captured at config time, and
+ * its component defs are declared as `reads`. `entityCount` is a membership sum
+ * over matching archetypes and reads no column, so it trips no `accessCheck` read.
  *
  * The query must be **dense-only**: `entityCount` asserts this in `DEV`
- * (`_assertDenseOnly`), so pass a plain `ecs.query(...)` — a query carrying
+ * (`_assertDenseOnly`), so pass a plain `ecs.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;
 /** Invert a condition: run exactly when `cond` would skip. */
-export declare function not(cond: RunCondition): RunCondition;
-/** Run only when EVERY condition passes (`&&`, short-circuit). */
-export declare function allOf(...conds: RunCondition[]): RunCondition;
-/** Run when ANY condition passes (`||`, short-circuit). */
-export declare function anyOf(...conds: RunCondition[]): RunCondition;
+export declare function runIfNot(cond: RunCondition): RunCondition;
+/** Run only when every condition passes (`&&`, short-circuit). */
+export declare function runIfAll(...conds: RunCondition[]): RunCondition;
+/** Run when any condition passes (`||`, short-circuit). */
+export declare function runIfAny(...conds: RunCondition[]): RunCondition;
 //# sourceMappingURL=run_condition.d.ts.map

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

@@ -1 +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;AAIrC;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACvC,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,GAAG,CAAC,EAAE,CAAC;CACrD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAcjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,YAAY,CAoBlE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,YAAY,EAAE,CAAC,GAAG,YAAY,CAMjF;AA4BD,8DAA8D;AAC9D,wBAAgB,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAMpD;AAED,kEAAkE;AAClE,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,YAAY,CAM5D;AAED,2DAA2D;AAC3D,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,YAAY,CAM5D"}
+{"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;AAIrC;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACvC,0EAA0E;IAC1E,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,GAAG,CAAC,EAAE,CAAC;CACrD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAcjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,YAAY,CAoBlE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,YAAY,EAAE,CAAC,GAAG,YAAY,CAMjF;AAgCD,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAMzD;AAED,kEAAkE;AAClE,wBAAgB,QAAQ,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,YAAY,CAM/D;AAED,2DAA2D;AAC3D,wBAAgB,QAAQ,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,YAAY,CAM/D"}

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

@@ -1,155 +1,126 @@
-import { SystemContext } from './query.cjs';
+import { SystemEntry, SystemSet, SystemSetConfig } from './system_set.cjs';
+import { Phase, PhaseConfig, SchedulePhase } from './phase.cjs';
+import { SystemContext } from './system_context.cjs';
 import { SystemDescriptor } from './system.cjs';
 import { ComputeBackend } from './compute_backend.cjs';
-import { RunCondition } from './run_condition.cjs';
-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. 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. 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`.
- * 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. A `false` verdict skips the body that tick. */
-    runIf?: RunCondition | readonly RunCondition[];
-    /** Set membership — the system inherits each set's shared condition and
-     * ordering. */
-    set?: SystemSet | readonly SystemSet[];
+/** What the schedule needs of a worker pool, and nothing more.
+ *
+ * The pool ships in the workers plugin, so a class reference here would pull
+ * the pool, the plan builder and the node threads shim into every program.
+ * This interface is structural, and it erases, so the core graph reaches none
+ * of them. `run` answers false below the row threshold, before the kernel is
+ * loaded, and after a failed join. Then the sequential body runs. */
+export interface RouteDispatch {
+    /** `plan` is the opaque value the descriptor carries. The schedule loads
+     * it and passes it on, and only the route reads inside it. Answering false
+     * puts this dispatch back on the system's own `fn`. */
+    run(plan: object, ctx: SystemContext, deltaTime: number, runTick: number): boolean;
 }
 export declare class Schedule {
-    private readonly labelSystems;
-    private readonly sortedCache;
-    private readonly systemIndex;
-    private readonly systemLastRun;
-    private readonly lastRunSlots;
-    private readonly freeLastRunSlots;
+    private readonly _phases;
+    private readonly _builtins;
+    private _startupOrder;
+    private _fixedOrder;
+    private _updateOrder;
+    private readonly _phaseBySystem;
+    private readonly _lastRunTicks;
+    private readonly _slotBySystem;
+    private readonly _freeSlots;
     private _driveDepth;
-    private readonly gatedSystems;
-    private readonly setConditions;
-    private readonly setOrdering;
-    private nextInsertionOrder;
+    private readonly _gatedSystems;
+    private readonly _conditionsBySet;
+    private readonly _orderingBySet;
+    private _nextInsertionOrder;
     private _backend;
-    /** Dev-diagnostic sink (`ECSOptions.onWarn`); defaults to `console.warn`.
-     * The only schedule diagnostic today is `warnDroppedEdge`. */
-    private readonly onWarn;
-    /** The `FIXED_UPDATE` node list, held directly for `hasFixedSystems`. */
-    private readonly _fixedNodes;
+    private _route;
+    /** Dev-diagnostic sink (`ECSOptions.onWarn`). Defaults to `console.warn`.
+     * The only schedule diagnostic today is the dropped ordering edge
+     * `schedule_plan.ts` reports. */
+    private readonly _onWarn;
+    private _fixedSystemCount;
+    private _nextPhaseOrder;
     constructor(onWarn?: (message: string) => void);
-    addSystems(label: SCHEDULE, ...entries: (SystemDescriptor | SystemEntry)[]): void;
     /**
-     * Configure a `SystemSet` — its shared run condition(s) and/or
+     * Add one phase to a loop and hand back its handle. Cold path, setup only.
+     *
+     * `before` and `after` order it against the other phases of the same loop.
+     * A target in another loop is dropped, the way a system ordered against a
+     * system in another phase is dropped. With neither, the phase runs after
+     * every phase declared before it, so it lands at the tail of its loop.
+     *
+     * The handle is this world's. Two calls with one name make two phases, the
+     * rule `systemSet` already follows, so hold the handle rather than the name.
+     */
+    addPhase(name: string, config: PhaseConfig): Phase;
+    private _declarePhase;
+    /** Check that a phase belongs to this schedule, and hand it back unchanged.
+     * Not a dev guard: a handle from another world would push systems into that
+     * world's list, and a production build that scheduled them into nothing is
+     * worse than a named fault on a setup call. */
+    private _checkPhase;
+    /** The node behind either spelling of a phase. Cold path. */
+    private _resolvePhase;
+    /** Sort one loop's phases and cache the result. Kahn's algorithm with
+     * declaration order as the tiebreaker, the same rule the systems inside a
+     * phase follow. Cold path, once per `addPhase`. */
+    private _resolveOrder;
+    addSystems(phase: SchedulePhase, ...entries: (SystemDescriptor | SystemEntry)[]): void;
+    /**
+     * Configure a `SystemSet`, its shared run conditions, or its
      * 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;
+    /** Drop every cached plan. Cold path, and the reason each caller needs it
+     * sits at that call site. */
+    private _invalidatePlans;
     /** Attach (or, with `null`, detach) the opt-in compute backend. Driven
-     * by `ECS.attachBackend`; routes any scheduled system carrying a
+     * 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;
+    /** Attach (or, with `null`, detach) the system dispatch route. Driven by
+     * the plugin that installed it. Runs any scheduled system carrying a
+     * `routePlan` through the route in place of its `fn`. */
+    setRoute(dispatch: RouteDispatch | null): void;
+    runStartup(ctx: SystemContext): void;
+    runUpdate(ctx: SystemContext, deltaTime: number): void;
+    runFixedUpdate(ctx: SystemContext, fixedDt: number): void;
     hasFixedSystems(): boolean;
     getAllSystems(): SystemDescriptor[];
     hasSystem(system: SystemDescriptor): boolean;
-    /** Hand `descriptor` its `systemLastRun` slot, keeping the array packed (no
-     * holes ⇒ no undefined-check on the read in `runLabel`, which is the whole
+    /** Hand `descriptor` its `_lastRunTicks` slot, keeping the array packed (no
+     * holes ⇒ no undefined-check on the read in `_runPhase`, which is the whole
      * point of it not being a `Map`). Idempotent for a descriptor already in this
-     * schedule — `getSorted` re-asks for every system it sorts. A descriptor that
+     * schedule, `_getPlan` re-asks for every system it sorts. A descriptor that
      * was removed and re-added gets a *fresh* slot starting at tick 0, which is
      * what the previous `Map`-based bookkeeping did (`delete` on remove, `set(…, 0)`
      * on re-add). */
     private _assignLastRunSlot;
     clear(): void;
-    private runLabel;
+    private _runPhase;
     /**
-     * Whether a gated system runs this tick — the AND of its own conditions and
+     * 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
+     * set uniformly. A `configureSet` between phases is still honored because the
+     * memo lives only for a single `_runPhase` pass. Short-circuits on the first
      * `false`. The system's own conditions evaluate per system, in canonical order.
      *
-     * SEMANTIC NOTE: this evaluates a set's conditions once-per-set-per-phase
-     * rather than once-per-member. Equivalent for pure RunConditions; observably
-     * different only if a set condition reads state mutated earlier in the SAME
-     * phase (resources write immediately). That is intentional — the set gates as a
-     * unit, so all its members share one verdict for the phase.
+     * This evaluates a set's conditions once for each set in each phase, and not
+     * once for each member. The two agree for a pure `RunCondition`. They differ
+     * only when a set condition reads state a system mutated earlier in the same
+     * phase (a resource writes immediately). That is intentional. The set gates
+     * as a unit, so every member shares one verdict for the phase.
      */
-    private shouldRun;
-    /** Evaluate a condition list with AND semantics. Each predicate runs inside a
+    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. 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;
+     * undeclared resource, or attempts any mutation, throws. */
+    private _evalConditions;
+    /** Sort one phase and cache its plan on the phase. Cold: the drive reads
+     * `phase.plan` and only lands here when an add or a remove nulled it. */
+    private _buildPlan;
 }
 //# sourceMappingURL=schedule.d.ts.map