@oasys/oecs 0.5.4 → 0.6.0

package/dist/core/store/action_ring.d.cts

@@ -1,71 +1,71 @@
 /**
- * Action ring — main-thread producer / worker-thread consumer SPSC ring
+ * Action ring, a main-thread producer and worker-thread consumer SPSC ring
  * for client input intents (`send_action`-shaped bytes).
  *
  * Same on-the-wire shape as `command_ring.ts`, but with two practical
  * differences:
  *
- *   1. Producer/consumer roles flip — the action ring is main → worker,
+ *   1. Producer and consumer roles flip, the action ring is main → worker,
  *      whereas the command ring is sim → host.
  *   2. Slot payload carries a `length` prefix because client actions are
  *      variable-width (the encoded bytes that would normally go straight
- *      to the WebSocket). `payload[0]` is the length in bytes; bytes
+ *      to the WebSocket). `payload[0]` is the length in bytes. Bytes
  *      `[1..1+length)` are the action payload itself.
  *
  * Layout (identical to command ring header):
  *
- *   [ write_head:   u32 ]   monotonic; modulo `capacity_slots` for slot
+ *   [ write_head:   u32 ]   monotonic. Modulo `capacity_slots` for slot
  *   [ read_head:    u32 ]   monotonic
  *   [ capacity:     u32 ]   slot count, power-of-two
- *   [ overflow:     u32 ]   0 = OK; 1 = ring exhausted (producer side)
+ *   [ overflow:     u32 ]   0 = OK, 1 = ring exhausted (producer side)
  *   [ slot 0:       16 B ]  length: u8, payload: [15]u8
  *   [ slot 1:       16 B ]  ...
  *
  * SPSC contract:
- *   - Producer: main thread, from `GameNetworkClient.send_action`. Pushes
- *     one entry per user action; `Atomics.store`s `write_head` after each.
- *   - Consumer: sim worker, drained on each `apply_diff` / `apply_snapshot`
- *     boundary. `Atomics.store`s `read_head` after each pop.
- *   - Today's consumer is a no-op observer (logs / counts in DEV) — the
- *     wire path still goes main → WebSocket → server. A later change moves
- *     the `PredictionReconciler` into the worker so the action ring becomes
- *     load-bearing for client-side prediction.
+ *   - Producer: the main thread, from the host's action-send call. It pushes
+ *     one entry per user action, and `Atomics.store`s `write_head` after each.
+ *   - Consumer: the worker, drained on each apply boundary. It `Atomics.store`s
+ *     `read_head` after each pop.
+ *   - Today's consumer only observes (it logs or counts in DEV), because the
+ *     host's own send path still carries the action. A later change moves
+ *     reconciliation into the worker, and the ring becomes load-bearing for
+ *     client-side prediction.
  *
  * Overflow:
- *   - If main writes a slot when `(write_head - read_head) === capacity`,
- *     it sets `overflow = 1` and the push returns `false`. The server
- *     send path is independent (`_transport.send(...)` ran first), so an
- *     overflow doesn't drop the action — it only drops worker
+ *   - If the main thread writes a slot when
+ *     `(write_head - read_head) === capacity`, it sets `overflow = 1` and the
+ *     push returns `false`. The host's own send path is independent and ran
+ *     first, so an overflow does not drop the action. It only drops worker
  *     observability for that one entry.
  *
- * Atomics: the head fields (`write_head` / `read_head`) are the
- * cross-thread synchronization edge — the producer runs on the main
- * thread, the consumer in the sim worker, and both alias the same
+ * Atomics: the head fields `write_head` and `read_head` are the
+ * cross-thread synchronization edge, the producer runs on the main
+ * thread, the consumer in the worker, and both alias the same
  * `SharedArrayBuffer`. The producer writes the slot bytes, then
- * `Atomics.store`s `write_head`; the consumer `Atomics.load`s
+ * `Atomics.store`s `write_head`. The consumer `Atomics.load`s
  * `write_head` before touching the slot, reads it, then `Atomics.store`s
  * `read_head`. These SeqCst ops establish the happens-before that a
  * plain `DataView` write does not under the JS memory model:
  * without them the worker could observe a bumped `write_head` before the
  * producer's `setUint8(len)` + payload `set()` are visible and read a
- * torn/stale slot, and the producer could read a stale `read_head`
+ * torn or stale slot, and the producer could read a stale `read_head`
  * (false overflow, or overwrite a slot mid-read). Slot payload bytes
- * stay on plain `DataView` / `Uint8Array` ops — the head Atomics fence
- * them, so no per-byte atomic is needed. A future PR may still add an
- * `Atomics.wait/notify` pair so the worker can block between actions
- * instead of polling — additive change, no layout shift.
+ * stay on plain `DataView` and `Uint8Array` ops, the head Atomics fence
+ * them, so no per-byte atomic is needed. A later change may still add an
+ * `Atomics.wait` and `Atomics.notify` pair so the worker can block between
+ * actions instead of polling. That is additive, with no layout shift.
  */
 /** Total bytes for the ring header. Identical to `command_ring`. */
 export declare const ACTION_RING_HEADER_BYTES = 16;
-/** Fixed slot size — 1-byte length + 15-byte payload. */
+/** Fixed slot size, 1-byte length + 15-byte payload. */
 export declare const ACTION_RING_SLOT_BYTES = 16;
-/** Default ring capacity in slots. Sized for ~250 ms of click-spam at 60
- * Hz on the high end of human input rates; 256 × 16 B = 4 KiB + 16 B
- * header. */
+/** Default ring capacity in slots. It holds a burst of clicks at the high end
+ * of a human input rate, over the frames a host takes to drain it. The region
+ * is the slot count times `ACTION_RING_SLOT_BYTES`, plus the header. */
 export declare const ACTION_RING_DEFAULT_CAPACITY_SLOTS = 256;
-/** Max payload bytes per slot (slot size minus the length prefix). All
- * actions defined in `packages/protocol/src/actions.ts` encode to under
- * 8 bytes, so this is comfortably above today's max. */
+/** Max payload bytes per slot, the slot size minus the length prefix. An
+ * action a host sends encodes to a few bytes, so the slot holds one with
+ * room to spare. */
 export declare const ACTION_RING_MAX_PAYLOAD_BYTES: number;
 /** Byte offsets within the ring header. Matches `command_ring` so a
  * future shared helper can normalise across both rings without per-ring
@@ -82,7 +82,7 @@ export declare class ActionRingError extends Error {
     constructor(message: string);
 }
 /** Initialise the ring header at `ringOff` in the SAB. Zeroes heads
- * and the overflow flag; sets `capacity_slots`. Slot bytes are left
+ * and the overflow flag. Sets `capacity_slots`. Slot bytes are left
  * as-is (callers normally allocate the ring on a zero-initialised SAB). */
 export declare function initActionRing(view: DataView, ringOff: number, capacitySlots: number): void;
 /** Read live ring-header fields. Heads are stored signed but returned
@@ -95,8 +95,8 @@ export declare function actionRingOverflow(view: DataView, ringOff: number): boo
 /** Pending entry count = `(write_head - read_head) mod 2^32`. */
 export declare function pendingActionCount(view: DataView, ringOff: number): number;
 /** Push an action into the ring. `payload` must be in
- * `[1, ACTION_RING_MAX_PAYLOAD_BYTES]`; longer payloads — and **empty**
- * ones — are an `ActionRingError` (the producer is the only caller and it
+ * `[1, ACTION_RING_MAX_PAYLOAD_BYTES]`. Longer payloads, and **empty**
+ * ones, are an `ActionRingError` (the producer is the only caller and it
  * can size its inputs ahead of time). The zero-length rejection closes the
  * lower-bound footgun: a 0-byte slot is indistinguishable from
  * `popAction`'s empty-ring sentinel (`0`), so admitting one would let it
@@ -106,29 +106,29 @@ export declare function pendingActionCount(view: DataView, ringOff: number): num
 export declare function pushAction(view: DataView, ringOff: number, payload: Uint8Array): boolean;
 /** Pop one action from the ring. Returns the byte length written into
  * `outPayload`, or `0` if the ring was empty. `outPayload` must be at
- * least `ACTION_RING_MAX_PAYLOAD_BYTES`; only the first `length` bytes
+ * least `ACTION_RING_MAX_PAYLOAD_BYTES`. Only the first `length` bytes
  * are meaningful after a non-zero return.
  *
- * NOTE: a `0` return is ambiguous — it means "ring empty" OR "a 0-byte
+ * A `0` return is ambiguous. It means "ring empty" or "a 0-byte
  * slot" (the latter only reachable via ABI-skew, since `pushAction`
  * rejects empty payloads). Callers that loop must decide emptiness from
- * the heads (`pendingActionCount` / `write_head === read_head`), not
- * from this return value; see `drainActionRing`. */
+ * the heads, either `pendingActionCount` or `write_head === read_head`, and
+ * not from this return value. See `drainActionRing`. */
 export declare function popAction(view: DataView, ringOff: number, outPayload: Uint8Array): number;
 /** Drain every pending action, invoking `handler(payload)` per entry.
  * The `payload` passed to the handler is a freshly-copied
  * `Uint8Array(length)` so handlers can hold it past the next pop without
  * aliasing the scratch buffer. Returns the number of actions drained.
  *
- * Termination is decided from the heads (`pendingActionCount`), NOT from
- * `popAction`'s return value. A genuine 0-byte slot returns `0` — the same
- * value `popAction` yields on an empty ring — so terminating on `len === 0`
+ * Termination is decided from the heads (`pendingActionCount`), not from
+ * `popAction`'s return value. A genuine 0-byte slot returns `0`, the same
+ * value `popAction` yields on an empty ring, so terminating on `len === 0`
  * would silently consume the zero-length entry and strand everything queued
  * behind it for a tick. The heads check is SPSC-safe: this consumer
  * is the sole reader, so a non-zero pending count cannot race to empty before
  * the `popAction` below. */
 export declare function drainActionRing(view: DataView, ringOff: number, handler: (payload: Uint8Array) => void): number;
-/** Clear the overflow flag. The producer sets it on a failed push; the
+/** Clear the overflow flag. The producer sets it on a failed push. The
  * consumer can reset it once it has observed and logged the condition,
  * so a single overflow doesn't keep firing dev assertions. */
 export declare function clearActionRingOverflow(view: DataView, ringOff: number): void;

package/dist/core/store/action_ring.d.ts

@@ -1,71 +1,71 @@
 /**
- * Action ring — main-thread producer / worker-thread consumer SPSC ring
+ * Action ring, a main-thread producer and worker-thread consumer SPSC ring
  * for client input intents (`send_action`-shaped bytes).
  *
  * Same on-the-wire shape as `command_ring.ts`, but with two practical
  * differences:
  *
- *   1. Producer/consumer roles flip — the action ring is main → worker,
+ *   1. Producer and consumer roles flip, the action ring is main → worker,
  *      whereas the command ring is sim → host.
  *   2. Slot payload carries a `length` prefix because client actions are
  *      variable-width (the encoded bytes that would normally go straight
- *      to the WebSocket). `payload[0]` is the length in bytes; bytes
+ *      to the WebSocket). `payload[0]` is the length in bytes. Bytes
  *      `[1..1+length)` are the action payload itself.
  *
  * Layout (identical to command ring header):
  *
- *   [ write_head:   u32 ]   monotonic; modulo `capacity_slots` for slot
+ *   [ write_head:   u32 ]   monotonic. Modulo `capacity_slots` for slot
  *   [ read_head:    u32 ]   monotonic
  *   [ capacity:     u32 ]   slot count, power-of-two
- *   [ overflow:     u32 ]   0 = OK; 1 = ring exhausted (producer side)
+ *   [ overflow:     u32 ]   0 = OK, 1 = ring exhausted (producer side)
  *   [ slot 0:       16 B ]  length: u8, payload: [15]u8
  *   [ slot 1:       16 B ]  ...
  *
  * SPSC contract:
- *   - Producer: main thread, from `GameNetworkClient.send_action`. Pushes
- *     one entry per user action; `Atomics.store`s `write_head` after each.
- *   - Consumer: sim worker, drained on each `apply_diff` / `apply_snapshot`
- *     boundary. `Atomics.store`s `read_head` after each pop.
- *   - Today's consumer is a no-op observer (logs / counts in DEV) — the
- *     wire path still goes main → WebSocket → server. A later change moves
- *     the `PredictionReconciler` into the worker so the action ring becomes
- *     load-bearing for client-side prediction.
+ *   - Producer: the main thread, from the host's action-send call. It pushes
+ *     one entry per user action, and `Atomics.store`s `write_head` after each.
+ *   - Consumer: the worker, drained on each apply boundary. It `Atomics.store`s
+ *     `read_head` after each pop.
+ *   - Today's consumer only observes (it logs or counts in DEV), because the
+ *     host's own send path still carries the action. A later change moves
+ *     reconciliation into the worker, and the ring becomes load-bearing for
+ *     client-side prediction.
  *
  * Overflow:
- *   - If main writes a slot when `(write_head - read_head) === capacity`,
- *     it sets `overflow = 1` and the push returns `false`. The server
- *     send path is independent (`_transport.send(...)` ran first), so an
- *     overflow doesn't drop the action — it only drops worker
+ *   - If the main thread writes a slot when
+ *     `(write_head - read_head) === capacity`, it sets `overflow = 1` and the
+ *     push returns `false`. The host's own send path is independent and ran
+ *     first, so an overflow does not drop the action. It only drops worker
  *     observability for that one entry.
  *
- * Atomics: the head fields (`write_head` / `read_head`) are the
- * cross-thread synchronization edge — the producer runs on the main
- * thread, the consumer in the sim worker, and both alias the same
+ * Atomics: the head fields `write_head` and `read_head` are the
+ * cross-thread synchronization edge, the producer runs on the main
+ * thread, the consumer in the worker, and both alias the same
  * `SharedArrayBuffer`. The producer writes the slot bytes, then
- * `Atomics.store`s `write_head`; the consumer `Atomics.load`s
+ * `Atomics.store`s `write_head`. The consumer `Atomics.load`s
  * `write_head` before touching the slot, reads it, then `Atomics.store`s
  * `read_head`. These SeqCst ops establish the happens-before that a
  * plain `DataView` write does not under the JS memory model:
  * without them the worker could observe a bumped `write_head` before the
  * producer's `setUint8(len)` + payload `set()` are visible and read a
- * torn/stale slot, and the producer could read a stale `read_head`
+ * torn or stale slot, and the producer could read a stale `read_head`
  * (false overflow, or overwrite a slot mid-read). Slot payload bytes
- * stay on plain `DataView` / `Uint8Array` ops — the head Atomics fence
- * them, so no per-byte atomic is needed. A future PR may still add an
- * `Atomics.wait/notify` pair so the worker can block between actions
- * instead of polling — additive change, no layout shift.
+ * stay on plain `DataView` and `Uint8Array` ops, the head Atomics fence
+ * them, so no per-byte atomic is needed. A later change may still add an
+ * `Atomics.wait` and `Atomics.notify` pair so the worker can block between
+ * actions instead of polling. That is additive, with no layout shift.
  */
 /** Total bytes for the ring header. Identical to `command_ring`. */
 export declare const ACTION_RING_HEADER_BYTES = 16;
-/** Fixed slot size — 1-byte length + 15-byte payload. */
+/** Fixed slot size, 1-byte length + 15-byte payload. */
 export declare const ACTION_RING_SLOT_BYTES = 16;
-/** Default ring capacity in slots. Sized for ~250 ms of click-spam at 60
- * Hz on the high end of human input rates; 256 × 16 B = 4 KiB + 16 B
- * header. */
+/** Default ring capacity in slots. It holds a burst of clicks at the high end
+ * of a human input rate, over the frames a host takes to drain it. The region
+ * is the slot count times `ACTION_RING_SLOT_BYTES`, plus the header. */
 export declare const ACTION_RING_DEFAULT_CAPACITY_SLOTS = 256;
-/** Max payload bytes per slot (slot size minus the length prefix). All
- * actions defined in `packages/protocol/src/actions.ts` encode to under
- * 8 bytes, so this is comfortably above today's max. */
+/** Max payload bytes per slot, the slot size minus the length prefix. An
+ * action a host sends encodes to a few bytes, so the slot holds one with
+ * room to spare. */
 export declare const ACTION_RING_MAX_PAYLOAD_BYTES: number;
 /** Byte offsets within the ring header. Matches `command_ring` so a
  * future shared helper can normalise across both rings without per-ring
@@ -82,7 +82,7 @@ export declare class ActionRingError extends Error {
     constructor(message: string);
 }
 /** Initialise the ring header at `ringOff` in the SAB. Zeroes heads
- * and the overflow flag; sets `capacity_slots`. Slot bytes are left
+ * and the overflow flag. Sets `capacity_slots`. Slot bytes are left
  * as-is (callers normally allocate the ring on a zero-initialised SAB). */
 export declare function initActionRing(view: DataView, ringOff: number, capacitySlots: number): void;
 /** Read live ring-header fields. Heads are stored signed but returned
@@ -95,8 +95,8 @@ export declare function actionRingOverflow(view: DataView, ringOff: number): boo
 /** Pending entry count = `(write_head - read_head) mod 2^32`. */
 export declare function pendingActionCount(view: DataView, ringOff: number): number;
 /** Push an action into the ring. `payload` must be in
- * `[1, ACTION_RING_MAX_PAYLOAD_BYTES]`; longer payloads — and **empty**
- * ones — are an `ActionRingError` (the producer is the only caller and it
+ * `[1, ACTION_RING_MAX_PAYLOAD_BYTES]`. Longer payloads, and **empty**
+ * ones, are an `ActionRingError` (the producer is the only caller and it
  * can size its inputs ahead of time). The zero-length rejection closes the
  * lower-bound footgun: a 0-byte slot is indistinguishable from
  * `popAction`'s empty-ring sentinel (`0`), so admitting one would let it
@@ -106,29 +106,29 @@ export declare function pendingActionCount(view: DataView, ringOff: number): num
 export declare function pushAction(view: DataView, ringOff: number, payload: Uint8Array): boolean;
 /** Pop one action from the ring. Returns the byte length written into
  * `outPayload`, or `0` if the ring was empty. `outPayload` must be at
- * least `ACTION_RING_MAX_PAYLOAD_BYTES`; only the first `length` bytes
+ * least `ACTION_RING_MAX_PAYLOAD_BYTES`. Only the first `length` bytes
  * are meaningful after a non-zero return.
  *
- * NOTE: a `0` return is ambiguous — it means "ring empty" OR "a 0-byte
+ * A `0` return is ambiguous. It means "ring empty" or "a 0-byte
  * slot" (the latter only reachable via ABI-skew, since `pushAction`
  * rejects empty payloads). Callers that loop must decide emptiness from
- * the heads (`pendingActionCount` / `write_head === read_head`), not
- * from this return value; see `drainActionRing`. */
+ * the heads, either `pendingActionCount` or `write_head === read_head`, and
+ * not from this return value. See `drainActionRing`. */
 export declare function popAction(view: DataView, ringOff: number, outPayload: Uint8Array): number;
 /** Drain every pending action, invoking `handler(payload)` per entry.
  * The `payload` passed to the handler is a freshly-copied
  * `Uint8Array(length)` so handlers can hold it past the next pop without
  * aliasing the scratch buffer. Returns the number of actions drained.
  *
- * Termination is decided from the heads (`pendingActionCount`), NOT from
- * `popAction`'s return value. A genuine 0-byte slot returns `0` — the same
- * value `popAction` yields on an empty ring — so terminating on `len === 0`
+ * Termination is decided from the heads (`pendingActionCount`), not from
+ * `popAction`'s return value. A genuine 0-byte slot returns `0`, the same
+ * value `popAction` yields on an empty ring, so terminating on `len === 0`
  * would silently consume the zero-length entry and strand everything queued
  * behind it for a tick. The heads check is SPSC-safe: this consumer
  * is the sole reader, so a non-zero pending count cannot race to empty before
  * the `popAction` below. */
 export declare function drainActionRing(view: DataView, ringOff: number, handler: (payload: Uint8Array) => void): number;
-/** Clear the overflow flag. The producer sets it on a failed push; the
+/** Clear the overflow flag. The producer sets it on a failed push. The
  * consumer can reset it once it has observed and logged the condition,
  * so a single overflow doesn't keep firing dev assertions. */
 export declare function clearActionRingOverflow(view: DataView, ringOff: number): void;

package/dist/core/store/action_ring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action_ring.d.ts","sourceRoot":"","sources":["../../../src/core/store/action_ring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,yDAAyD;AACzD,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;aAEa;AACb,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD;;wDAEwD;AACxD,eAAO,MAAM,6BAA6B,QAA6B,CAAC;AAExE;;iBAEiB;AACjB,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAC;AAwBX,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE7D;AAMD,qBAAa,eAAgB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI3B;AAED;;2EAE2E;AAC3E,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAiB3F;AAED;;mDAEmD;AACnD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3E;AACD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1E;AACD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/E;AACD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;0CAQ0C;AAC1C,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAoCxF;AAED;;;;;;;;;oDASoD;AACpD,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAwBzF;AAED;;;;;;;;;;;4BAW4B;AAC5B,wBAAgB,eAAe,CAC9B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,GACpC,MAAM,CAUR;AAED;;8DAE8D;AAC9D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7E"}
+{"version":3,"file":"action_ring.d.ts","sourceRoot":"","sources":["../../../src/core/store/action_ring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,wDAAwD;AACxD,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;wEAEwE;AACxE,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD;;oBAEoB;AACpB,eAAO,MAAM,6BAA6B,QAA6B,CAAC;AAExE;;iBAEiB;AACjB,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAC;AAwBX,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE7D;AAMD,qBAAa,eAAgB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI3B;AAED;;2EAE2E;AAC3E,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAiB3F;AAED;;mDAEmD;AACnD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3E;AACD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1E;AACD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/E;AACD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;0CAQ0C;AAC1C,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CA0CxF;AAED;;;;;;;;;wDASwD;AACxD,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CA4BzF;AAED;;;;;;;;;;;4BAW4B;AAC5B,wBAAgB,eAAe,CAC9B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,GACpC,MAAM,CAUR;AAED;;8DAE8D;AAC9D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7E"}