@woosh/meep-engine 3.46.0 → 3.47.0

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

@@ -9,9 +9,7 @@ export namespace NetworkPacketType {
     let RECOVERY_REQUEST: number;
     let STATE_BURST: number;
     let AUTH_STATE: number;
-    let FRAGMENT: number;
     let RELIABLE_COMMAND: number;
-    let NACK_FRAGMENT: number;
     let TIME_DILATION: number;
     let INITIAL_SYNC: number;
     let RESUME_HELLO: number;
@@ -20,6 +18,21 @@ export namespace NetworkPacketType {
     let DISCONNECT: number;
     let FRAME_MARKER: number;
 }
+/**
+ * Flags of an INITIAL_SYNC page.
+ */
+export type InitialSyncPage = number;
+/**
+ * Flags of an INITIAL_SYNC page.
+ * @readonly
+ * @enum {number}
+ */
+export const InitialSyncPage: Readonly<{
+    /** The first page of a join: it issues the session token, and replaces the receiver's world. */
+    FIRST: 1;
+    /** The last page: every entity's state at its frame is now with the receiver. */
+    FINAL: 2;
+}>;
 /**
  * Reason codes for {@link NetworkPacketType.RESUME_REJECT }.
  */
@@ -51,39 +64,20 @@ export const ResumeRejectReason: Readonly<{
      */
     NoSessionToken: 5;
 }>;
-/**
- * One outbound action-stream send, awaiting confirmation.
- *
- * A send occupies one transport seq when it fits the MTU and N consecutive
- * seqs when it has to be fragmented. All of those seqs map to the SAME record:
- * the receiver reassembles a fragmented message all-or-nothing, so the frame
- * range is confirmed only when `unacked` reaches zero without `abandoned`
- * having been set by a loss along the way.
- *
- * A tick may make several sends to one peer, each carrying the next slice of
- * the owed range (see {@link NetworkPeer#flush_outbound}). They confirm
- * independently, and the baseline advances only through slices confirmed in
- * order — a later slice landing says nothing about an earlier one still in
- * flight. `head` marks the first slice of a tick, whose start is the pack
- * start itself; see {@link NetworkPeer#__credit_confirmed}.
- *
- * @typedef {{frame_start: number, frame_end: number, head: boolean, unacked: number, abandoned: boolean}} PendingAck
- * @property {number} frame_start first frame in the packed range
- * @property {number} frame_end   last frame in the packed range
- * @property {boolean} head       this send began at the pack start, so nothing
- *   sendable lies before it and its confirmation credits outright
- * @property {number} unacked     seqs of this send not yet acked or declared lost
- * @property {boolean} abandoned  at least one seq was declared lost, so the
- *   message is forfeit and must never advance the baseline
- */
 /**
  * Per-tick orchestrator that wires the action infrastructure to one or more
  * peers over a Transport.
  *
  * Holds a single world (`EntityComponentDataset`) plus the action machinery
  * (executor, replicator, action log). For each connected peer it owns a
- * `Channel` and a `seq` → {@link PendingAck} map so that ack notifications
- * advance the `Baseline.last_acked(peer_id)` watermark.
+ * {@link Connection} and the action-stream slices sent on it and not yet
+ * resolved ({@link PendingSlices}), so that their acknowledgements advance the
+ * `Baseline.last_acked(peer_id)` watermark.
+ *
+ * Every `send_*` queues; nothing reaches a transport until {@link send_queued}
+ * (or {@link flush_peer}), which {@link end_tick} calls last. One tick's
+ * traffic to a peer thereby leaves together, packed into as few datagrams as
+ * fit.
  *
  * Use as both server (many connected peers) and client (one peer = the server).
  * The asymmetry is in *who* connects — the orchestrator itself is symmetric.
@@ -94,9 +88,9 @@ export const ResumeRejectReason: Readonly<{
  *      - `begin_tick(frame_number)` — open the action log for this frame.
  *      - User code runs game logic, calling `executor.execute(action)` for each
  *        replicated state mutation. Inbound actions from peers also flow into
- *        the executor automatically (via the channel.onPayload wiring).
+ *        the executor automatically (via the connection's onMessage wiring).
  *      - `end_tick()` — close the frame and dispatch outgoing packets to every peer.
- *   3. `disconnect_peer(peer_id)` — release the channel + baseline state.
+ *   3. `disconnect_peer(peer_id)` — release the connection + baseline state.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -115,9 +109,20 @@ export class NetworkPeer {
      *   mutation_ledger_retention_frames?: number,
      *   changed_set_capacity?: number,
      *   max_packets_per_tick?: number,
+     *   clock: function(): number,
+     *   tick_period_ms: number,
+     *   send_rate_bytes_per_second?: number,
+     *   max_message_bytes?: number,
+     *   receive_window_bytes?: number,
+     *   max_queued_bytes?: number,
      * }} options
+     *   `clock` returns milliseconds and never runs backwards: every network timer (loss, probe,
+     *   pacing) runs on it, and nothing in the stack reads a clock of its own. `tick_period_ms` is
+     *   how often this peer sends: the longest it sits on an acknowledgement, and the resolution
+     *   of its timers. The remaining four configure every {@link Connection}; see there.
+     *   `max_message_bytes` and `receive_window_bytes` must be the same on both ends.
      */
-    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, }: {
+    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, clock, tick_period_ms, send_rate_bytes_per_second, max_message_bytes, receive_window_bytes, max_queued_bytes, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -131,6 +136,12 @@ export class NetworkPeer {
         mutation_ledger_retention_frames?: number;
         changed_set_capacity?: number;
         max_packets_per_tick?: number;
+        clock: () => number;
+        tick_period_ms: number;
+        send_rate_bytes_per_second?: number;
+        max_message_bytes?: number;
+        receive_window_bytes?: number;
+        max_queued_bytes?: number;
     });
     /** @type {EntityComponentDataset} */
     world: EntityComponentDataset;
@@ -153,17 +164,9 @@ export class NetworkPeer {
      * fit one packet; past that the owed range grows until it meets the
      * ring floor and frames are lost.
      *
-     * It is also the bandwidth ceiling under catch-up — this many MTUs per
-     * tick per peer — and it has to stay inside the channel's ack window.
-     * A peer's ack header covers its latest 33 seqs, so with a peer that
-     * replies once a tick, `33 / max_packets_per_tick` consecutive lost
-     * replies leave a delivered packet outside the window and it is
-     * declared lost: a wasted re-send rather than a defect, since the
-     * receiver skips frames it has already applied. Eight tolerates three
-     * such losses in a row (one tick in sixteen at 50% loss, one in ten
-     * thousand at 10%), and lets a 60 Hz stream at 100 ms RTT carry a full
-     * packet of actions per frame. Lower it for peers that reply less often
-     * than every tick.
+     * It is also the bandwidth ceiling under catch-up — this many datagrams
+     * of actions per tick per peer. Eight lets a 60 Hz stream at 100 ms RTT
+     * carry a full datagram of actions per frame.
      *
      * @type {number}
      */
@@ -203,6 +206,24 @@ export class NetworkPeer {
      * @type {Signal}
      */
     onMalformedPacket: Signal;
+    /**
+     * The connection to a peer is no longer whole: `(peer_id, reason)`. Its connection said so
+     * (Connection.onProtocolError: a reliable lane broke its limits and stopped, or the peer
+     * acknowledged a packet never sent), or more of the peer's action stream arrived during
+     * {@link hold_inbound} than may be held. Nothing more can be trusted to arrive whole on it:
+     * give the connection up.
+     * @type {Signal}
+     */
+    onProtocolError: Signal;
+    /**
+     * An action-stream frame larger than any message the connection may carry
+     * (`max_message_bytes`) was given up rather than sent: `(peer_id, frame_start, frame_end,
+     * bytes)`. It can never be delivered, so it is stepped over — the peer never applies it —
+     * and the stream goes on behind it. Raise `max_message_bytes` on both ends for frames that
+     * large.
+     * @type {Signal}
+     */
+    onFrameTooLarge: Signal;
     /**
      * Fired when an inbound packet is a `RECOVERY_REQUEST` (peer is asking
      * which entities mutated in a tick range so it can request their state).
@@ -233,7 +254,8 @@ export class NetworkPeer {
     onAuthState: Signal;
     /**
      * Fires on TIME_DILATION packet arrival.
-     * Args: `(peer_id, buffer_depth)` — signed int16.
+     * Args: `(peer_id, buffer_depth, frame_number)` — signed int16, and the sender's sim frame
+     * as it sent it: the freshest word of where the host is, every tick.
      * @type {Signal}
      */
     onTimeDilationFeedback: Signal;
@@ -243,10 +265,11 @@ export class NetworkPeer {
      */
     onFrameMarker: Signal;
     /**
-     * Fires on INITIAL_SYNC packet arrival.
-     * Args: `(peer_id, session_token, frame_number, buffer, payload_end)`.
-     * `session_token` is a `Uint8Array(16)` (UUID v1 raw bytes); the
-     * buffer is positioned at the start of the Snapshotter payload.
+     * Fires on each INITIAL_SYNC page.
+     * Args: `(peer_id, session_token, frame_number, flags, buffer, payload_end)`.
+     * `session_token` is a `Uint8Array(16)` (UUID v1 raw bytes); `flags`
+     * is {@link InitialSyncPage}; the buffer is positioned at the page's
+     * uint32 entity count.
      * @type {Signal}
      */
     onInitialSync: Signal;
@@ -282,7 +305,7 @@ export class NetworkPeer {
     onDisconnectPacket: Signal;
     /**
      * Fired when a reliable command arrives from a peer (delivered via
-     * {@link ReliableCommandPipeline}, dedup'd against retransmits).
+     * the connection's USER lane, once and in order).
      *
      * Args: `(peer_id, buffer, payload_offset, payload_length)`. The
      * buffer is the per-peer scratch and may be reused after the handler
@@ -296,7 +319,7 @@ export class NetworkPeer {
      */
     onReliableCommand: Signal;
     /**
-     * Wire `transport` to the peer identified by `peer_id`. Creates a Channel
+     * Wire `transport` to the peer identified by `peer_id`. Creates a Connection
      * over the transport and connects ack/payload notifications to the local
      * Baseline / Replicator.
      *
@@ -308,7 +331,8 @@ export class NetworkPeer {
         onReceive: any;
     }): void;
     /**
-     * Unwire and forget a peer.
+     * Unwire and forget a peer. Sends nothing: the transport may already be gone. To say a last
+     * word first — a DISCONNECT — queue it and call {@link flush_peer}.
      * @param {number} peer_id
      */
     disconnect_peer(peer_id: number): void;
@@ -335,22 +359,21 @@ export class NetworkPeer {
      */
     inbound_count(peer_id: number): number;
     /**
-     * Number of outbound action-stream seqs for `peer_id` still awaiting an
+     * Number of action-stream slices sent to `peer_id` still awaiting an
      * ack-or-lost verdict. Returns 0 for an unknown peer.
      *
-     * Diagnostics: this is bounded by the channel's in-flight window and must
-     * fall back to 0 once a stream of acks has resolved everything sent. A
-     * value that only grows is a leak in the ack accounting.
+     * Diagnostics: this must fall back to 0 once a stream of acks has resolved
+     * everything sent. A value that only grows is a leak in the ack accounting.
      * @param {number} peer_id
      * @returns {number}
      */
     pending_ack_count(peer_id: number): number;
     /**
-     * Direct access to a peer's channel (for sending acks-only packets, raw payloads, etc.).
+     * A peer's connection, for diagnostics: round-trip time, statistics, what is in flight.
      * @param {number} peer_id
-     * @returns {Channel|undefined}
+     * @returns {Connection|undefined}
      */
-    channel_for(peer_id: number): Channel | undefined;
+    connection_for(peer_id: number): Connection | 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.
@@ -372,6 +395,28 @@ export class NetworkPeer {
      * @param {number} [from_frame=0]
      */
     release_outbound(peer_id: number, from_frame?: number): void;
+    /**
+     * Keep the action stream and AUTH_STATE that `peer_id` sends, unapplied, until
+     * {@link release_inbound}; everything else it sends is handled as ever.
+     *
+     * For a client being given a world in pages. The host releases its action stream from the frame
+     * after the last page, so the stream's datagrams can overtake the last pages on the way; what
+     * they carry is about entities the client may not hold yet. Held, they are applied after the
+     * world is complete, in the order they came.
+     *
+     * Held messages are copies, bounded by `max_queued_bytes`; past that the connection can no
+     * longer give the peer a whole stream, and says so on {@link onProtocolError}.
+     *
+     * @param {number} peer_id
+     */
+    hold_inbound(peer_id: number): void;
+    /**
+     * Stop holding `peer_id`'s action stream and AUTH_STATE, and handle what was held, in the order
+     * it arrived.
+     *
+     * @param {number} peer_id
+     */
+    release_inbound(peer_id: 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`)
@@ -382,15 +427,29 @@ export class NetworkPeer {
      */
     begin_tick(frame_number: number): void;
     /**
-     * Close the current tick and send pending action records to every peer.
-     * For each peer, packs frames `[Baseline.last_acked(peer) + 1, current_frame]`
-     * and sends via the channel; records the seqs the send went out under so
-     * that acks for all of them advance the baseline.
-     *
-     * If a {@link MutationLedger} was supplied at construction, this tick's
-     * accumulated changed-entity set is also compacted into the ledger.
+     * Close the current tick, queue the action stream for every peer (see
+     * {@link flush_outbound}), and send everything queued ({@link send_queued}).
      */
     end_tick(): void;
+    /**
+     * Send what is queued for every peer: one flush of each connection, packing the tick's
+     * messages into as few datagrams as fit, and running its loss and probe timers. Also sends a
+     * bare acknowledgement to a peer that has sent something since the last one.
+     */
+    send_queued(): void;
+    /**
+     * Send what is queued for one peer now. For a last word before {@link disconnect_peer}:
+     * queue the DISCONNECT, flush, then disconnect.
+     * @param {number} peer_id
+     */
+    flush_peer(peer_id: number): void;
+    /**
+     * The frame `network_id` was last changed by an action this peer executed or applied, or -1.
+     * Stamped at the end of each tick, by {@link flush_outbound}.
+     * @param {number} network_id
+     * @returns {number}
+     */
+    last_changed_frame(network_id: number): number;
     /**
      * Pack and dispatch the outbound action stream for `current_frame` to
      * every connected peer. Second half of {@link end_tick} — exposed
@@ -404,9 +463,12 @@ export class NetworkPeer {
      * MutationLedger (if configured), then packs frames
      * `[last_acked+1, current_frame]` for each peer via
      * `Replicator.pack_for_peer` into up to {@link max_packets_per_tick}
-     * channel packets, each the next slice of that range. Empty packs (no
-     * in-scope actions) are not sent. Clears the per-tick changed-entity set
-     * after recording.
+     * slices, each the next part of that range and one datagram at most; a
+     * frame too large for a datagram goes on {@link Lane.FRAMES}. Empty packs
+     * (no in-scope actions) are not sent. Stamps and clears the per-tick
+     * changed-entity set.
+     *
+     * Only queues: {@link send_queued} sends.
      *
      * @param {number} current_frame
      */
@@ -417,8 +479,7 @@ export class NetworkPeer {
      * server-side handler ({@link onRecoveryRequest}) is expected to respond by
      * calling {@link send_state_burst_for_range}.
      *
-     * Best-effort delivery via the same UDP-style channel — if the request is
-     * lost, the client is expected to retry.
+     * Reliable, on the CONTROL lane.
      *
      * @param {number} peer_id
      * @param {number} start_tick
@@ -439,7 +500,7 @@ export class NetworkPeer {
      * @param {number} start_tick
      * @param {number} end_tick
      */
-    send_state_burst_for_range(peer_id: number, start_tick: number, end_tick: number): void;
+    send_state_burst_for_range(peer_id: number, start_tick: number, end_tick: number): any;
     /**
      * Send the authoritative state of one entity to `peer_id`, tagged with
      * the frame the state represents. Used by client-side prediction: the
@@ -459,16 +520,18 @@ export class NetworkPeer {
      */
     send_auth_state(peer_id: number, frame_number: number, network_id: number, write_fn: (arg0: BinaryBuffer) => void): void;
     /**
-     * Send an INITIAL_SYNC packet. `write_fn` receives the send-buffer
-     * positioned just past the `(packet_type, session_token, frame_number)`
-     * header and writes the Snapshotter payload. Fragments transparently.
+     * Queue one INITIAL_SYNC page on the BULK lane: the header, then `length` bytes of
+     * `entities` — a uint32 entity count and that many Snapshotter entity records.
      *
      * @param {number} peer_id
      * @param {Uint8Array} session_token 16-byte UUID v1 identifying this peer-session
-     * @param {number} frame_number server sim frame this snapshot represents
-     * @param {function(BinaryBuffer): void} write_fn
+     * @param {number} frame_number server sim frame the page's state is from
+     * @param {number} flags {@link InitialSyncPage}
+     * @param {Uint8Array} entities
+     * @param {number} length
+     * @returns {number} delivery mark on {@link Lane.BULK}
      */
-    send_initial_sync(peer_id: number, session_token: Uint8Array, frame_number: number, write_fn: (arg0: BinaryBuffer) => void): void;
+    send_sync_page(peer_id: number, session_token: Uint8Array, frame_number: number, flags: number, entities: Uint8Array, length: number): number;
     /**
      * Send a RESUME_HELLO packet to the server. Client-only direction.
      *
@@ -507,58 +570,34 @@ export class NetworkPeer {
      *
      * @param {number} peer_id
      * @param {number} buffer_depth signed integer; clamped to int16
+     * @param {number} frame_number this side's sim frame
      */
-    send_time_dilation_feedback(peer_id: number, buffer_depth: number): void;
+    send_time_dilation_feedback(peer_id: number, buffer_depth: number, frame_number: 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.
+     * connection's acknowledgements like any message.
      *
      * @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-
-     * side dedup by logical seq. Use for messages where the action-stream
-     * model (best-effort, per-frame back-fill) isn't suitable — chat,
-     * lobby/room state, level transitions.
-     *
-     * Returns the logical seq the pipeline assigned (diagnostic only; the
-     * receiver dedups internally regardless).
+     * Queue a reliable command for a connected peer, on the connection's USER
+     * lane: it arrives once, whole, and in order with the peer's other
+     * commands, unless the connection ends first. Up to the connection's
+     * `max_message_bytes` (less the type byte). Use for messages where the
+     * action-stream model (best-effort, per-frame back-fill) isn't suitable —
+     * chat, lobby/room state, level transitions.
      *
      * @param {number} peer_id
      * @param {Uint8Array} payload
      * @param {number} length
-     * @returns {number} logical seq
+     * @returns {number} delivery mark: see {@link Connection#is_delivered} with {@link Lane.USER}
      */
     send_reliable_command(peer_id: number, payload: Uint8Array, length: number): number;
     #private;
 }
-/**
- * One outbound action-stream send, awaiting confirmation.
- *
- * A send occupies one transport seq when it fits the MTU and N consecutive
- * seqs when it has to be fragmented. All of those seqs map to the SAME record:
- * the receiver reassembles a fragmented message all-or-nothing, so the frame
- * range is confirmed only when `unacked` reaches zero without `abandoned`
- * having been set by a loss along the way.
- *
- * A tick may make several sends to one peer, each carrying the next slice of
- * the owed range (see {@link NetworkPeerflush_outbound }). They confirm
- * independently, and the baseline advances only through slices confirmed in
- * order — a later slice landing says nothing about an earlier one still in
- * flight. `head` marks the first slice of a tick, whose start is the pack
- * start itself; see {@link NetworkPeer__credit_confirmed }.
- */
-export type PendingAck = {
-    frame_start: number;
-    frame_end: number;
-    head: boolean;
-    unacked: number;
-    abandoned: boolean;
-};
 import { ReplicatedComponentRegistry } from "../sim/ReplicatedComponentRegistry.js";
 import { SimActionRegistry } from "../sim/SimActionRegistry.js";
 import { ReplicationSlotTable } from "../state/ReplicationSlotTable.js";
@@ -568,6 +607,6 @@ import { SimActionExecutor } from "../sim/SimActionExecutor.js";
 import { Replicator } from "../replication/Replicator.js";
 import { Baseline } from "../state/Baseline.js";
 import Signal from "../../../core/events/signal/Signal.js";
-import { Channel } from "../transport/Channel.js";
+import { Connection } from "../transport/connection/Connection.js";
 import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 //# sourceMappingURL=NetworkPeer.d.ts.map

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":";;;;;gCA4CU,MAAM;;;;;;;;;;;;;;;;;;8BAuHN,MAAM;AAHhB;;;;GAIG;AACH;IACI,gGAAgG;;IAEhG,iFAAiF;;GAElF;;;;iCAIiB,MAAM;AAF1B;;;GAGG;AACH;;;;;IAKI;;;;;OAKG;;IAEH;;;;;;;;OAQG;;GAEJ;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAwDI;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,gVAzBW;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;QAClC,KAAS,QAAc,MAAM,CAAC;QAC9B,cAAkB,EAAE,MAAM,CAAC;QAC3B,0BAA8B,CAAC,EAAE,MAAM,CAAC;QACxC,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,gBAAoB,CAAC,EAAE,MAAM,CAAC;KAC3B,EAqSH;IAzPG,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;;;;;;;;;;;;;;;;OAgBG;IACH,sBAFU,MAAM,CAEgC;IAEhD;;;;;;;;OAQG;IACH,iBAFU,cAAc,GAAC,IAAI,CAES;IAEtC;;;;;;;;;OASG;IACH,kCAFU,MAAM,CAEwD;IAWxE,gCAAgC;IAChC,UADW,iBAAiB,CAQ1B;IAEF,yBAAyB;IACzB,YADW,UAAU,CAOnB;IAEF,uBAAuB;IACvB,UADW,QAAQ,CACW;IAwB9B;;;;;;OAMG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,iBAFU,MAAM,CAEmB;IAEnC;;;;;;;OAOG;IACH,iBAFU,MAAM,CAEmB;IAEnC;;;;;;OAMG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;;;;OAQG;IACH,aAFU,MAAM,CAEe;IAE/B;;;;;OAKG;IACH,wBAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;;;;OAOG;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,QAoO3E;IAED;;;;OAIG;IACH,yBAFW,MAAM,QAkBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,6BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,UAAU,GAAC,SAAS,CAKhC;IAED;;;;;;;;;;;OAWG;IACH,uBAFW,MAAM,QAQhB;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,eACN,MAAM,QAShB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,yBAFW,MAAM,QAehB;IAED;;;;;;;OAOG;IACH,yBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,iBASC;IAED;;;;OAIG;IACH,oBAIC;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,+BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,8BAFW,MAAM,QA2MhB;IAqDD;;;;;;;;;;;OAWG;IACH,+BAJW,MAAM,cACN,MAAM,YACN,MAAM,QAchB;IAED;;;;;;;;;;;;;OAaG;IACH,oCAJW,MAAM,cACN,MAAM,YACN,MAAM,OA6ChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBALW,MAAM,gBACN,MAAM,cACN,MAAM,mBACG,YAAY,KAAG,IAAI,QAgBtC;IAED;;;;;;;;;;;OAWG;IACH,wBARW,MAAM,iBACN,UAAU,gBACV,MAAM,SACN,MAAM,YACN,UAAU,UACV,MAAM,GACJ,MAAM,CAkBlB;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;;;;;;;;OAQG;IACH,qCAJW,MAAM,gBACN,MAAM,gBACN,MAAM,QAkBhB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,gBACN,MAAM,QAYhB;IAED;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,WACN,UAAU,UACV,MAAM,GACJ,MAAM,CAalB;;CACJ;4CAlmD2C,uCAAuC;kCAEjD,6BAA6B;qCAK1B,kCAAkC;0BAR7C,qBAAqB;+BAOhB,4BAA4B;kCALZ,6BAA6B;2BAJjD,8BAA8B;yBAOhC,sBAAsB;mBAT5B,uCAAuC;2BAazB,uCAAuC;6BAd3C,sCAAsC"}