@woosh/meep-engine 2.169.6 → 2.170.0

package/src/engine/ecs/EntityManager.js

@@ -154,6 +154,27 @@ export class EntityManager {
      */
     dataset = null;
 
+    /**
+     * Objects consulted before each fixed step is executed. A gate that answers
+     * `false` postpones the step: {@link simulate} breaks out of the catch-up
+     * loop with the unconsumed time still in the accumulator, so the step runs
+     * on a later call instead of being skipped.
+     *
+     * This exists for systems whose work is performed off-thread and consumed a
+     * fixed number of ticks later (see {@link WorkerSystem}): the gate is what
+     * makes "step T-K is finished before tick T runs" an invariant rather than a
+     * hope, which is what lets such a system keep a synchronous `fixedUpdate`
+     * and stay deterministic — a gate can change *when* a step runs in
+     * wall-clock terms, never *what* it computes.
+     *
+     * A gate must be able to answer `false` only transiently. One that never
+     * opens freezes the simulation.
+     *
+     * @private
+     * @type {{may_advance: (next_tick: number) => boolean}[]}
+     */
+    #fixed_step_gates = [];
+
     /**
      * Whenever a system is added or removed, optimal execution plan changes, this flag tells us to rebuild the current plan
      * see {@link #systemsExecutionOrder}
@@ -251,6 +272,57 @@ export class EntityManager {
         // console.timeEnd('updateExecutionOrder')
     }
 
+    /**
+     * Register a gate consulted before each fixed step. Idempotent.
+     * @param {{may_advance: (next_tick: number) => boolean}} gate
+     * @see #fixed_step_gates
+     */
+    registerFixedStepGate(gate) {
+        assert.defined(gate, "gate");
+        assert.notNull(gate, "gate");
+        assert.isFunction(gate.may_advance, "gate.may_advance");
+
+        if (this.#fixed_step_gates.indexOf(gate) !== -1) {
+            return;
+        }
+
+        this.#fixed_step_gates.push(gate);
+    }
+
+    /**
+     * @param {{may_advance: (next_tick: number) => boolean}} gate
+     * @returns {boolean} whether the gate was registered
+     */
+    unregisterFixedStepGate(gate) {
+        const i = this.#fixed_step_gates.indexOf(gate);
+
+        if (i === -1) {
+            return false;
+        }
+
+        this.#fixed_step_gates.splice(i, 1);
+
+        return true;
+    }
+
+    /**
+     * @private
+     * @param {number} next_tick
+     * @returns {boolean} whether every gate permits advancing to `next_tick`
+     */
+    #fixed_step_gates_allow(next_tick) {
+        const gates = this.#fixed_step_gates;
+        const gate_count = gates.length;
+
+        for (let i = 0; i < gate_count; i++) {
+            if (!gates[i].may_advance(next_tick)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Get list of all components referenced by active systems
      * @returns {Class[]}
@@ -460,6 +532,15 @@ export class EntityManager {
 
         const t0 = performance.now();
         while (this.__fixedStepAccumulator >= fixed_step) {
+
+            // Off-thread producers get to postpone a step whose inputs are not
+            // ready yet. Breaking here leaves the time in the accumulator, so
+            // the step is deferred rather than dropped and the simulation stays
+            // on the same deterministic tick sequence.
+            if (this.#fixed_step_gates.length !== 0 && !this.#fixed_step_gates_allow(this.fixedStepTick + 1)) {
+                break;
+            }
+
             this.fixedStepTick++;
 
             for (let i = 0; i < system_count; i++) {

package/src/engine/ecs/animation/Animation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Animation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/Animation.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAsHI;;;;OAIG;IACH,4BAFa,SAAS,CAMrB;IA9HD;;;;;OAKG;IACH,0BAwBC;IAvBG;;;OAGG;IACH,OAFU,KAAK,aAAa,CAAC,CAEN;IAEvB,iBAAiB;IAMjB;;;OAGG;IACH,iBAFU,SAAO,IAAI,CAEJ;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEoD;IAWxE;;;OAGG;IACH,4BAEC;IAdD;;;OAGG;IACH,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAanB;IAED;;;OAGG;IACH,QAFa,MAAM,CAOlB;IAaD,0BAYC;IAED;;;MAKC;IAIL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;;kBAUS,MAAM;;iBAxKC,uCAAuC;8BAE1B,oBAAoB;+BACnB,qBAAqB"}
+{"version":3,"file":"Animation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/Animation.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAsHI;;;;OAIG;IACH,4BAFa,SAAS,CAMrB;IAtHD;;;;;OAKG;IACH,0BAgBC;IA9BD;;;OAGG;IACH,OAFU,KAAK,aAAa,CAAC,CAEV;IAEnB,iBAAa;IAaT;;;OAGG;IACH,iBAFU,SAAO,IAAI,CAEJ;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEoD;IAWxE;;;OAGG;IACH,4BAEC;IAdD;;;OAGG;IACH,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAanB;IAED;;;OAGG;IACH,QAFa,MAAM,CAOlB;IAaD,0BAYC;IAED;;;MAKC;IAIL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;;kBAUS,MAAM;;iBAxKC,uCAAuC;8BAE1B,oBAAoB;+BACnB,qBAAqB"}

package/src/engine/ecs/animation/Animation.js

@@ -8,6 +8,14 @@ import { AnimationFlags } from "./AnimationFlags.js";
  * @class
  */
 export class Animation {
+    /**
+     *
+     * @type {List<AnimationClip>}
+     */
+    clips = new List();
+
+    debtTime = 0;
+
     /**
      *
      * @param options
@@ -15,14 +23,6 @@ export class Animation {
      * @constructor
      */
     constructor(options) {
-        /**
-         *
-         * @type {List<AnimationClip>}
-         */
-        this.clips = new List();
-
-        this.debtTime = 0;
-
         if (options !== undefined) {
             this.fromJSON(options);
         }

package/src/engine/ecs/async/SystemWorkerHost.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Worker-side half of the {@link WorkerSystem} bridge.
+ *
+ * Owns the protocol; the *work* lives in a "core" object supplied by the caller:
+ *
+ * ```js
+ * // my.worker.js
+ * SystemWorkerHost.serve(new MyWorkerCore());
+ * ```
+ *
+ * A core implements two methods, both of which may be omitted:
+ *
+ *   - `boot(payload)` — one-off setup from the main thread's boot payload.
+ *   - `handleMessage(data, host)` — cold plane; structural changes.
+ *   - `step(tick, command)` — hot plane; runs once per dispatched tick with the
+ *     shared command region. Throwing is safe and is reported; see below.
+ *
+ * **Failure contract**: a throwing `step` sets {@link WorkerSystemControl.ERR}
+ * and posts the error on the cold plane, but still advances
+ * {@link WorkerSystemControl.DONE}. The main thread's fixed-step gate waits on
+ * `DONE`, so a step that failed to publish it would freeze the simulation — the
+ * pump must never leave a request unanswered.
+ *
+ * **Event-loop yielding**: while parked in `Atomics.wait`, a worker does not run
+ * its event loop, so `message` events queue up undelivered. The main thread
+ * bumps {@link WorkerSystemControl.MSG_SEQ} and notifies whenever it posts, and
+ * the pump responds by returning to the event loop and re-entering on a timer.
+ * This is why cold-plane traffic must stay rare — it costs a scheduling round
+ * trip — and why it must exist at all: nothing else can be delivered to a parked
+ * worker.
+ *
+ * The blocking pump lives in {@link SystemWorkerHost.serve}; the class itself is
+ * non-blocking, which is what lets tests drive a real host through
+ * {@link runPendingStep} without a real worker thread.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SystemWorkerHost {
+    /**
+     * Attach `core` to the worker global scope and run the blocking pump.
+     *
+     * The pump alternates between executing dispatched steps and parking on
+     * {@link WorkerSystemControl.REQ}. It returns to the event loop whenever a
+     * cold-plane message is pending or the park times out, re-entering on a
+     * zero-delay timer so queued `message` events are delivered first.
+     *
+     * @param {object} core
+     * @param {object} [scope] defaults to the worker global scope
+     * @returns {SystemWorkerHost}
+     */
+    static serve(core: object, scope?: object): SystemWorkerHost;
+    /**
+     * @param {object} core
+     */
+    constructor(core: object);
+    /**
+     * How long the pump parks in `Atomics.wait` before returning to the event
+     * loop anyway.
+     *
+     * A timeout is not strictly required — the main thread notifies on both
+     * dispatch and cold-plane posts — but there is a narrow window between the
+     * pump's pending-message check and its park in which a notify can find no
+     * waiter. The timeout bounds that delay, so it should stay small relative to
+     * a fixed step rather than merely finite.
+     * @type {number}
+     */
+    idle_timeout_ms: number;
+    /**
+     * @returns {boolean} true once the boot message has been processed.
+     */
+    get is_booted(): boolean;
+    /**
+     * Install message handling on `scope`. The bridge is not live until the main
+     * thread's boot message arrives and is answered with `{type: "ready"}`.
+     *
+     * @param {object} scope object exposing `postMessage` and an `onmessage` hook
+     */
+    attach(scope: object): void;
+    /**
+     * Run the pending step, if the main thread has dispatched one that has not
+     * been executed yet. Never blocks.
+     *
+     * @returns {boolean} whether a step was executed
+     */
+    runPendingStep(): boolean;
+    /**
+     * @returns {boolean} whether the main thread has asked the pump to stop.
+     */
+    isQuitRequested(): boolean;
+    /**
+     * @returns {boolean} whether cold-plane messages are queued but undelivered,
+     *                    meaning the pump must yield to the event loop.
+     */
+    hasPendingMessages(): boolean;
+    #private;
+}
+//# sourceMappingURL=SystemWorkerHost.d.ts.map

package/src/engine/ecs/async/SystemWorkerHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemWorkerHost.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/async/SystemWorkerHost.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAgKI;;;;;;;;;;;OAWG;IACH,mBAJW,MAAM,UACN,MAAM,GACJ,gBAAgB,CAmD5B;IAjKD;;OAEG;IACH,kBAFW,MAAM,EAIhB;IA/DD;;;;;;;;;;OAUG;IACH,iBAFU,MAAM,CAEK;IAsDrB;;OAEG;IACH,yBAEC;IAED;;;;;OAKG;IACH,cAFW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,kBAFa,OAAO,CA2CnB;IAED;;OAEG;IACH,mBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,sBAHa,OAAO,CAanB;;CA6HJ"}

package/src/engine/ecs/async/SystemWorkerHost.js

@@ -0,0 +1,329 @@
+import {
+    WORKER_SYSTEM_NO_TICK,
+    WorkerSystemControl,
+    worker_system_command_view,
+    worker_system_control_view
+} from "./WorkerSystemProtocol.js";
+
+/**
+ * Worker-side half of the {@link WorkerSystem} bridge.
+ *
+ * Owns the protocol; the *work* lives in a "core" object supplied by the caller:
+ *
+ * ```js
+ * // my.worker.js
+ * SystemWorkerHost.serve(new MyWorkerCore());
+ * ```
+ *
+ * A core implements two methods, both of which may be omitted:
+ *
+ *   - `boot(payload)` — one-off setup from the main thread's boot payload.
+ *   - `handleMessage(data, host)` — cold plane; structural changes.
+ *   - `step(tick, command)` — hot plane; runs once per dispatched tick with the
+ *     shared command region. Throwing is safe and is reported; see below.
+ *
+ * **Failure contract**: a throwing `step` sets {@link WorkerSystemControl.ERR}
+ * and posts the error on the cold plane, but still advances
+ * {@link WorkerSystemControl.DONE}. The main thread's fixed-step gate waits on
+ * `DONE`, so a step that failed to publish it would freeze the simulation — the
+ * pump must never leave a request unanswered.
+ *
+ * **Event-loop yielding**: while parked in `Atomics.wait`, a worker does not run
+ * its event loop, so `message` events queue up undelivered. The main thread
+ * bumps {@link WorkerSystemControl.MSG_SEQ} and notifies whenever it posts, and
+ * the pump responds by returning to the event loop and re-entering on a timer.
+ * This is why cold-plane traffic must stay rare — it costs a scheduling round
+ * trip — and why it must exist at all: nothing else can be delivered to a parked
+ * worker.
+ *
+ * The blocking pump lives in {@link SystemWorkerHost.serve}; the class itself is
+ * non-blocking, which is what lets tests drive a real host through
+ * {@link runPendingStep} without a real worker thread.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SystemWorkerHost {
+
+    /**
+     * How long the pump parks in `Atomics.wait` before returning to the event
+     * loop anyway.
+     *
+     * A timeout is not strictly required — the main thread notifies on both
+     * dispatch and cold-plane posts — but there is a narrow window between the
+     * pump's pending-message check and its park in which a notify can find no
+     * waiter. The timeout bounds that delay, so it should stay small relative to
+     * a fixed step rather than merely finite.
+     * @type {number}
+     */
+    idle_timeout_ms = 50;
+
+    /**
+     * @type {object}
+     */
+    #core;
+
+    /**
+     * The scope messages are received on and posted to — `globalThis` in a real
+     * worker.
+     * @type {object|null}
+     */
+    #scope = null;
+
+    /** @type {Int32Array|null} */
+    #control = null;
+
+    /** @type {Float64Array|null} */
+    #command = null;
+
+    /**
+     * Last tick handed to the core, whether it succeeded or threw.
+     * @type {number}
+     */
+    #last_step = WORKER_SYSTEM_NO_TICK;
+
+    /**
+     * Number of cold-plane messages handled so far, mirrored into
+     * {@link WorkerSystemControl.ACK_SEQ}. The boot message is not counted — it
+     * precedes the main thread's first `MSG_SEQ` bump.
+     * @type {number}
+     */
+    #handled_message_count = 0;
+
+    /**
+     * Re-entry point for the blocking pump, installed by {@link serve}. Null when
+     * the host is driven manually (tests).
+     * @type {(() => void)|null}
+     */
+    #resume_pump = null;
+
+    /**
+     * Whether a pump re-entry is already queued.
+     * @type {boolean}
+     */
+    #pump_scheduled = false;
+
+    /**
+     * @param {object} core
+     */
+    constructor(core) {
+        this.#core = core;
+    }
+
+    /**
+     * @returns {boolean} true once the boot message has been processed.
+     */
+    get is_booted() {
+        return this.#control !== null;
+    }
+
+    /**
+     * Install message handling on `scope`. The bridge is not live until the main
+     * thread's boot message arrives and is answered with `{type: "ready"}`.
+     *
+     * @param {object} scope object exposing `postMessage` and an `onmessage` hook
+     */
+    attach(scope) {
+        this.#scope = scope;
+
+        scope.onmessage = (event) => {
+            this.#receive(event.data);
+        };
+    }
+
+    /**
+     * Run the pending step, if the main thread has dispatched one that has not
+     * been executed yet. Never blocks.
+     *
+     * @returns {boolean} whether a step was executed
+     */
+    runPendingStep() {
+        const control = this.#control;
+
+        if (control === null) {
+            return false;
+        }
+
+        const requested = Atomics.load(control, WorkerSystemControl.REQ);
+
+        if (requested === this.#last_step || requested === WORKER_SYSTEM_NO_TICK) {
+            return false;
+        }
+
+        this.#last_step = requested;
+
+        let error_code = 0;
+
+        try {
+            this.#core.step(requested, this.#command);
+        } catch (e) {
+            error_code = 1;
+
+            console.error(`SystemWorkerHost: step ${requested} failed:`, e);
+
+            this.#post({
+                type: "error",
+                tick: requested,
+                message: e instanceof Error ? e.message : String(e),
+                stack: e instanceof Error ? e.stack : ""
+            });
+        }
+
+        Atomics.store(control, WorkerSystemControl.ERR, error_code);
+
+        // Published LAST, and only after ERR: the main thread treats a DONE at
+        // or past its awaited tick as permission to read everything above.
+        // No notify — the main thread is not allowed to Atomics.wait, so it
+        // polls DONE instead and a notify here would be a syscall for nobody.
+        Atomics.store(control, WorkerSystemControl.DONE, requested);
+
+        return true;
+    }
+
+    /**
+     * @returns {boolean} whether the main thread has asked the pump to stop.
+     */
+    isQuitRequested() {
+        return this.#control !== null && Atomics.load(this.#control, WorkerSystemControl.QUIT) !== 0;
+    }
+
+    /**
+     * @returns {boolean} whether cold-plane messages are queued but undelivered,
+     *                    meaning the pump must yield to the event loop.
+     */
+    hasPendingMessages() {
+        if (this.#control === null) {
+            return false;
+        }
+
+        // Deliberately an ORDERED comparison. An equality test turns any
+        // divergence — a restarted bridge, a handler that threw — into a
+        // permanent "always pending" state, and since the pump yields whenever
+        // this is true, that would stop the worker executing steps forever.
+        return Atomics.load(this.#control, WorkerSystemControl.MSG_SEQ) > this.#handled_message_count;
+    }
+
+    /**
+     * Attach `core` to the worker global scope and run the blocking pump.
+     *
+     * The pump alternates between executing dispatched steps and parking on
+     * {@link WorkerSystemControl.REQ}. It returns to the event loop whenever a
+     * cold-plane message is pending or the park times out, re-entering on a
+     * zero-delay timer so queued `message` events are delivered first.
+     *
+     * @param {object} core
+     * @param {object} [scope] defaults to the worker global scope
+     * @returns {SystemWorkerHost}
+     */
+    static serve(core, scope = globalThis) {
+        const host = new SystemWorkerHost(core);
+
+        host.attach(scope);
+
+        const pump = () => {
+            for (; ;) {
+                if (host.isQuitRequested()) {
+                    return;
+                }
+
+                if (!host.is_booted) {
+                    // Boot has not landed yet; it arrives as a message.
+                    host.#schedule_pump();
+                    return;
+                }
+
+                // The dispatched step runs FIRST. The main thread never
+                // references state introduced by an unacknowledged message, so a
+                // pending message is not a precondition for stepping — and
+                // making it one would put the hot plane at the mercy of the cold
+                // one, where a single undelivered message stalls the simulation.
+                if (host.runPendingStep()) {
+                    continue;
+                }
+
+                if (host.hasPendingMessages()) {
+                    host.#schedule_pump();
+                    return;
+                }
+
+                const control = host.#control;
+                const requested = Atomics.load(control, WorkerSystemControl.REQ);
+
+                if (Atomics.wait(control, WorkerSystemControl.REQ, requested, host.idle_timeout_ms) === "timed-out") {
+                    host.#schedule_pump();
+                    return;
+                }
+            }
+        };
+
+        host.#resume_pump = () => {
+            host.#pump_scheduled = false;
+            pump();
+        };
+
+        host.#schedule_pump();
+
+        return host;
+    }
+
+    /**
+     * @param {*} data
+     */
+    #receive(data) {
+        if (data !== null && typeof data === "object" && data.type === "boot") {
+            this.#control = worker_system_control_view(data.buffer);
+            this.#command = worker_system_command_view(data.buffer);
+
+            if (typeof this.#core.boot === "function") {
+                this.#core.boot(data.payload);
+            }
+
+            this.#post({ type: "ready" });
+
+            return;
+        }
+
+        try {
+            if (typeof this.#core.handleMessage === "function") {
+                this.#core.handleMessage(data, this);
+            }
+        } finally {
+            // Counted even when the handler threw. The count is "messages
+            // consumed", not "messages consumed successfully" — leaving it
+            // behind would strand hasPendingMessages() permanently true and stop
+            // the pump ever running another step.
+            this.#handled_message_count++;
+
+            if (this.#control !== null) {
+                Atomics.store(this.#control, WorkerSystemControl.ACK_SEQ, this.#handled_message_count);
+            }
+
+            this.#schedule_pump();
+        }
+    }
+
+    /**
+     * Queue one pump re-entry, at most.
+     *
+     * Without the guard, every cold-plane message would start an additional
+     * independent pump loop — the pump schedules itself when it yields, and the
+     * message handler schedules it again — so the number of concurrent pump
+     * chains would grow monotonically for the life of the worker.
+     */
+    #schedule_pump() {
+        if (this.#resume_pump === null || this.#pump_scheduled) {
+            return;
+        }
+
+        this.#pump_scheduled = true;
+
+        this.#scope.setTimeout(this.#resume_pump, 0);
+    }
+
+    /**
+     * @param {*} message
+     */
+    #post(message) {
+        this.#scope.postMessage(message);
+    }
+}

package/src/engine/ecs/async/SystemWorkerLoopback.d.ts

@@ -0,0 +1,80 @@
+/**
+ * An in-process stand-in for a `Worker`, for testing a {@link WorkerSystem}
+ * without a worker thread.
+ *
+ * A browser `Worker` is a genuine platform boundary — it cannot exist under
+ * node — so it is the one piece a test must supply itself. Everything on the
+ * other side of it is real: a real {@link SystemWorkerHost}, the real core, a
+ * real {@link SharedArrayBuffer}, real `Atomics`. What this class replaces is
+ * only the thread and the message pipe.
+ *
+ * Messages are **queued, not delivered**, until {@link flush} is called, and
+ * steps run only when {@link runPendingStep} is called. That is the point: it
+ * makes the two things that are genuinely concurrent in production — message
+ * delivery and step execution — explicit events a test can order at will,
+ * including orderings a real worker would only produce under unlucky timing.
+ *
+ * Messages pass by reference rather than being structured-cloned. For the
+ * shared buffer that matches production exactly; for anything else, a test that
+ * depends on the difference is testing the clone, not the bridge.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SystemWorkerLoopback {
+    /**
+     * @param {object} core the worker-side core under test
+     */
+    constructor(core: object);
+    /**
+     * Main-thread message handler, assigned by {@link WorkerSystem}.
+     * @type {((event: {data: *}) => void)|null}
+     */
+    onmessage: (event: {
+        data: any;
+    }) => void;
+    /**
+     * @type {((event: *) => void)|null}
+     */
+    onerror: (event: any) => void;
+    /**
+     * @type {boolean}
+     */
+    terminated: boolean;
+    /**
+     * @returns {SystemWorkerHost}
+     */
+    get host(): SystemWorkerHost;
+    /**
+     * @returns {number} messages queued in either direction
+     */
+    get queued_message_count(): number;
+    /**
+     * `Worker` interface — called by {@link WorkerSystem}.
+     * @param {*} message
+     */
+    postMessage(message: any): void;
+    /**
+     * `Worker` interface.
+     */
+    terminate(): void;
+    /**
+     * Deliver every queued message in both directions, including any sent in
+     * response, until both queues are empty.
+     */
+    flush(): void;
+    /**
+     * Execute one dispatched step, if the main thread has published one.
+     * @returns {boolean} whether a step ran
+     */
+    runPendingStep(): boolean;
+    /**
+     * Raise a worker-level failure, as a real `Worker` would on a module load
+     * error or an uncaught top-level throw.
+     * @param {string} message
+     */
+    failWorker(message: string): void;
+    #private;
+}
+import { SystemWorkerHost } from "./SystemWorkerHost.js";
+//# sourceMappingURL=SystemWorkerLoopback.d.ts.map

package/src/engine/ecs/async/SystemWorkerLoopback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemWorkerLoopback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/async/SystemWorkerLoopback.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAiCI;;OAEG;IACH,kBAFW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,mBAFmB;QAAC,IAAI,MAAG;KAAC,KAAK,IAAI,CAEpB;IAEjB;;OAEG;IACH,yBAFyB,IAAI,CAEd;IAEf;;OAEG;IACH,YAFU,OAAO,CAEE;IAgCnB;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,cAgBC;IAED;;;OAGG;IACH,kBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAMhB;;CACJ;iCA9IgC,uBAAuB"}