@woosh/meep-engine 2.169.6 → 2.170.0

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

@@ -0,0 +1,143 @@
+import { SystemWorkerHost } from "./SystemWorkerHost.js";
+
+/**
+ * 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 {
+
+    /**
+     * Main-thread message handler, assigned by {@link WorkerSystem}.
+     * @type {((event: {data: *}) => void)|null}
+     */
+    onmessage = null;
+
+    /**
+     * @type {((event: *) => void)|null}
+     */
+    onerror = null;
+
+    /**
+     * @type {boolean}
+     */
+    terminated = false;
+
+    /** @type {SystemWorkerHost} */
+    #host;
+
+    /**
+     * Stands in for the worker's global scope.
+     * @type {{onmessage: ((event: {data: *}) => void)|null, postMessage: (message: *) => void}}
+     */
+    #worker_scope;
+
+    /** @type {*[]} */
+    #to_worker = [];
+
+    /** @type {*[]} */
+    #to_main = [];
+
+    /**
+     * @param {object} core the worker-side core under test
+     */
+    constructor(core) {
+        this.#worker_scope = {
+            onmessage: null,
+            postMessage: (message) => {
+                this.#to_main.push(message);
+            }
+        };
+
+        this.#host = new SystemWorkerHost(core);
+        this.#host.attach(this.#worker_scope);
+    }
+
+    /**
+     * @returns {SystemWorkerHost}
+     */
+    get host() {
+        return this.#host;
+    }
+
+    /**
+     * @returns {number} messages queued in either direction
+     */
+    get queued_message_count() {
+        return this.#to_worker.length + this.#to_main.length;
+    }
+
+    /**
+     * `Worker` interface — called by {@link WorkerSystem}.
+     * @param {*} message
+     */
+    postMessage(message) {
+        this.#to_worker.push(message);
+    }
+
+    /**
+     * `Worker` interface.
+     */
+    terminate() {
+        this.terminated = true;
+    }
+
+    /**
+     * Deliver every queued message in both directions, including any sent in
+     * response, until both queues are empty.
+     */
+    flush() {
+        while (this.#to_worker.length !== 0 || this.#to_main.length !== 0) {
+            while (this.#to_worker.length !== 0) {
+                const message = this.#to_worker.shift();
+
+                this.#worker_scope.onmessage({ data: message });
+            }
+
+            while (this.#to_main.length !== 0) {
+                const message = this.#to_main.shift();
+
+                if (this.onmessage !== null) {
+                    this.onmessage({ data: message });
+                }
+            }
+        }
+    }
+
+    /**
+     * Execute one dispatched step, if the main thread has published one.
+     * @returns {boolean} whether a step ran
+     */
+    runPendingStep() {
+        return this.#host.runPendingStep();
+    }
+
+    /**
+     * 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) {
+        if (this.onerror !== null) {
+            this.onerror({ message });
+        }
+    }
+}

package/src/engine/ecs/async/WORKER_SYSTEM_PLAN.md

@@ -0,0 +1,246 @@
+# `WorkerSystem` (Design A) — implementation plan
+
+Companion to [`../ASYNC_SYSTEMS_PROPOSAL.md`](../ASYNC_SYSTEMS_PROPOSAL.md). This is the
+SharedArrayBuffer + Atomics variant with a **synchronous hot path**: the `System`
+tick stays synchronous, the worker owns the data between ticks, and a fixed-step
+gate in `EntityManager` keeps exactly one step in flight.
+
+> **Status: implemented.** Where the built code diverged from this plan, the plan
+> has been updated to match — see §6.
+
+First consumer: `WorkerFluidSystem`, a drop-in alternative to `FluidSystem`.
+
+---
+
+## 1. Design in one page
+
+Per fixed tick `T`, a `WorkerSystem` does exactly two things:
+
+1. **Join** the outstanding step — the gate has already guaranteed its `DONE`, so
+   this is a load and a hook call, never a wait.
+2. **Dispatch** step `T` — write the command words, `Atomics.store(REQ, T)`,
+   `Atomics.notify`.
+
+Between dispatch and the next join the **worker owns the shared state**. The main
+thread must not touch it. The gate makes that safe for the simulation:
+`EntityManager` refuses to begin a tick while a step is outstanding, so every
+system's `fixedUpdate` runs with the worker idle.
+
+**Exactly one step is in flight**, which is structural rather than a tuning knob.
+The worker mutates shared state in place, so the main thread has nowhere to build
+a second step's input while the first runs; and `REQ` holds a single tick, so a
+second dispatch before the worker consumed the first would overwrite it and
+silently drop a step. A deeper pipeline needs double-buffered payloads and a
+request queue — a different design, not a parameter on this one.
+
+```
+fixed tick:      T                        T+1                      T+2
+main thread:  join(T-1)                join(T)                  join(T+1)
+              dispatch(T)              dispatch(T+1)            dispatch(T+2)
+              ...other systems,        ...other systems,
+                 render, idle...          render, idle...
+worker:          └── steps T ─────────┘  └── steps T+1 ────────┘
+```
+
+Two planes:
+
+- **Hot plane** — `Atomics` over a `SharedArrayBuffer`. Per-tick, zero-copy,
+  zero allocation, no message queue.
+- **Cold plane** — `postMessage`. Structural changes only (register a new field,
+  boot payloads). Rare, and never on the critical path.
+
+Because a futex-parked worker (`Atomics.wait`) does not turn its event loop, cold
+messages would never be delivered while the worker is parked or busy. A `MSG_SEQ`
+counter + `notify` wakes the pump, which yields to the event loop, lets the
+message land, and re-enters via `setTimeout(0)`. The main thread does **not**
+stall on this: newly registered work is simply excluded from dispatch until the
+worker acks it via `ACK_SEQ`.
+
+### Control block (`Int32Array` header at the head of one SAB)
+
+| slot | name | writer | meaning |
+|---|---|---|---|
+| 0 | `REQ` | main | latest dispatched tick |
+| 1 | `DONE` | worker | latest completed tick |
+| 2 | `ERR` | worker | 0 = ok, else the step threw |
+| 3 | `QUIT` | main | 1 = terminate the pump |
+| 4 | `MSG_SEQ` | main | bumped when a cold message is posted |
+| 5 | `ACK_SEQ` | worker | echoes `MSG_SEQ` once handled |
+
+Publication is protocol-ordered, not per-word-atomic: the worker finishes all
+plain writes to the shared payload, *then* seq-cst-stores `DONE`. Main seq-cst-loads
+`DONE ≥ T` *before* reading. That pair is the happens-before edge, so the payload
+itself needs no atomics.
+
+Followed by a `Float64Array` **command region** — per-tick parameters, written by
+main before the `REQ` store, read by the worker after the `REQ` load.
+
+### Deadlock safety
+
+The gate is the one new way to stall the simulation, so every path must be
+provably non-blocking:
+
+| situation | outcome |
+|---|---|
+| worker computing | `DONE` lands → gate opens |
+| step threw | host sets `ERR` **and** `DONE` → gate opens, main disables the system |
+| worker `onerror` / dead | `#failed = true` → gate returns `true` unconditionally |
+| worker never booted | gate is registered *after* the ready handshake; `startup` never resolves, so `fixedUpdate` never runs |
+| **worker hangs or is killed silently** | no `DONE`, no `error` event — caught by a wall-clock deadline (`step_deadline_ms`) that fails the bridge, which opens the gate |
+| shutdown | gate unregistered before terminate |
+| never dispatched (priming, `collect` declined, detached dataset) | nothing in flight → gate returns `true` |
+| `collect` / `apply` throws | `EntityManager` logs it; no dispatch happens that tick, so the gate stays open |
+
+A worker that is merely *slow* costs the bounded spin, then the loop breaks with
+the accumulator loaded.
+
+**A gated system runs at most one fixed step per `simulate()` call.** Once it has
+dispatched, the gate closes for the rest of that cycle, so the fixed rate is
+capped at the rate `simulate()` is called — normally the frame rate. Unlike an
+over-budget main-thread system, which can still run several steps inside the
+15 ms catch-up budget, a gated one cannot repay accumulated debt at all: if the
+worker cannot sustain the fixed step rate, the simulation runs slower than real
+time indefinitely and `__fixedStepAccumulator` grows without bound. This is
+reported once via `console.warn` after `BLOCKED_CYCLES_BEFORE_WARNING`
+consecutive blocked cycles, because the failure is otherwise invisible — the
+fixed loop's own runaway warning sits downstream of the gate's `break` and never
+fires. Fixed step size and per-step worker cost have to be chosen with that
+ceiling in mind.
+
+---
+
+## 2. Files
+
+### Framework — `engine/ecs/async/`
+
+| file | contents |
+|---|---|
+| `WorkerSystemProtocol.js` | control-slot enum, sizing, `worker_system_allocate_shared`, spin helper |
+| `WorkerSystem.js` | `WorkerSystem extends System` — lifecycle, hot path, cold path, gate |
+| `SystemWorkerHost.js` | worker-side pump: wait → step → publish, message yield, error capture |
+| `SystemWorkerLoopback.js` | in-process stand-in for a `Worker`, so bridges are testable without a thread |
+| `WorkerSystem.spec.js` | main-thread lifecycle + gate, real SABs, real atomics |
+| `SystemWorkerHost.spec.js` | worker-side pump including the real `Atomics.wait` park |
+
+### Core hook — `engine/ecs/EntityManager.js`
+
+`registerFixedStepGate(gate)` / `unregisterFixedStepGate(gate)` plus one check in
+the fixed loop before `fixedStepTick++`. No other semantics change; when no gate
+is registered the added cost is one `length !== 0` test per step.
+
+### Fluid — `engine/physics/fluid/`
+
+| file | contents |
+|---|---|
+| `FluidField.js` | **modified**: `shared_memory` flag → single-SAB allocation, `getSharedDescriptor()` / `fromSharedDescriptor()` |
+| `ecs/fluid_reanchor_field.js`, `ecs/fluid_build_world_to_grid.js`, `ecs/fluid_gather_visible_effectors.js`, `ecs/fluid_sync_effectors_from_transform.js` | **extracted** from `FluidSystem` so both systems share one implementation rather than two that can drift |
+| `ecs/fluid_worker_protocol.js` | command word layout + enum packing, shared by both sides |
+| `ecs/FluidWorkerCore.js` | worker-side logic — pure, no worker globals, node-testable |
+| `ecs/WorkerFluidSystem.js` | the system |
+| `ecs/fluid.worker.js` | worker entry: `SystemWorkerHost.serve(new FluidWorkerCore())` |
+| `ecs/makeFluidWorker.js` | `new Worker(new URL(...))` factory — **never imported by specs** (`import.meta` is a Jest parse error) |
+| `ecs/WorkerFluidSystem.spec.js` | parity vs `FluidSystem`, ownership, lifecycle |
+
+---
+
+## 3. `WorkerFluidSystem` specifics
+
+### Work split
+
+`FluidSimulator.step()` phase 1 is "apply effectors"; phases 2–6 are the solve
+(~80% of which is the pressure Poisson). So:
+
+- **main thread**: reanchor/shift, effector `syncFromTransform`, AABB broad-phase,
+  and `effector.apply(field, dt, world_to_grid)` — arbitrary user-authored
+  effector classes keep running on the main thread, unserialized.
+- **worker**: `sim.step(field, dt, [], IDENTITY)` — the *same* method with an empty
+  effector list, which is exactly phases 2–6.
+
+This needs **zero changes to `FluidSimulator`**, and makes parity exact by
+construction: identical code, identical order, identical float data.
+
+### Memory
+
+`FluidField` gains one opt-in flag. When `shared_memory = true`, `build()` allocates
+a **single** `SharedArrayBuffer` and sub-views every buffer into it (f32 lattices
+first, then the u8 masks, each offset aligned to its element size), so the whole
+field travels as one object on the cold plane. Layout is derived deterministically
+from `(resolution, scalar names, half_precision_pressure)`, so
+`fromSharedDescriptor` recomputes identical offsets rather than shipping a table.
+
+`makeArrayBuffer` is deliberately **not** used: it reads the bare global
+`crossOriginIsolated` (a `ReferenceError` under node) and silently falls back to a
+non-shared `ArrayBuffer`, which for a worker bridge is a silent correctness
+disaster — main and worker would each mutate their own copy. `WorkerFluidSystem`
+instead throws at link time when a field isn't SAB-backed.
+
+### Drop-in scope
+
+Drop-in at the system level: `FluidComponent`, effectors, `FluidObstacleSystem`,
+and the sampling API are untouched. Two things the caller must do:
+
+1. `field.shared_memory = true` before `field.build()` (throws with instructions
+   otherwise).
+2. Supply a worker factory: `new WorkerFluidSystem({ worker_factory: makeFluidWorker })`.
+
+### Ownership contract (the one real semantic difference)
+
+`FluidSystem` leaves the field consistent at all times. `WorkerFluidSystem` leaves
+it worker-owned between dispatch and the next join. Precisely:
+
+- Systems that touch fluid fields must run **earlier in the fixed pass** than
+  `WorkerFluidSystem`. Note this is *not* controlled by registration order:
+  `updateExecutionOrder` sorts by a score derived from `components_used`, and
+  registration order only breaks exact ties. `FluidObstacleSystem` does sort
+  first today, in both registration orders, and `WorkerFluidSystem.spec.js` pins
+  that as a standing assertion — because if the scheduler ever reorders the two,
+  the symptom is a silent data race rather than a visible failure.
+- `update()`-phase and render-phase readers see a step in progress. **Today there
+  are no such readers** — the fluid package has no consumers anywhere else in the
+  codebase (verified) — so the exposure is zero, but it is a real constraint and is
+  documented on the class. The escape hatch, if a reader ever appears, is a
+  double-buffered publish slot (2× memory, one worker-side copy per step); not
+  built now because it would erase most of the zero-copy win for a hypothetical.
+
+### Latency
+
+One tick (`K = 1`) of visible latency: at tick `T` the field shows the result of
+step `T − 1`. The *sequence* of states is identical to `FluidSystem`'s, only
+observed one tick later.
+
+---
+
+## 4. Testing
+
+Real `SharedArrayBuffer`, real `Atomics`, real `FluidSimulator`, real
+`EntityManager`/`EntityComponentDataset`/`Entity`. The only stand-in is the browser
+`Worker` itself — a genuine platform boundary that cannot exist in node, faked by a
+`LoopbackWorker` that implements the same message interface and lets the spec drive
+the real `SystemWorkerHost`/`FluidWorkerCore` pump by hand. All protocol logic,
+atomics, and solver code under test is production code.
+
+Cases:
+
+1. **Protocol** — dispatch/join round trip; `DONE` ordering; `ERR` capture keeps
+   `DONE` advancing; cold message yield + ack.
+2. **Gate** — blocks advancement until the result lands; opens for a failed worker;
+   opens when nothing was dispatched; accumulator retains time on block.
+3. **Parity** — `FluidSystem` and `WorkerFluidSystem` over an identical scene
+   (moving transform, effectors, obstacles) for N ticks produce **bit-identical**
+   fields.
+4. **Ownership** — the field is not mutated by the main thread between dispatch
+   and join.
+5. **Lifecycle** — link/unlink registers/removes fields; non-shared field throws;
+   shutdown settles and terminates.
+
+---
+
+## 5. Order of work
+
+1. `WorkerSystemProtocol.js` + `SystemWorkerHost.js` + `WorkerSystem.js`
+2. `EntityManager` gate + spec
+3. `WorkerSystem.spec.js`
+4. `FluidField` shared allocation + spec additions
+5. `fluid_worker_protocol.js`, `FluidWorkerCore.js`, `WorkerFluidSystem.js`, entry + factory
+6. `WorkerFluidSystem.spec.js` (parity is the gate)
+7. Adversarial review, then commit

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

@@ -0,0 +1,173 @@
+/**
+ * Returned by {@link WorkerSystem.postToWorker} when the message could not be
+ * sent. Never acknowledged, so {@link WorkerSystem.isMessageHandled} reports
+ * `false` for it rather than reporting a dropped message as delivered.
+ * @type {number}
+ */
+export const WORKER_SYSTEM_MESSAGE_NOT_SENT: number;
+/**
+ * A {@link System} whose per-tick work runs on a worker thread over shared
+ * memory, with a **synchronous** hot path.
+ *
+ * Each fixed tick `T` the system does exactly two things:
+ *
+ *   1. **join** step `T - 1` — already guaranteed complete by the fixed-step
+ *      gate, so this is a load and an {@link apply} call, not a wait;
+ *   2. **dispatch** step `T` — {@link collect} writes the command words, then a
+ *      single `Atomics.store` publishes the request.
+ *
+ * Between dispatch and the next join **the worker owns the shared state** and
+ * the main thread must not touch it. That is made safe for the simulation by a
+ * gate registered with {@link EntityManager}: the fixed loop will not advance
+ * into tick `T + 1` until step `T` has landed, so every system's `fixedUpdate`
+ * runs with the worker idle. Subclasses must document the same constraint for
+ * any main-thread reader outside the fixed pass.
+ *
+ * Exactly one step is in flight at a time — see {@link #in_flight} for why that
+ * is structural rather than a tuning choice.
+ *
+ * Nothing here is `async` on the hot path, deliberately. `await` always defers
+ * its continuation to a microtask, so an `async fixedUpdate` could never consume
+ * a result during the pass even when shared memory shows it has been ready for
+ * milliseconds; the coroutine form would buy syntax while costing the manager's
+ * synchronous-pass guarantees. See `ASYNC_SYSTEMS_PROPOSAL.md`.
+ *
+ * Subclasses implement:
+ *
+ *   - {@link createWorker} — spawn the worker (kept as a hook so the spawn
+ *     expression, which needs `import.meta.url` under webpack, stays out of any
+ *     module a test might import);
+ *   - {@link collect} — on-tick, prepare shared state and command words;
+ *   - {@link apply} — on-tick, integrate a completed step;
+ *   - optionally {@link buildBootPayload}, {@link handleWorkerMessage}.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class WorkerSystem extends System<any> {
+    constructor();
+    /**
+     * Milliseconds the fixed-step gate spins waiting for a result before giving
+     * up on this cycle.
+     *
+     * Spinning is worth a little because a worker that is *nearly* done costs
+     * far less here than a whole ticker cycle of delay. When the budget expires
+     * the fixed loop simply breaks with the accumulator loaded, and catches up
+     * on a later call — the wait affects wall-clock pacing only, never which
+     * state a tick computes.
+     *
+     * @type {number}
+     */
+    join_spin_budget_ms: number;
+    /**
+     * Size of the command region, in `Float64` words.
+     * @type {number}
+     */
+    command_word_count: number;
+    /**
+     * Milliseconds a step may stay outstanding before the bridge is failed.
+     * @see DEFAULT_STEP_DEADLINE_MS
+     * @type {number}
+     */
+    step_deadline_ms: number;
+    /**
+     * @returns {boolean} whether the bridge is live.
+     */
+    get is_worker_alive(): boolean;
+    /**
+     * @returns {number} latest tick whose result has been applied.
+     */
+    get last_joined_tick(): number;
+    /**
+     * Whether a step is currently outstanding — equivalently, whether the worker
+     * currently owns the shared state. Subclasses should expose this rather than
+     * tracking ownership separately, so the two cannot disagree (in particular
+     * after a failure, where no join ever happens).
+     *
+     * @returns {boolean}
+     */
+    get is_step_in_flight(): boolean;
+    /**
+     * Create the worker. Called once during {@link startup}.
+     *
+     * Under webpack the idiomatic body is
+     * `new Worker(new URL("./x.worker.js", import.meta.url), { type: "module" })`
+     * — keep that expression in a module no test imports, because `import.meta`
+     * is a parse error under the CommonJS transform Jest uses.
+     *
+     * @returns {Worker}
+     */
+    createWorker(): Worker;
+    /**
+     * One-off payload delivered with the boot message, before the worker reports
+     * ready.
+     * @returns {*}
+     */
+    buildBootPayload(): any;
+    /**
+     * Prepare shared state and write the command words for tick `tick`. Runs
+     * on-tick with the worker idle, so it has exclusive access to everything the
+     * worker touches.
+     *
+     * @param {Float64Array} command
+     * @param {number} tick
+     * @param {number} time_delta_seconds
+     * @returns {boolean} `false` to skip dispatching this tick
+     */
+    collect(command: Float64Array, tick: number, time_delta_seconds: number): boolean;
+    /**
+     * Integrate the result of `tick`. Runs on-tick, at this system's position in
+     * the execution order, with the worker idle.
+     *
+     * Bridges whose results live entirely in shared memory (the worker mutated
+     * them in place) have nothing to do here.
+     *
+     * @param {number} tick
+     */
+    apply(tick: number): void;
+    /**
+     * A cold-plane message from the worker. `{type: "ready"}` and
+     * `{type: "error"}` are consumed by the base class and never reach this.
+     * @param {*} data
+     */
+    handleWorkerMessage(data: any): void;
+    /**
+     * Fixed-step gate consulted by {@link EntityManager} before it advances the
+     * simulation. Returns whether the result this system will need at
+     * `next_tick` is available.
+     *
+     * Every "not available" path must be transient, or the simulation freezes.
+     * The gate opens unconditionally when the bridge has failed and whenever
+     * nothing is in flight — which covers priming and ticks {@link collect}
+     * declined.
+     *
+     * `next_tick` is unused: the invariant is that no step is outstanding when a
+     * tick begins, which does not depend on which tick is next.
+     *
+     * @param {number} next_tick
+     * @returns {boolean}
+     */
+    may_advance(next_tick: number): boolean;
+    /**
+     * Send a structural message to the worker and wake its pump so the message
+     * can actually be delivered (a worker parked in `Atomics.wait` never runs its
+     * event loop).
+     *
+     * Rare by design — every cold-plane post costs the worker a scheduling round
+     * trip.
+     *
+     * @param {*} message
+     * @param {Transferable[]} [transfer]
+     * @returns {number} sequence number; pass to {@link isMessageHandled} to tell
+     *                   when the worker has consumed it
+     */
+    postToWorker(message: any, transfer?: Transferable[]): number;
+    /**
+     * @param {number} sequence value returned by {@link postToWorker}
+     * @returns {boolean} whether the worker has consumed that message
+     */
+    isMessageHandled(sequence: number): boolean;
+    #private;
+}
+import { System } from "../System.js";
+//# sourceMappingURL=WorkerSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/async/WorkerSystem.js"],"names":[],"mappings":"AA+CA;;;;;GAKG;AACH,6CAFU,MAAM,CAEiC;AAUjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;;IAEI;;;;;;;;;;;OAWG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,oBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,kBAFU,MAAM,CAE4B;IAuE5C;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;;;OAOG;IACH,iCAEC;IAMD;;;;;;;;;OASG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;;;OASG;IACH,iBALW,YAAY,QACZ,MAAM,sBACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,YAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,qCAEC;IAyLD;;;;;;;;;;;;;;;OAeG;IACH,uBAHW,MAAM,GACJ,OAAO,CAuDnB;IAMD;;;;;;;;;;;;OAYG;IACH,sCAJW,YAAY,EAAE,GACZ,MAAM,CAoBlB;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,OAAO,CAQnB;;CAgHJ;uBA3rBsB,cAAc"}