@woosh/meep-engine 3.30.0 → 3.32.0

package/src/engine/network/correction/Correction.js

@@ -0,0 +1,143 @@
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+/**
+ * @typedef {import("../../ecs/EntityManager.js").EntityManager} EntityManager
+ * @typedef {import("../../interpolation/InterpolationSystem.js").InterpolationSystem} InterpolationSystem
+ * @typedef {import("../../ecs/storage/binary/BinaryClassSerializationAdapter.js").BinaryClassSerializationAdapter} BinaryClassSerializationAdapter
+ */
+
+/**
+ * Where a correction lands: the live component of an entity, and what follows it. The session fills
+ * one in for every component it corrects and hands it to {@link Correction#apply}; read it there, do
+ * not keep it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class CorrectionTarget {
+    /**
+     * The engine the entity lives in — for a correction that has to go through the system that owns
+     * the component (a rigid body's pose goes through its physics system).
+     * @type {EntityManager|null}
+     */
+    entity_manager = null;
+
+    /** @type {number} */
+    entity = -1;
+
+    /**
+     * The live component being corrected.
+     * @type {object|null}
+     */
+    component = null;
+
+    /**
+     * The engine's interpolation system, for a correction that hides its step in what is drawn
+     * ({@link InterpolationSystem#correct}); null when there is none.
+     * @type {InterpolationSystem|null}
+     */
+    interpolation = null;
+
+    /**
+     * The component's replication adapter.
+     * @type {BinaryClassSerializationAdapter|null}
+     */
+    adapter = null;
+
+    /** @type {BinaryBuffer} */
+    #scratch = new BinaryBuffer();
+
+    /**
+     * Make the live component `state`, as the wire carries it: through the component's replication
+     * adapter.
+     * @param {object} state a decoded state of the component
+     */
+    write(state) {
+        const buffer = this.#scratch;
+        buffer.position = 0;
+        this.adapter.serialize(buffer, state);
+        buffer.position = 0;
+        this.adapter.deserialize(buffer, this.component);
+    }
+}
+
+/**
+ * How a client corrects one replicated component of an entity it predicts, when it reconciles by
+ * comparison ({@link NetworkSessionReconcile.Correct}).
+ *
+ * The host's state of the entity at frame S arrives some frames after the client predicted S. The
+ * session compares the two — their wire images first, and only where those differ, through
+ * {@link same} — and when they disagree, hands the strategy both: the host's state and the
+ * prediction, at S, decoded through the component's replication adapter, so both at the wire's
+ * precision. The strategy carries the difference into the present: into the live component
+ * ({@link apply}), and into each prediction the client has made since S ({@link carry}), so the next
+ * comparison is against a history consistent with the correction.
+ *
+ * This base class carries nothing: it has no notion of what a difference between two states of an
+ * arbitrary component means. The host's value at S replaces the live component, and the predictions
+ * since S are left as they were. What the client predicted after S is lost with it — so for a
+ * component the client predicts from its own input, every prediction since comes up short of the
+ * host, and each comparison corrects it again: it does not settle. It is for components a client
+ * does not predict, and values with no difference to carry. A component whose differences mean
+ * something — a pose, a velocity, a count the client adds to — has a strategy that carries them.
+ *
+ * Strategies are stateless as far as the session is concerned, and shared: one instance serves every
+ * entity and every session.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Correction {
+    /**
+     * Whether `server` and `predicted`, the host's state and the prediction for the same frame,
+     * describe the same state. Asked only when their wire images differ: a strategy that tolerates
+     * a difference — the rounding an encoding cannot tell apart — says so here.
+     *
+     * @param {object} server
+     * @param {object} predicted
+     * @returns {boolean}
+     */
+    same(server, predicted) {
+        return false;
+    }
+
+    /**
+     * Carry the difference between `server` and `predicted` into `state`, in place: a prediction of
+     * the same entity for a frame after theirs.
+     *
+     * @param {object} state
+     * @param {object} server
+     * @param {object} predicted
+     */
+    carry(state, server, predicted) {
+    }
+
+    /**
+     * Carry the difference between `server` and `predicted` into the entity's live component, and
+     * into whatever the component's value runs through — the system that owns it, what is drawn.
+     * The session announces the write afterwards.
+     *
+     * @param {CorrectionTarget} target
+     * @param {object} server
+     * @param {object} predicted
+     * @returns {number} the size of the correction, in the strategy's own terms, for
+     *   {@link NetworkSession#onCorrection}; 0 when it has none
+     */
+    apply(target, server, predicted) {
+        target.write(server);
+        return 0;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Correction.prototype.isCorrection = true;
+
+/**
+ * The host's value replaces the live component; see {@link Correction}. For a component a client
+ * does not predict, or whose value has no difference to carry — a name, a state machine's state.
+ * @type {Correction}
+ */
+export const HOST_VALUE_CORRECTION = Object.freeze(new Correction());

package/src/engine/network/ecs/NetworkSystem.d.ts

@@ -8,14 +8,24 @@
  *   - When an entity loses its `NetworkIdentity` (or is destroyed), free the
  *     slot.
  *
- * **Not** responsible for the per-tick `begin_tick` / `end_tick` cadence —
- * the engine's `EntityManager` doesn't expose pre/post-simulate hooks, so the
- * application code wraps its `engine.simulate(dt)` call:
+ * It is also where the network meets the engine's loop. Given a `driver`, it
+ * passes on the phases of the loop a system takes part in:
+ *
+ *   - `open_step()` as every fixed step opens, before any system's `fixedUpdate`;
+ *   - `close_step()` as the step closes, after the last `fixedUpdate` — only
+ *     for a step whose `open_step` returned;
+ *   - `frame(dt)` once per rendered frame, with the frame's delta in seconds.
+ *
+ * A {@link NetworkSession} drives its peer this way: a network frame opens and
+ * closes with each fixed step, so everything the step simulates happens inside
+ * it. Code driving a bare `NetworkPeer` does the same:
  *
  * ```js
- *   peer.begin_tick(frame_number);
- *   engine.simulate(dt);
- *   peer.end_tick();
+ *   let frame_number = 0;
+ *   engine.entityManager.addSystem(new NetworkSystem(peer, {
+ *       open_step: () => peer.begin_tick(frame_number),
+ *       close_step: () => { peer.end_tick(); frame_number++; },
+ *   }));
  * ```
  *
  * Add this system to the engine once per `NetworkPeer` instance:
@@ -32,14 +42,33 @@
 export class NetworkSystem extends System<any> {
     /**
      * @param {NetworkPeer} peer
+     * @param {{
+     *   open_step?: () => void,
+     *   close_step?: () => void,
+     *   frame?: (dt: number) => void,
+     * }|null} [driver] runs the peer's network frames on the engine's clock; see the class notes
      */
-    constructor(peer: NetworkPeer);
+    constructor(peer: NetworkPeer, driver?: {
+        open_step?: () => void;
+        close_step?: () => void;
+        frame?: (dt: number) => void;
+    } | null);
     dependencies: (typeof NetworkIdentity)[];
     components_used: ResourceAccessSpecification<typeof NetworkIdentity>[];
     /**
      * @type {NetworkPeer}
      */
     peer: NetworkPeer;
+    /**
+     * @readonly
+     * @type {{open_step?: () => void, close_step?: () => void, frame?: (dt: number) => void}|null}
+     */
+    readonly driver: {
+        open_step?: () => void;
+        close_step?: () => void;
+        frame?: (dt: number) => void;
+    } | null;
+    update(dt: any): void;
     /**
      * @param {NetworkIdentity} identity
      * @param {number} entity

package/src/engine/network/ecs/NetworkSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/ecs/NetworkSystem.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAQI;;OAEG;IACH,+BAQC;IAjBD,yCAAiC;IAEjC,uEAEE;IASE;;OAEG;IACH,kBAAgB;IAGpB;;;OAGG;IACH,eAHW,eAAe,UACf,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHW,eAAe,UACf,MAAM,QAOhB;CACJ;uBAhFsB,qBAAqB;gCACZ,iCAAiC;4CAFrB,oDAAoD"}
+{"version":3,"file":"NetworkSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/ecs/NetworkSystem.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAQI;;;;;;;OAOG;IACH,wCANW;QACV,SAAa,CAAC,EAAE,MAAM,IAAI,CAAC;QAC3B,UAAc,CAAC,EAAE,MAAM,IAAI,CAAC;QAC5B,KAAS,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;KAC9B,GAAC,IAAI,EAgBR;IA5BD,yCAAiC;IAEjC,uEAEE;IAcE;;OAEG;IACH,kBAAgB;IAEhB;;;OAGG;IACH,iBAFU;QAAC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;KAAC,GAAC,IAAI,CAE1E;IAiBxB,sBAKC;IAED;;;OAGG;IACH,eAHW,eAAe,UACf,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHW,eAAe,UACf,MAAM,QAOhB;CACJ;uBA1HsB,qBAAqB;gCACZ,iCAAiC;4CAFrB,oDAAoD"}

package/src/engine/network/ecs/NetworkSystem.js

@@ -14,14 +14,24 @@ import { NetworkIdentity } from "./components/NetworkIdentity.js";
  *   - When an entity loses its `NetworkIdentity` (or is destroyed), free the
  *     slot.
  *
- * **Not** responsible for the per-tick `begin_tick` / `end_tick` cadence —
- * the engine's `EntityManager` doesn't expose pre/post-simulate hooks, so the
- * application code wraps its `engine.simulate(dt)` call:
+ * It is also where the network meets the engine's loop. Given a `driver`, it
+ * passes on the phases of the loop a system takes part in:
+ *
+ *   - `open_step()` as every fixed step opens, before any system's `fixedUpdate`;
+ *   - `close_step()` as the step closes, after the last `fixedUpdate` — only
+ *     for a step whose `open_step` returned;
+ *   - `frame(dt)` once per rendered frame, with the frame's delta in seconds.
+ *
+ * A {@link NetworkSession} drives its peer this way: a network frame opens and
+ * closes with each fixed step, so everything the step simulates happens inside
+ * it. Code driving a bare `NetworkPeer` does the same:
  *
  * ```js
- *   peer.begin_tick(frame_number);
- *   engine.simulate(dt);
- *   peer.end_tick();
+ *   let frame_number = 0;
+ *   engine.entityManager.addSystem(new NetworkSystem(peer, {
+ *       open_step: () => peer.begin_tick(frame_number),
+ *       close_step: () => { peer.end_tick(); frame_number++; },
+ *   }));
  * ```
  *
  * Add this system to the engine once per `NetworkPeer` instance:
@@ -45,8 +55,13 @@ export class NetworkSystem extends System {
 
     /**
      * @param {NetworkPeer} peer
+     * @param {{
+     *   open_step?: () => void,
+     *   close_step?: () => void,
+     *   frame?: (dt: number) => void,
+     * }|null} [driver] runs the peer's network frames on the engine's clock; see the class notes
      */
-    constructor(peer) {
+    constructor(peer, driver = null) {
         super();
         assert.ok(peer && peer.slot_table, 'NetworkSystem: peer must be a NetworkPeer instance with a slot_table');
 
@@ -54,6 +69,33 @@ export class NetworkSystem extends System {
          * @type {NetworkPeer}
          */
         this.peer = peer;
+
+        /**
+         * @readonly
+         * @type {{open_step?: () => void, close_step?: () => void, frame?: (dt: number) => void}|null}
+         */
+        this.driver = driver;
+    }
+
+    openFixedStep() {
+        const driver = this.driver;
+        if (driver !== null && driver.open_step !== undefined) {
+            driver.open_step();
+        }
+    }
+
+    closeFixedStep() {
+        const driver = this.driver;
+        if (driver !== null && driver.close_step !== undefined) {
+            driver.close_step();
+        }
+    }
+
+    update(dt) {
+        const driver = this.driver;
+        if (driver !== null && driver.frame !== undefined) {
+            driver.frame(dt);
+        }
     }
 
     /**

package/src/engine/network/orchestrator/NetworkPeer.d.ts

@@ -18,6 +18,7 @@ export namespace NetworkPacketType {
     let RESUME_ACCEPT: number;
     let RESUME_REJECT: number;
     let DISCONNECT: number;
+    let FRAME_MARKER: number;
 }
 /**
  * Reason codes for {@link NetworkPacketType.RESUME_REJECT }.
@@ -111,11 +112,12 @@ export class NetworkPeer {
      *   frame_capacity?: number,
      *   initial_buffer_size?: number,
      *   mutation_ledger?: MutationLedger|null,
+     *   mutation_ledger_retention_frames?: number,
      *   changed_set_capacity?: number,
      *   max_packets_per_tick?: number,
      * }} options
      */
-    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, mutation_ledger, changed_set_capacity, max_packets_per_tick, }: {
+    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, mutation_ledger, mutation_ledger_retention_frames, changed_set_capacity, max_packets_per_tick, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -126,6 +128,7 @@ export class NetworkPeer {
         frame_capacity?: number;
         initial_buffer_size?: number;
         mutation_ledger?: MutationLedger | null;
+        mutation_ledger_retention_frames?: number;
         changed_set_capacity?: number;
         max_packets_per_tick?: number;
     });
@@ -175,6 +178,17 @@ export class NetworkPeer {
      * @type {MutationLedger|null}
      */
     mutation_ledger: MutationLedger | null;
+    /**
+     * How many frames of mutation history to keep.
+     *
+     * Ten seconds at 60 Hz: far beyond any recovery request worth answering with a delta
+     * rather than a full re-init, and bounded - which the ledger was not, because nothing
+     * ever called `drop_through` and it grew one varint-list entry per mutating tick for the
+     * life of the session.
+     *
+     * @type {number}
+     */
+    mutation_ledger_retention_frames: number;
     /** @type {SimActionExecutor} */
     executor: SimActionExecutor;
     /** @type {Replicator} */
@@ -223,6 +237,11 @@ export class NetworkPeer {
      * @type {Signal}
      */
     onTimeDilationFeedback: Signal;
+    /**
+     * Fires on FRAME_MARKER packet arrival. Args: `(peer_id, frame_number)`.
+     * @type {Signal}
+     */
+    onFrameMarker: Signal;
     /**
      * Fires on INITIAL_SYNC packet arrival.
      * Args: `(peer_id, session_token, frame_number, buffer, payload_end)`.
@@ -332,6 +351,27 @@ export class NetworkPeer {
      * @returns {Channel|undefined}
      */
     channel_for(peer_id: number): Channel | undefined;
+    /**
+     * Send `peer_id` nothing on the action stream until {@link release_outbound}. What the log
+     * records meanwhile stays owed, and goes out on release unless the release starts past it.
+     * Nothing else is held: the `send_*` packets go out as ever.
+     *
+     * For a peer that has yet to say which world it holds. A client bound to its host afresh does
+     * not know whether the host will resume the world the client has been predicting on, or replace
+     * it with a snapshot; in the second case what it predicted on the old one is input for a world
+     * that is gone, and must never be applied.
+     *
+     * @param {number} peer_id
+     */
+    hold_outbound(peer_id: number): void;
+    /**
+     * Stop holding `peer_id`'s action stream. From the next {@link flush_outbound} it is sent what
+     * it is owed from `from_frame` on; frames before `from_frame` are never sent to it.
+     *
+     * @param {number} peer_id
+     * @param {number} [from_frame=0]
+     */
+    release_outbound(peer_id: number, from_frame?: number): void;
     /**
      * Open the action log for `frame_number`. Call before running game logic
      * for the tick. The user's code (or the engine's `EntityManager.simulate`)
@@ -469,6 +509,15 @@ export class NetworkPeer {
      * @param {number} buffer_depth signed integer; clamped to int16
      */
     send_time_dilation_feedback(peer_id: number, buffer_depth: number): void;
+    /**
+     * Tell a peer which frame this one has just finished simulating. See
+     * {@link NetworkPacketType.FRAME_MARKER}. Also serves as the tick's keep-alive: it advances the
+     * channel's seq/ack like any packet.
+     *
+     * @param {number} peer_id
+     * @param {number} frame_number
+     */
+    send_frame_marker(peer_id: number, frame_number: number): void;
     /**
      * Send a reliable command to a connected peer. Delivered at-least-once
      * with sender-side retransmit on Channel-detected loss and receiver-

package/src/engine/network/orchestrator/NetworkPeer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":";;;;;gCAgDU,MAAM;;;;;;;;;;;;;;;;;;;;iCA2II,MAAM;AAF1B;;;GAGG;AACH;;;;;IAKI;;;;;OAKG;;IAEH;;;;;;;;OAQG;;GAEJ;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAwDI;;;;;;;;;;;;;;OAcG;IACH,kOAdW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE;YAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;QACxF,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,cAAc,GAAC,IAAI,CAAC;QAC1C,gCAAoC,CAAC,EAAE,MAAM,CAAC;QAC9C,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EA0QH;IArPG,qCAAqC;IACrC,8BAAkB;IAElB,0CAA0C;IAC1C,oBADW,2BAA2B,CACoC;IAK1E,gCAAgC;IAChC,iBADW,iBAAiB,CACkB;IAK9C,mCAAmC;IACnC,YADW,oBAAoB,CACa;IAE5C,wBAAwB;IACxB,YADW,SAAS,CACoD;IAExE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,sBAFU,MAAM,CAEgC;IAEhD;;;;;;;;OAQG;IACH,iBAFU,cAAc,GAAC,IAAI,CAES;IAEtC;;;;;;;;;OASG;IACH,kCAFU,MAAM,CAEwD;IAaxE,gCAAgC;IAChC,UADW,iBAAiB,CAQ1B;IAEF,yBAAyB;IACzB,YADW,UAAU,CAOnB;IAEF,uBAAuB;IACvB,UADW,QAAQ,CACW;IAgC9B;;;;;;OAMG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;OAMG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;;;;OAQG;IACH,aAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,wBAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;;;OAMG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,oBAFU,MAAM,CAEsB;IAEtC;;;;;;;;;;;;;OAaG;IACH,mBAFU,MAAM,CAEqB;IAGzC;;;;;;;OAOG;IACH,sBAHW,MAAM,aACN;QAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,SAAS,EAAE,GAAG,CAAA;KAAE,QAyT3E;IAED;;;OAGG;IACH,yBAFW,MAAM,QAgChB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,6BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;OASG;IACH,2BAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,OAAO,GAAC,SAAS,CAK7B;IAED;;;;;;;;;;;OAWG;IACH,uBAFW,MAAM,QAQhB;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,eACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,yBAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,iBAQC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,8BAFW,MAAM,QA0LhB;IAkGD;;;;;;;;;;;;OAYG;IACH,+BAJW,MAAM,cACN,MAAM,YACN,MAAM,QAchB;IAED;;;;;;;;;;;;;OAaG;IACH,oCAJW,MAAM,cACN,MAAM,YACN,MAAM,QA8ChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBALW,MAAM,gBACN,MAAM,cACN,MAAM,mBACG,YAAY,KAAG,IAAI,QAgBtC;IAED;;;;;;;;;OASG;IACH,2BALW,MAAM,iBACN,UAAU,gBACV,MAAM,mBACG,YAAY,KAAG,IAAI,QAiBtC;IAED;;;;;;;;;;OAUG;IACH,2BARW,MAAM,iBACN,MAAM,oBACN,MAAM,aACN,OAAO,iBAGP,UAAU,QAmBpB;IAED;;;OAGG;IACH,4BAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,eACN,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,yBAHW,MAAM,iBACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,qCAHW,MAAM,gBACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,gBACN,MAAM,QAYhB;IAED;;;;;;;;;;;;;;OAcG;IACH,+BALW,MAAM,WACN,UAAU,UACV,MAAM,GACJ,MAAM,CAUlB;;CACJ;;;;;;;;;;;;;;;;;yBAr7CY;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC;4CA7N7D,uCAAuC;kCAEjD,6BAA6B;qCAK1B,kCAAkC;0BAR7C,qBAAqB;+BAOhB,4BAA4B;kCALZ,6BAA6B;2BAJjD,8BAA8B;yBAOhC,sBAAsB;mBAV5B,uCAAuC;wBAclC,yBAAyB;6BAfpB,sCAAsC"}