@ecsia/scheduler 0.1.0

package/dist/commands/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/commands/fields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,EAAE,MAAM,eAAe,CAAA;AAU1E,UAAU,UAAU;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACvE,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAA;CAC7D;AAED,MAAM,WAAW,mBAAmB;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAA;IACtC,2FAA2F;IAC3F,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACvF,sFAAsF;IACtF,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChE;AA8ED,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,mBAAmB,CA0B9E"}

package/dist/commands/fields.js

@@ -0,0 +1,123 @@
+// Field-word codec for OP_ADD / OP_SET_PAYLOAD / OP_ADD_PAIR payloads.
+// Each component/relation field contributes `stride` u32 words to a record's payload tail; f64
+// contributes two words (low, high). The codec is derived ONCE per component from its FieldDescriptor
+// list (declaration order). Encode widens a JS value to its u32 slot bit-pattern; decode narrows back.
+// Object<T> fields are NOT encodable (restrictedToMainThread) — a component carrying one is
+// worker-ineligible upstream, so this path never sees it.
+// Shared scratch for f32-bit aliasing and f64 two-word split (host-native, consistent within a
+// process; the buffer is transferred not re-serialized in the fallback, so byte order is preserved).
+const scratch = new ArrayBuffer(8);
+const scratchF32 = new Float32Array(scratch);
+const scratchF64 = new Float64Array(scratch);
+const scratchU32 = new Uint32Array(scratch);
+const scratchI32 = new Int32Array(scratch);
+function scalarCodec(token, d) {
+    if (token === 'f32') {
+        return {
+            name: d.name,
+            words: 1,
+            encode: (v, out, at) => {
+                scratchF32[0] = +v;
+                out[at] = scratchU32[0];
+            },
+            decode: (w, at) => {
+                scratchU32[0] = w[at];
+                return scratchF32[0];
+            },
+        };
+    }
+    if (token === 'f64') {
+        return {
+            name: d.name,
+            words: 2,
+            encode: (v, out, at) => {
+                scratchF64[0] = +v;
+                out[at] = scratchU32[0];
+                out[at + 1] = scratchU32[1];
+            },
+            decode: (w, at) => {
+                scratchU32[0] = w[at];
+                scratchU32[1] = w[at + 1];
+                return scratchF64[0];
+            },
+        };
+    }
+    // Integer / bool / eid / staticString: one word, the encoded slot value. Round-trip through the
+    // descriptor's own encode/decode so the apply path stores exactly what a main-thread setter would.
+    return {
+        name: d.name,
+        words: 1,
+        encode: (v, out, at) => {
+            out[at] = d.encode(v) >>> 0;
+        },
+        decode: (w, at) => {
+            // i32-class slots must round-trip through a signed reinterpret before the descriptor decode.
+            scratchU32[0] = w[at];
+            return d.decode(scratchI32[0]);
+        },
+    };
+}
+function fieldCodec(d) {
+    const token = d.token;
+    if (typeof token === 'string')
+        return scalarCodec(token, d);
+    const kind = token.kind;
+    if (kind === 'vec') {
+        const elem = token.elem;
+        const len = token.len;
+        const per = scalarCodec(elem, { ...d, stride: 1 });
+        const words = per.words * len;
+        return {
+            name: d.name,
+            words,
+            encode: (v, out, at) => {
+                const arr = v;
+                for (let i = 0; i < len; i++)
+                    per.encode(arr[i], out, at + i * per.words);
+            },
+            decode: (w, at) => {
+                const arr = [];
+                for (let i = 0; i < len; i++)
+                    arr.push(per.decode(w, at + i * per.words));
+                return arr;
+            },
+        };
+    }
+    if (kind === 'staticString') {
+        return scalarCodec('u32', d);
+    }
+    throw new Error(`command-buffer: field '${d.name}' (object token) is not encodable in a command buffer`);
+}
+export function buildFieldCodec(def) {
+    const fields = def.fields.filter((f) => f.shareable).map(fieldCodec);
+    let totalWords = 0;
+    for (const f of fields)
+        totalWords += f.words;
+    return {
+        totalWords,
+        fields,
+        encode(init, out, at) {
+            let cursor = at;
+            for (const f of fields) {
+                const value = init?.[f.name] ?? defaultFor(def, f.name);
+                f.encode(value, out, cursor);
+                cursor += f.words;
+            }
+            return cursor - at;
+        },
+        decode(words, at) {
+            const obj = {};
+            let cursor = at;
+            for (const f of fields) {
+                obj[f.name] = f.decode(words, cursor);
+                cursor += f.words;
+            }
+            return obj;
+        },
+    };
+}
+function defaultFor(def, fieldName) {
+    const d = def.fields.find((f) => f.name === fieldName);
+    return d?.default ?? 0;
+}
+//# sourceMappingURL=fields.js.map

package/dist/commands/fields.js.map

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

package/dist/commands/index.d.ts

@@ -0,0 +1,10 @@
+export { Op, recordLen } from './op.js';
+export { directApplySink, flushAll } from './apply.js';
+export type { CommandSink, StructuralIntent, WorldApply } from './apply.js';
+export { makeCommandBuffer, resetBuffer, ensureWords } from './buffer.js';
+export type { CommandBuffer, BufferReservation } from './buffer.js';
+export { makeEncoder } from './encode.js';
+export type { CommandEncoder, ComponentEncodeInfo, EncoderEnv } from './encode.js';
+export { buildFieldCodec } from './fields.js';
+export type { ComponentFieldCodec } from './fields.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACtD,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC3E,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzE,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzC,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA"}

package/dist/commands/index.js

@@ -0,0 +1,6 @@
+export { Op, recordLen } from './op.js';
+export { directApplySink, flushAll } from './apply.js';
+export { makeCommandBuffer, resetBuffer, ensureWords } from './buffer.js';
+export { makeEncoder } from './encode.js';
+export { buildFieldCodec } from './fields.js';
+//# sourceMappingURL=index.js.map

package/dist/commands/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAEtD,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEzE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA"}

package/dist/commands/op.d.ts

@@ -0,0 +1,16 @@
+export declare const enum Op {
+    CREATE = 0,// OP_CREATE reservedEid
+    DESTROY = 1,// OP_DESTROY eid
+    ADD = 2,// OP_ADD eid componentId fieldWordCount [field words...]
+    REMOVE = 3,// OP_REMOVE eid componentId
+    ADD_PAIR = 4,// OP_ADD_PAIR eid relationId targetEid payloadWordCount [payload words...]
+    REMOVE_PAIR = 5,// OP_REMOVE_PAIR eid relationId targetEid
+    SET_PAYLOAD = 6
+}
+/**
+ * Self-describing record length in u32 words. Every record's length is
+ * computable from its first word(s) WITHOUT consulting any schema — the variable-arity ops carry an
+ * explicit count word — so the merge loop can skip/iterate records with no schema lookup.
+ */
+export declare function recordLen(words: Uint32Array, at: number): number;
+//# sourceMappingURL=op.d.ts.map

package/dist/commands/op.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op.d.ts","sourceRoot":"","sources":["../../src/commands/op.ts"],"names":[],"mappings":"AASA,0BAAkB,EAAE;IAClB,MAAM,IAAI,CAAE,wBAAwB;IACpC,OAAO,IAAI,CAAE,iBAAiB;IAC9B,GAAG,IAAI,CAAE,yDAAyD;IAClE,MAAM,IAAI,CAAE,4BAA4B;IACxC,QAAQ,IAAI,CAAE,2EAA2E;IACzF,WAAW,IAAI,CAAE,0CAA0C;IAC3D,WAAW,IAAI;CAChB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAkBhE"}

package/dist/commands/op.js

@@ -0,0 +1,43 @@
+// Command-buffer op ordinals. These numeric
+// values are SHARED across command-buffer `Op`, serialization `DeltaOp`, and reactivity `ShapeKind`
+// — the member names differ per spec but the numeric values are identical. Pinning them here is what
+// lets the apply path be reused across command-buffer and serialization.
+//
+// declares the FORMAT only. The encode methods (CommandEncoder) and the
+// per-worker SAB transport land at; ships the ordinals, the self-describing record-length
+// function, and a direct main-thread apply seam so is purely additive.
+export var Op;
+(function (Op) {
+    Op[Op["CREATE"] = 0] = "CREATE";
+    Op[Op["DESTROY"] = 1] = "DESTROY";
+    Op[Op["ADD"] = 2] = "ADD";
+    Op[Op["REMOVE"] = 3] = "REMOVE";
+    Op[Op["ADD_PAIR"] = 4] = "ADD_PAIR";
+    Op[Op["REMOVE_PAIR"] = 5] = "REMOVE_PAIR";
+    Op[Op["SET_PAYLOAD"] = 6] = "SET_PAYLOAD";
+})(Op || (Op = {}));
+/**
+ * Self-describing record length in u32 words. Every record's length is
+ * computable from its first word(s) WITHOUT consulting any schema — the variable-arity ops carry an
+ * explicit count word — so the merge loop can skip/iterate records with no schema lookup.
+ */
+export function recordLen(words, at) {
+    switch (words[at]) {
+        case Op.CREATE:
+            return 2;
+        case Op.DESTROY:
+            return 2;
+        case Op.REMOVE:
+            return 3;
+        case Op.REMOVE_PAIR:
+            return 4;
+        case Op.ADD:
+        case Op.SET_PAYLOAD:
+            return 4 + words[at + 3]; // 4 + fieldWordCount
+        case Op.ADD_PAIR:
+            return 5 + words[at + 4]; // 5 + payloadWordCount
+        default:
+            throw new Error(`corrupt command buffer: bad opcode ${words[at]} at ${at}`);
+    }
+}
+//# sourceMappingURL=op.js.map

package/dist/commands/op.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"op.js","sourceRoot":"","sources":["../../src/commands/op.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,oGAAoG;AACpG,qGAAqG;AACrG,yEAAyE;AACzE,EAAE;AACF,wEAAwE;AACxE,0FAA0F;AAC1F,uEAAuE;AAEvE,MAAM,CAAN,IAAkB,EAQjB;AARD,WAAkB,EAAE;IAClB,+BAAU,CAAA;IACV,iCAAW,CAAA;IACX,yBAAO,CAAA;IACP,+BAAU,CAAA;IACV,mCAAY,CAAA;IACZ,yCAAe,CAAA;IACf,yCAAe,CAAA;AACjB,CAAC,EARiB,EAAE,KAAF,EAAE,QAQnB;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,KAAkB,EAAE,EAAU;IACtD,QAAQ,KAAK,CAAC,EAAE,CAAO,EAAE,CAAC;QACxB,KAAK,EAAE,CAAC,MAAM;YACZ,OAAO,CAAC,CAAA;QACV,KAAK,EAAE,CAAC,OAAO;YACb,OAAO,CAAC,CAAA;QACV,KAAK,EAAE,CAAC,MAAM;YACZ,OAAO,CAAC,CAAA;QACV,KAAK,EAAE,CAAC,WAAW;YACjB,OAAO,CAAC,CAAA;QACV,KAAK,EAAE,CAAC,GAAG,CAAC;QACZ,KAAK,EAAE,CAAC,WAAW;YACjB,OAAO,CAAC,GAAI,KAAK,CAAC,EAAE,GAAG,CAAC,CAAY,CAAA,CAAC,qBAAqB;QAC5D,KAAK,EAAE,CAAC,QAAQ;YACd,OAAO,CAAC,GAAI,KAAK,CAAC,EAAE,GAAG,CAAC,CAAY,CAAA,CAAC,uBAAuB;QAC9D;YACE,MAAM,IAAI,KAAK,CAAC,sCAAsC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;IAC/E,CAAC;AACH,CAAC"}

package/dist/executor/guards.d.ts

@@ -0,0 +1,8 @@
+import type { World } from '@ecsia/core';
+import type { SystemBox } from '../planner/index.js';
+/**
+ * Wrap `world.query` so each term's component is asserted against the system's declared access.
+ * Returns the world's own query result unchanged; only the dev-mode diagnostic is added.
+ */
+export declare function makeScopedQuery(world: World, sb: SystemBox, dev: boolean): World['query'];
+//# sourceMappingURL=guards.d.ts.map

package/dist/executor/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/executor/guards.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAwBpD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,CA4BzF"}

package/dist/executor/guards.js

@@ -0,0 +1,61 @@
+// Dev-mode access guards (declared-intent contract). A system's
+// scoped `query` warns when a term references a component outside the system's declared
+// `read ∪ write`, and when a `write(C)` term names a C absent from `writeIds`. The declaration stays
+// authoritative — an undeclared access is a scheduling BUG the user must fix, not blocked (production
+// silent). Guards compile out when `dev` is false so the hot path is unaffected.
+function defOfTerm(term) {
+    const t = term;
+    if (t.relation !== undefined)
+        return { def: null, role: 'other' }; // Pair term — pair ids checked at
+    switch (t.__term) {
+        case 'write':
+            return { def: t.c ?? null, role: 'write' };
+        case 'read':
+        case 'optional':
+            return { def: t.c ?? null, role: 'read' };
+        case 'has':
+        case 'without':
+            return { def: t.c ?? null, role: 'other' };
+        default:
+            // bare ComponentDef == read
+            return { def: term, role: 'read' };
+    }
+}
+function warn(message) {
+    if (typeof console !== 'undefined')
+        console.warn(`[ecsia:scheduler] ${message}`);
+}
+/**
+ * Wrap `world.query` so each term's component is asserted against the system's declared access.
+ * Returns the world's own query result unchanged; only the dev-mode diagnostic is added.
+ */
+export function makeScopedQuery(world, sb, dev) {
+    if (!dev)
+        return world.query;
+    const readSet = new Set(sb.readIds);
+    const writeSet = new Set(sb.writeIds);
+    const scoped = (...terms) => {
+        for (const term of terms) {
+            const { def, role } = defOfTerm(term);
+            if (def === null)
+                continue;
+            const id = def.id;
+            if (id < 0)
+                continue; // unregistered — the world's compiler reports it
+            if (role === 'write') {
+                if (!writeSet.has(id)) {
+                    warn(`system '${sb.name}' issues a write(${def.name}) term but '${def.name}' is not in its declared write set — ` +
+                        `add it to the system's write access so parallel scheduling can serialize conflicting writers`);
+                }
+            }
+            else if (role === 'read' && !readSet.has(id) && !writeSet.has(id)) {
+                // `has`/`without` are presence FILTERS (role 'other'), not data access — declaring the
+                // filtered component would be spurious, so only genuine read terms are access-checked.
+                warn(`system '${sb.name}' references ${def.name} in a query but it is not in the system's declared read/write set`);
+            }
+        }
+        return world.query(...terms);
+    };
+    return scoped;
+}
+//# sourceMappingURL=guards.js.map

package/dist/executor/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/executor/guards.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,wFAAwF;AACxF,qGAAqG;AACrG,sGAAsG;AACtG,iFAAiF;AAMjF,SAAS,SAAS,CAAC,IAAe;IAChC,MAAM,CAAC,GAAG,IAAyE,CAAA;IACnF,IAAI,CAAC,CAAC,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA,CAAC,kCAAkC;IACpG,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC;QACjB,KAAK,OAAO;YACV,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;QAC5C,KAAK,MAAM,CAAC;QACZ,KAAK,UAAU;YACb,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;QAC3C,KAAK,KAAK,CAAC;QACX,KAAK,SAAS;YACZ,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;QAC5C;YACE,4BAA4B;YAC5B,OAAO,EAAE,GAAG,EAAE,IAA4B,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;IAC9D,CAAC;AACH,CAAC;AAED,SAAS,IAAI,CAAC,OAAe;IAC3B,IAAI,OAAO,OAAO,KAAK,WAAW;QAAE,OAAO,CAAC,IAAI,CAAC,qBAAqB,OAAO,EAAE,CAAC,CAAA;AAClF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,KAAY,EAAE,EAAa,EAAE,GAAY;IACvE,IAAI,CAAC,GAAG;QAAE,OAAO,KAAK,CAAC,KAAK,CAAA;IAC5B,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,EAAE,CAAC,OAA8B,CAAC,CAAA;IAClE,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAS,EAAE,CAAC,QAA+B,CAAC,CAAA;IACpE,MAAM,MAAM,GAAG,CAAC,GAAG,KAAkB,EAAW,EAAE;QAChD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;YACrC,IAAI,GAAG,KAAK,IAAI;gBAAE,SAAQ;YAC1B,MAAM,EAAE,GAAG,GAAG,CAAC,EAAuB,CAAA;YACtC,IAAI,EAAE,GAAG,CAAC;gBAAE,SAAQ,CAAC,iDAAiD;YACtE,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;gBACrB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;oBACtB,IAAI,CACF,WAAW,EAAE,CAAC,IAAI,oBAAoB,GAAG,CAAC,IAAI,eAAe,GAAG,CAAC,IAAI,uCAAuC;wBAC1G,8FAA8F,CACjG,CAAA;gBACH,CAAC;YACH,CAAC;iBAAM,IAAI,IAAI,KAAK,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;gBACpE,uFAAuF;gBACvF,uFAAuF;gBACvF,IAAI,CACF,WAAW,EAAE,CAAC,IAAI,gBAAgB,GAAG,CAAC,IAAI,mEAAmE,CAC9G,CAAA;YACH,CAAC;QACH,CAAC;QACD,OAAQ,KAAK,CAAC,KAAwC,CAAC,GAAG,KAAK,CAAC,CAAA;IAClE,CAAC,CAAA;IACD,OAAO,MAAmC,CAAA;AAC5C,CAAC"}

package/dist/executor/index.d.ts

@@ -0,0 +1,9 @@
+export { createScheduler, buildSchedulePlan } from './scheduler.js';
+export type { SchedulerHandle, CreateSchedulerOptions } from './scheduler.js';
+export { runUpdate } from './update.js';
+export { runUpdateThreaded } from './update-threaded.js';
+export type { RoundDispatcher } from './update-threaded.js';
+export { runWave, buildScopedQueries } from './run-wave.js';
+export type { ExecutorEnv } from './run-wave.js';
+export { makeScopedQuery } from './guards.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/executor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/executor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AACnE,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAC3D,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA"}

package/dist/executor/index.js

@@ -0,0 +1,6 @@
+export { createScheduler, buildSchedulePlan } from './scheduler.js';
+export { runUpdate } from './update.js';
+export { runUpdateThreaded } from './update-threaded.js';
+export { runWave, buildScopedQueries } from './run-wave.js';
+export { makeScopedQuery } from './guards.js';
+//# sourceMappingURL=index.js.map

package/dist/executor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/executor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAEnE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA"}

package/dist/executor/run-wave.d.ts

@@ -0,0 +1,19 @@
+import type { World } from '@ecsia/core';
+import type { ScheduleWave } from '../graph/index.js';
+import type { SystemBox } from '../planner/index.js';
+import type { CommandSink } from '../commands/index.js';
+export interface ExecutorEnv {
+    readonly world: World;
+    readonly dev: boolean;
+    readonly commands: CommandSink;
+    /** 'per-system' drains observers in every wave's serial slot; 'frame-end' once after the last wave. */
+    readonly observerCadence: 'frame-end' | 'per-system';
+    /** The plan's SystemBoxes, indexed by SystemId. */
+    readonly systems: readonly SystemBox[];
+    /** Pre-built per-system scoped queries (dev-guarded). Indexed by SystemId. */
+    readonly scopedQueries: readonly World['query'][];
+}
+export declare function buildScopedQueries(world: World, systems: readonly SystemBox[], dev: boolean): World['query'][];
+/** Run one wave, then the serial flush slot after it. */
+export declare function runWave(env: ExecutorEnv, wave: ScheduleWave, dt: number): void;
+//# sourceMappingURL=run-wave.d.ts.map

package/dist/executor/run-wave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-wave.d.ts","sourceRoot":"","sources":["../../src/executor/run-wave.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,qBAAqB,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;IAC9B,uGAAuG;IACvG,QAAQ,CAAC,eAAe,EAAE,WAAW,GAAG,YAAY,CAAA;IACpD,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAA;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,EAAE,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,CAAA;CAClD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,EAAE,GAAG,EAAE,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,CAE9G;AAYD,yDAAyD;AACzD,wBAAgB,OAAO,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAY9E"}

package/dist/executor/run-wave.js

@@ -0,0 +1,38 @@
+// The single-threaded executor — the NORMATIVE semantics. Runs waves IN ORDER on
+// the main thread; each wave's rounds run sequentially and (single-thread) each round's batches run
+// sequentially in batch-index order. Because batches in a round are conflict-free by construction
+// (WAVE-CONFLICT), the observable result equals the threaded path.
+//
+// Rule PHASE-1: in single-thread mode (workers === 0) runWave does NOT flip world.phase to
+// 'wave'. It stays 'serial' for the entire update, so every structural op a system performs takes the
+// synchronous direct-apply fast path and there are no command buffers to
+// flush. The post-wave serial slot's flushAll/mergeCorrals are no-ops — zero cost single-threaded.
+import { makeScopedQuery } from './guards.js';
+export function buildScopedQueries(world, systems, dev) {
+    return systems.map((sb) => makeScopedQuery(world, sb, dev));
+}
+function runSystem(env, sb, dt) {
+    const ctx = {
+        world: env.world,
+        dt,
+        tick: env.world.currentTick(),
+        query: env.scopedQueries[sb.id],
+    };
+    sb.run(ctx);
+}
+/** Run one wave, then the serial flush slot after it. */
+export function runWave(env, wave, dt) {
+    // ---- WAVE PHASE ---- (single-thread: world.phase stays 'serial', PHASE-1)
+    for (const round of wave.rounds) {
+        for (const batch of round) {
+            runSystem(env, env.systems[batch.systemId], dt);
+        }
+    }
+    // ---- SERIAL SLOT ---- apply staged structural changes + maintain queries + (maybe) observers.
+    env.world.mergeCorrals(); // no-op single-thread (no worker corrals)
+    env.commands.flushAll(); // no-op single-thread (no worker command buffers)
+    env.world.maintainStructural();
+    if (env.observerCadence === 'per-system')
+        env.world.observerDrain();
+}
+//# sourceMappingURL=run-wave.js.map

package/dist/executor/run-wave.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-wave.js","sourceRoot":"","sources":["../../src/executor/run-wave.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,oGAAoG;AACpG,kGAAkG;AAClG,mEAAmE;AACnE,EAAE;AACF,2FAA2F;AAC3F,sGAAsG;AACtG,yEAAyE;AACzE,mGAAmG;AAOnG,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAc7C,MAAM,UAAU,kBAAkB,CAAC,KAAY,EAAE,OAA6B,EAAE,GAAY;IAC1F,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;AAC7D,CAAC;AAED,SAAS,SAAS,CAAC,GAAgB,EAAE,EAAa,EAAE,EAAU;IAC5D,MAAM,GAAG,GAAkB;QACzB,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,EAAE;QACF,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,WAAW,EAAqB;QAChD,KAAK,EAAE,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,EAAuB,CAAE;KACtD,CAAA;IACD,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AACb,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,OAAO,CAAC,GAAgB,EAAE,IAAkB,EAAE,EAAU;IACtE,4EAA4E;IAC5E,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;YAC1B,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,QAA6B,CAAE,EAAE,EAAE,CAAC,CAAA;QACvE,CAAC;IACH,CAAC;IACD,gGAAgG;IAChG,GAAG,CAAC,KAAK,CAAC,YAAY,EAAE,CAAA,CAAC,0CAA0C;IACnE,GAAG,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAA,CAAC,kDAAkD;IAC1E,GAAG,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAA;IAC9B,IAAI,GAAG,CAAC,eAAe,KAAK,YAAY;QAAE,GAAG,CAAC,KAAK,CAAC,aAAa,EAAE,CAAA;AACrE,CAAC"}

package/dist/executor/scheduler.d.ts

@@ -0,0 +1,41 @@
+import type { World } from '@ecsia/core';
+import type { SystemBox, SystemDef } from '../planner/index.js';
+import type { SchedulePlan } from '../graph/index.js';
+import type { RoundDispatcher } from './update-threaded.js';
+export interface SchedulerHandle {
+    /** The immutable plan (frozen; rebuilt wholesale on re-plan, never patched — ). */
+    readonly plan: SchedulePlan;
+    /** Run one wave-scheduled tick on the main thread. */
+    update(dt?: number): void;
+    /**
+     * Run one wave-scheduled tick THREADED (PHASE-2): each round's worker batches
+     * are dispatched to `pool` (the WorkerPool), the rest run on the main thread. Reproduces the
+     * single-thread observable result through the SAME frame loop. The `pool`'s PoolSystem
+     * registration order MUST match the plan's SystemId order (the test rig wires this).
+     */
+    updateThreaded(pool: RoundDispatcher, dt?: number): Promise<void>;
+}
+export interface CreateSchedulerOptions {
+    /**
+     * registry.nextComponentId after createWorld registration (user components + reserved ids + one
+     * presence id per relation); accessStrideWords = ceil(registeredComponentCount / 32). When omitted,
+     * the stride is derived from the max declared component id (correct for the type-level disjointness
+     * test; widen-only). Pass it to align the access words with the bitmask stride for worker work.
+     */
+    readonly registeredComponentCount?: number;
+    /** Worker pool size for plan shape (matches WorldOptions.scheduler.workers). Default: 0 (single-thread; worker bodies land at ). */
+    readonly workers?: number;
+    /** Dev guards on/off. Default: NODE_ENV !== 'production'. */
+    readonly dev?: boolean;
+}
+/**
+ * Build the immutable plan from lowered, ordering-resolved SystemBoxes. The full pipeline:
+ * aggregate access → derive weighted conflict edges → cycle-detect + transitively reduce → extract
+ * waves + pack batches (WAVE-CONFLICT). Fails fast on a cyclic dependency (CycleError).
+ */
+export declare function buildSchedulePlan(systems: readonly SystemBox[], opts: {
+    accessStrideWords: number;
+    workers: number;
+}): SchedulePlan;
+export declare function createScheduler(world: World, defs: readonly SystemDef[], opts?: CreateSchedulerOptions): SchedulerHandle;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/executor/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/executor/scheduler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAKrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAG3D,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,sDAAsD;IACtD,MAAM,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAA;IAC1C,oIAAoI;IACpI,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CACvB;AAaD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,IAAI,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnD,YAAY,CAcd;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,IAAI,CAAC,EAAE,sBAAsB,GAC5B,eAAe,CA0BjB"}

package/dist/executor/scheduler.js

@@ -0,0 +1,71 @@
+// The world↔scheduler wiring seam (the locked dependency direction schema ← core ←
+// scheduler). The scheduler DRIVES the world externally: `createScheduler(world, systems).update(dt)`.
+// @ecsia/core NEVER imports @ecsia/scheduler — so rather than a core→scheduler import, the scheduler
+// holds the World and calls its public lifecycle verbs (frameReset / mergeCorrals /
+// maintainStructural / observerDrain / flushLogs / query / phase). A `world.setUpdate(fn)` seam was
+// rejected in favour of this external driver because it keeps the acyclic graph trivially obvious and
+// needs no new core surface.
+import { lowerSystems, aggregateAccess } from '../planner/index.js';
+import { resolveOrdering, buildEdges, buildDAG, buildPlan } from '../graph/index.js';
+import { directApplySink } from '../commands/index.js';
+import { buildScopedQueries } from './run-wave.js';
+import { runUpdate } from './update.js';
+import { runUpdateThreaded } from './update-threaded.js';
+import { IS_DEV } from '@ecsia/core';
+function strideFor(systems, registeredComponentCount) {
+    if (registeredComponentCount !== undefined)
+        return Math.max(1, Math.ceil(registeredComponentCount / 32));
+    let maxId = 0;
+    for (const sb of systems) {
+        for (const c of [...sb.readIds, ...sb.writeIds]) {
+            if (c > maxId)
+                maxId = c;
+        }
+    }
+    return Math.max(1, Math.ceil((maxId + 1) / 32));
+}
+/**
+ * Build the immutable plan from lowered, ordering-resolved SystemBoxes. The full pipeline:
+ * aggregate access → derive weighted conflict edges → cycle-detect + transitively reduce → extract
+ * waves + pack batches (WAVE-CONFLICT). Fails fast on a cyclic dependency (CycleError).
+ */
+export function buildSchedulePlan(systems, opts) {
+    if (systems.length === 0) {
+        return Object.freeze({
+            waves: [],
+            systems,
+            accessStrideWords: opts.accessStrideWords,
+            workers: opts.workers,
+        });
+    }
+    const defs = systems.map((sb) => sb.def);
+    const access = aggregateAccess(systems);
+    const edges = buildEdges(systems, defs, access);
+    const dag = buildDAG(systems, edges);
+    return buildPlan(systems, dag, opts.accessStrideWords, opts.workers);
+}
+export function createScheduler(world, defs, opts) {
+    const workers = opts?.workers ?? 0;
+    const dev = opts?.dev ?? IS_DEV;
+    const accessStrideWords = strideFor(lowerSystems(defs, 1), opts?.registeredComponentCount);
+    const systems = resolveOrdering(lowerSystems(defs, accessStrideWords), defs);
+    const plan = buildSchedulePlan(systems, { accessStrideWords, workers });
+    const env = {
+        world,
+        dev,
+        commands: directApplySink,
+        observerCadence: world.options.reactivity.observerCadence,
+        systems: plan.systems,
+        scopedQueries: buildScopedQueries(world, plan.systems, dev),
+    };
+    return {
+        plan,
+        update(dt = 0) {
+            runUpdate(env, plan, dt);
+        },
+        updateThreaded(pool, dt = 0) {
+            return runUpdateThreaded(env, plan, pool, dt);
+        },
+    };
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/executor/scheduler.js.map

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

package/dist/executor/seams.d.ts

@@ -0,0 +1,38 @@
+import type { Tick } from '@ecsia/schema';
+import type { SystemBatch } from '../graph/index.js';
+export type WorkerMode = 'single' | 'sab' | 'no-sab';
+/** SAB control block for one round's completion fence. */
+export interface WaveCounter {
+    readonly sab: SharedArrayBuffer;
+    readonly view: Int32Array;
+}
+export interface WaveSync {
+    /** Reset the counter to `batchCount` and bump the epoch. Main thread, before dispatch. */
+    begin(c: WaveCounter, batchCount: number): void;
+    /** Worker side (body ): Atomics.sub(remaining,1); if 0, Atomics.notify(epoch). */
+    complete(c: WaveCounter): void;
+    /** Main thread: wait until remaining === 0. Tier chosen by capability probe. */
+    await(c: WaveCounter): Promise<void> | void;
+}
+export interface WaveSyncTierProbe {
+    readonly waitAsync: boolean;
+    readonly waitBlocking: boolean;
+    readonly sabAvailable: boolean;
+}
+export type WaveSyncTier = 'waitAsync' | 'coordinator-block' | 'promise-poll' | 'postMessage';
+/**: choose the three-tier wait implementation once at world creation from the capability probe. */
+export declare function selectWaitTier(caps: WaveSyncTierProbe): WaveSyncTier;
+export interface WorkerHandle {
+    readonly index: number;
+    /** (plain AB, worker-local). Typed loosely until fills the CommandBuffer. */
+    readonly commandBuffer: unknown;
+    /** (plain AB, worker-local). */
+    readonly writeCorral: Uint32Array;
+}
+export interface WorkerDispatch {
+    /** Post a batch's systemId + ctx slice to a worker. Worker runs runSystem then WaveSync.complete (body ). */
+    dispatch(w: WorkerHandle, batch: SystemBatch, dt: number, tick: Tick): void;
+    readonly workers: readonly WorkerHandle[];
+    readonly mode: WorkerMode;
+}
+//# sourceMappingURL=seams.d.ts.map

package/dist/executor/seams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seams.d.ts","sourceRoot":"","sources":["../../src/executor/seams.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAA;AAEpD,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,iBAAiB,CAAA;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAK1B;AAED,MAAM,WAAW,QAAQ;IACvB,0FAA0F;IAC1F,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/C,kFAAkF;IAClF,QAAQ,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI,CAAA;IAC9B,gFAAgF;IAChF,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC5C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;CAC/B;AAED,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,mBAAmB,GAAG,cAAc,GAAG,aAAa,CAAA;AAE7F,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,IAAI,EAAE,iBAAiB,GAAG,YAAY,CAKpE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,gCAAgC;IAChC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B,6GAA6G;IAC7G,QAAQ,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;IACzC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAC1B"}

package/dist/executor/seams.js

@@ -0,0 +1,16 @@
+// Parallel-ready seams — INTERFACES ONLY. The single-thread executor is the
+// normative semantics; these contracts let the worker layer slot in with no public-API change.
+// This file ships only the type declarations + `selectWaitTier` so the plan already knows the
+// tier; the workers/ layer fills the bodies (WaveSync.complete, WorkerDispatch.dispatch, the
+// coordinator worker). NO Atomics, NO worker bodies here.
+/**: choose the three-tier wait implementation once at world creation from the capability probe. */
+export function selectWaitTier(caps) {
+    if (caps.waitAsync)
+        return 'waitAsync'; // tier 1: browser main thread, non-blocking
+    if (caps.waitBlocking)
+        return 'coordinator-block'; // tier 2: blocking Atomics.wait off main thread
+    if (caps.sabAvailable)
+        return 'promise-poll'; // tier 3: Atomics.load poll on microtask/setTimeout(0)
+    return 'postMessage'; // no SAB:
+}
+//# sourceMappingURL=seams.js.map

package/dist/executor/seams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seams.js","sourceRoot":"","sources":["../../src/executor/seams.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,+FAA+F;AAC/F,8FAA8F;AAC9F,6FAA6F;AAC7F,0DAA0D;AAkC1D,mGAAmG;AACnG,MAAM,UAAU,cAAc,CAAC,IAAuB;IACpD,IAAI,IAAI,CAAC,SAAS;QAAE,OAAO,WAAW,CAAA,CAAC,4CAA4C;IACnF,IAAI,IAAI,CAAC,YAAY;QAAE,OAAO,mBAAmB,CAAA,CAAC,gDAAgD;IAClG,IAAI,IAAI,CAAC,YAAY;QAAE,OAAO,cAAc,CAAA,CAAC,uDAAuD;IACpG,OAAO,aAAa,CAAA,CAAC,UAAU;AACjC,CAAC"}

package/dist/executor/update-threaded.d.ts

@@ -0,0 +1,17 @@
+import type { SchedulePlan } from '../graph/index.js';
+import type { ExecutorEnv } from './run-wave.js';
+/** The slice of WorkerPool the threaded executor drives. Kept structural to avoid a hard dependency
+ * cycle on the concrete pool (the workers layer is the deeper sibling). */
+export interface RoundDispatcher {
+    runRound(batches: readonly {
+        systemId: import('@ecsia/schema').SystemId;
+        workerIndex: number;
+    }[], dt: number): Promise<void>;
+}
+/**
+ * Run one threaded tick: the whole schedule (worker waves) + reactivity flush. The frame order is
+ * byte-identical to the single-thread runUpdate (frameReset → waves → observerDrain → flushLogs);
+ * the only difference is that each round's worker batches run on workers.
+ */
+export declare function runUpdateThreaded(env: ExecutorEnv, plan: SchedulePlan, pool: RoundDispatcher, dt: number): Promise<void>;
+//# sourceMappingURL=update-threaded.d.ts.map

package/dist/executor/update-threaded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-threaded.d.ts","sourceRoot":"","sources":["../../src/executor/update-threaded.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,YAAY,EAA6B,MAAM,mBAAmB,CAAA;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAIhD;2EAC2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,EAAE,OAAO,eAAe,EAAE,QAAQ,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7H;AAmCD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAc9H"}