@woosh/meep-engine 3.14.3 → 3.14.5

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

@@ -45,6 +45,7 @@ export class ServerAuthoritativeClient {
      *   input_byte_size?: number,
      *   reconcile_epsilon?: number,
      *   time_dilation?: TimeDilation,
+     *   max_packets_per_tick?: number,
      * }} options
      *
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
@@ -52,8 +53,11 @@ export class ServerAuthoritativeClient {
      * {@link dilation_factor} for the caller to scale its tick cadence.
      * Defaults to a stock instance; `dilation_factor` is 1.0 until the
      * first feedback arrives.
+     *
+     * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
+     * action-stream packets a tick may send the server.
      */
-    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, input_ring_capacity, input_byte_size, reconcile_epsilon, time_dilation, }: {
+    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, input_ring_capacity, input_byte_size, reconcile_epsilon, time_dilation, max_packets_per_tick, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -65,6 +69,7 @@ export class ServerAuthoritativeClient {
         input_byte_size?: number;
         reconcile_epsilon?: number;
         time_dilation?: TimeDilation;
+        max_packets_per_tick?: number;
     });
     /** @type {number} */
     reconcile_count: number;

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

@@ -1 +1 @@
-{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAsBI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2MApBW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,aAAiB,CAAC,EAAE,YAAY,CAAC;KAC9B,EAwLH;IA3MD,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAoCnB,0BAA0B;IAC1B,MADW,WAAW,CASpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAClC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAEhD;;;;OAIG;IACH,YAFU,SAAS,CAKjB;IAEF,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;OAKG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;;OAKG;IACH,eAFU,YAAY,CAEY;IAElC;;;;OAIG;IACH,mBAFU,MAAM,CAEW;IAE3B;;;;;;;;OAQG;IACH,iBAFU,MAAM,CAEU;IAO1B;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;;;OASG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAQ3C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;OAUG;IACH,oBAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,gBAKhB;IAiFD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BAva2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBAJnC,uCAAuC"}
+{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAsBI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iOAxBW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,aAAiB,CAAC,EAAE,YAAY,CAAC;QACjC,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EA6LH;IAjND,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAyCnB,0BAA0B;IAC1B,MADW,WAAW,CAUpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAClC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAEhD;;;;OAIG;IACH,YAFU,SAAS,CAKjB;IAEF,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;OAKG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;;OAKG;IACH,eAFU,YAAY,CAEY;IAElC;;;;OAIG;IACH,mBAFU,MAAM,CAEW;IAE3B;;;;;;;;OAQG;IACH,iBAFU,MAAM,CAEU;IAO1B;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;;;OASG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAQ3C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;OAUG;IACH,oBAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,gBAKhB;IAiFD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BA7a2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBAJnC,uCAAuC"}

package/src/engine/network/orchestrator/ServerAuthoritativeClient.js

@@ -75,6 +75,7 @@ export class ServerAuthoritativeClient {
      *   input_byte_size?: number,
      *   reconcile_epsilon?: number,
      *   time_dilation?: TimeDilation,
+     *   max_packets_per_tick?: number,
      * }} options
      *
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
@@ -82,6 +83,9 @@ export class ServerAuthoritativeClient {
      * {@link dilation_factor} for the caller to scale its tick cadence.
      * Defaults to a stock instance; `dilation_factor` is 1.0 until the
      * first feedback arrives.
+     *
+     * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
+     * action-stream packets a tick may send the server.
      */
     constructor({
         world,
@@ -95,6 +99,7 @@ export class ServerAuthoritativeClient {
         input_byte_size = 4,
         reconcile_epsilon = 1e-4,
         time_dilation = new TimeDilation(),
+        max_packets_per_tick,
     }) {
         /** @type {NetworkPeer} */
         this.peer = new NetworkPeer({
@@ -105,6 +110,7 @@ export class ServerAuthoritativeClient {
             scope_filter,
             frame_capacity,
             initial_buffer_size,
+            max_packets_per_tick,
         });
 
         /** @type {EntityComponentDataset} */

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

@@ -6,23 +6,48 @@
  *
  *   1. Inbound action packets do NOT execute on arrival. Instead, a deferral
  *      hook on the {@link Replicator} drops them into a per-tick pending log
- *      tagged with `(client_frame, sender_id, type_id, payload_bytes)`.
+ *      tagged with `(client_frame, sender_id, type_id, payload_bytes)` —
+ *      unless the action log already holds that record. The action stream
+ *      re-sends every unconfirmed frame each tick, so most arrivals at any
+ *      real latency are copies of applied records; those are dropped where
+ *      they arrive, and pending holds only input the log does not.
  *   2. Once per server tick, `tick(current_frame)` consumes the pending log:
  *      - Rejects entries older than the action_log's rewindable window.
- *      - Determines the oldest pending frame `replay_start`.
+ *      - Determines `replay_start`: the oldest pending frame, which by the
+ *        above is the oldest frame whose outcome can change.
  *      - Rewinds the server world back to end-of-(replay_start - 1) via the
  *        action_log's prior-state captures (see {@link RewindEngine}).
  *      - Replays forward `[replay_start, current_frame]`. For each frame `f`:
  *        - Read historical actions out of `action_log[f]` BEFORE
  *          `begin_frame(f)` recycles the buffer.
  *        - Append pending entries for `f`.
+ *        - Append anything queued by {@link enqueue_action}.
  *        - Stable-sort the merged list by `sender_id` (so multi-client order
  *          is deterministic across peers — relies on per-record sender_id in
- *          the action log).
- *        - `executor.execute` each in sorted order, then run the user-
- *          supplied local sim via {@link onLocalSim}.
+ *          the action log), and `executor.execute` each in that order.
+ *        - Run the user-supplied local sim via {@link onLocalSim}.
  *      - Clear pending.
  *
+ * A frame's records have one of two provenances, and the replay treats them
+ * differently:
+ *
+ *   - **Input** — actions that arrived from a peer, and actions the server
+ *     authored via {@link enqueue_action}. Each happened once, at a point in
+ *     time nothing can recompute, so a replay reapplies it from the log.
+ *   - **Derived output** — everything {@link onLocalSim} executes. The handler
+ *     runs again on every replay of the frame, against a world that now
+ *     includes whatever late input forced the replay, so the replay recomputes
+ *     it. Reapplying the previous pass's copy as well would apply the effect
+ *     twice — and three times on the next replay, and so on, without bound.
+ *     The executor stamps these {@link SENDER_DERIVED} while the handler runs
+ *     and {@link __read_historical} drops them.
+ *
+ * Derived records are still written, and still replicate: the prior-state
+ * capture is what lets a rewind undo the local sim's effect on replicated
+ * components (so derived output need not be idempotent — only deterministic
+ * in the frame's post-input state), and the action stream carries them to
+ * clients like any other record.
+ *
  * Net effect: a client action tagged at client tick K lands on the server as
  * if applied against end-of-K-1 server state, regardless of arrival timing
  * or order. Both peers compute identical world states for identical inputs.
@@ -51,8 +76,12 @@ export class ServerAuthoritativeServer {
      *   frame_capacity?: number,
      *   initial_buffer_size?: number,
      *   simulation_delay_ticks?: number,
+     *   max_packets_per_tick?: number,
      * }} options
      *
+     * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
+     * action-stream packets a tick may send one peer.
+     *
      * `simulation_delay_ticks`: server-side input buffer (Overwatch-style).
      * When > 0, {@link tick}(wall_frame) simulates
      * `sim_frame = wall_frame - simulation_delay_ticks`. Pending actions
@@ -62,7 +91,7 @@ export class ServerAuthoritativeServer {
      * input-to-feedback latency (client prediction hides it). Default 0
      * reproduces pre-feature behavior.
      */
-    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, simulation_delay_ticks, max_pending_future_lead, max_pending_total, identity_class, server_peer_id, }: {
+    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, simulation_delay_ticks, max_pending_future_lead, max_pending_total, identity_class, server_peer_id, max_packets_per_tick, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -71,6 +100,7 @@ export class ServerAuthoritativeServer {
         frame_capacity?: number;
         initial_buffer_size?: number;
         simulation_delay_ticks?: number;
+        max_packets_per_tick?: number;
     });
     /**
      * Most recently simulated frame. `-1` during warmup
@@ -109,6 +139,15 @@ export class ServerAuthoritativeServer {
      * @type {number}
      */
     simulation_delay_ticks: number;
+    /**
+     * Peer id of this authoritative server, or `-1` when the session has no
+     * privileged peer. Actions from {@link enqueue_action} are tagged with
+     * it so they pass the owner-authorization gate on any entity (see
+     * {@link make_owner_authorization}), which is the documented convention
+     * for the server's own mutations.
+     * @type {number}
+     */
+    server_peer_id: number;
     /**
      * Upper bound on how far ahead of the server's own simulation a peer
      * may tag an inbound action. `frame_number` is an attacker-controlled
@@ -132,13 +171,35 @@ export class ServerAuthoritativeServer {
      */
     max_pending_total: number;
     /**
-     * Fires once per frame during the replay loop, AFTER all merged
-     * actions for that frame have been applied and BEFORE the action_log
-     * frame is closed. Use this for server-authoritative local sim
-     * (clamps, collision, AI step, etc.). The current world state
-     * reflects all inputs for this frame; the local sim should be
-     * idempotent under repeated application (because it may run many
-     * times under rollback).
+     * Fires once per execution of a frame, AFTER all input for that frame
+     * has been applied and BEFORE the action_log frame is closed. Use it
+     * for server-authoritative local sim: clamps, collision, AI step,
+     * damage resolution, spawning the effects a hit produces.
+     *
+     * **This is a derivation, not an event.** The handler runs again on
+     * every replay of the frame, and must produce the same result for the
+     * same post-input world state — it is a function OF that state, not a
+     * one-shot that happens to be called from it. Concretely:
+     *
+     *   - Decide from world state and the frame number. Both are restored
+     *     before the handler re-runs.
+     *   - Do NOT latch on handler-local flags (`if (already_fired) return`)
+     *     to make something happen once. The replay needs the handler to
+     *     re-emit; a latch makes it emit nothing, and the action is lost
+     *     the first time a rollback crosses its frame. For a genuine
+     *     one-shot — a lobby spawn, an admin command, anything decided
+     *     outside the simulation — use {@link enqueue_action}, which is
+     *     recorded as input and replayed rather than recomputed.
+     *
+     * Actions the handler executes are recorded as derived output: they
+     * replicate to clients and their prior state is captured so a rewind
+     * undoes them, but a replay recomputes them instead of reapplying the
+     * previous pass's copy. So they need not be idempotent — a handler may
+     * subtract hit points — only deterministic in the frame's post-input
+     * state. Components the handler mutates DIRECTLY, without going through
+     * an action, have no prior-state capture and are not undone by a
+     * rewind; those must additionally be idempotent, which is why a clamp
+     * is safe to write that way and `hp -= 10` is not.
      *
      * Args: `(frame_number)`.
      * @type {Signal}
@@ -215,6 +276,37 @@ export class ServerAuthoritativeServer {
      * @param {number} peer_id
      */
     send_time_dilation_feedback(peer_id: number): void;
+    /**
+     * Author a server-side action, to be applied on the next simulated frame.
+     *
+     * This is the supported path for a mutation the simulation cannot
+     * recompute — a spawn triggered by a lobby event, an admin command, a
+     * scripted trigger — as opposed to {@link onLocalSim}, which derives a
+     * frame's output from its state and is re-run on every replay.
+     *
+     * The action is serialized immediately (so the caller may reuse or discard
+     * the instance) and applied exactly once, on the next frame {@link tick}
+     * simulates for the first time, merged into that frame's input and ordered
+     * with it by sender. From then on it is ordinary history: replayed from the
+     * log like any other input, and never re-queued.
+     *
+     * Callable at any time EXCEPT from inside {@link onLocalSim}, which throws:
+     * that handler re-runs on every replay of its frame, so it would queue a
+     * fresh copy each time. (`executor.execute` is the opposite — it requires
+     * an open action_log frame, so it only works from inside the handler.)
+     *
+     * Recorded with {@link server_peer_id} as the sender when the session has
+     * one, so it passes the owner-authorization gate on any entity; with
+     * {@link SENDER_LOCAL} otherwise, which bypasses the gate.
+     *
+     * @param {SimAction} action
+     */
+    enqueue_action(action: SimAction): void;
+    /**
+     * Number of locally-authored actions waiting for the next simulated frame.
+     * @returns {number}
+     */
+    queued_local_action_count(): number;
     /**
      * Drive the rollback flow for one tick.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"ServerAuthoritativeServer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeServer.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA6BI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uOApBW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,sBAA0B,CAAC,EAAE,MAAM,CAAC;KACjC,EAyLH;IA3MD;;;;;OAKG;IACH,mBAFU,MAAM,CAEO;IAwCnB,0BAA0B;IAC1B,MADW,WAAW,CASpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAclC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAChD,0CAA0C;IAC1C,gDAAsD;IAEtD,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;;OAMG;IACH,6BAFU,MAAM,CAEqB;IAErC;;;;OAIG;IACH,wBAFU,MAAM,CAEoC;IAEpD;;;;;;;;;OASG;IACH,yBAFU,MAAM,CAEsC;IAEtD;;;;;;;;;OASG;IACH,mBAFU,MAAM,CAE0B;IA4B1C;;;;;;;;;;;OAWG;IACH,YAFU,MAAM,CAEc;IAE9B;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;;;;;;;OAWG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,wBAFU,MAAM,CAE0B;IAG9C;;;;;;;OAOG;IACH,sBAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,yBALW,MAAM,gBACN,MAAM,cACN,MAAM,kBACA,YAAY,KAAK,IAAI,QAIrC;IAED;;;;OAIG;IACH,qBAFW,MAAM,6CAIhB;IAED;;;;;;;;OAQG;IACH,qCAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;OAYG;IACH,oBAFW,MAAM,QA2ChB;IAED;;;;;;;;OAQG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IA2GD;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CA0HJ;4BAvnB2B,kBAAkB;6BADjB,wBAAwB;mBANlC,uCAAuC;6BAH7B,sCAAsC"}
+{"version":3,"file":"ServerAuthoritativeServer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeServer.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH;IAsCI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,6PAxBW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,sBAA0B,CAAC,EAAE,MAAM,CAAC;QACpC,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EAiOH;IApPD;;;;;OAKG;IACH,mBAFU,MAAM,CAEO;IA6CnB,0BAA0B;IAC1B,MADW,WAAW,CAUpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAclC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAChD,0CAA0C;IAC1C,gDAAsD;IAEtD,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;;OAMG;IACH,6BAFU,MAAM,CAEqB;IAErC;;;;OAIG;IACH,wBAFU,MAAM,CAEoC;IAEpD;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEoB;IAEpC;;;;;;;;;OASG;IACH,yBAFU,MAAM,CAEsC;IAEtD;;;;;;;;;OASG;IACH,mBAFU,MAAM,CAE0B;IA+B1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,YAFU,MAAM,CAEc;IAE9B;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;;;;;;;OAWG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,wBAFU,MAAM,CAE0B;IAG9C;;;;;;;OAOG;IACH,sBAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,yBALW,MAAM,gBACN,MAAM,cACN,MAAM,kBACA,YAAY,KAAK,IAAI,QAIrC;IAED;;;;OAIG;IACH,qBAFW,MAAM,6CAIhB;IAED;;;;;;;;OAQG;IACH,qCAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,wCA8BC;IAED;;;OAGG;IACH,6BAFa,MAAM,CAIlB;IAED;;;;;;;;;;;;OAYG;IACH,oBAFW,MAAM,QAkDhB;IAED;;;;;;;;OAQG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAyLD;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CA8IJ;4BA52B2B,kBAAkB;6BAFjB,wBAAwB;mBAPlC,uCAAuC;6BAH7B,sCAAsC"}