@rotorsoft/act-sse 1.0.1 → 1.1.1

package/dist/@types/apply-patch.d.ts

@@ -1,35 +1,29 @@
-import type { BroadcastMessage, BroadcastState } from "./types.js";
+import type { BroadcastState, PatchMessage } from "./types.js";
 /**
- * Result of applying a broadcast message to cached client state.
+ * Result of applying a patch message to cached client state.
  */
 export type ApplyResult<S extends BroadcastState = BroadcastState> = {
     ok: true;
     state: S;
 } | {
     ok: false;
-    reason: "stale" | "behind" | "patch-failed";
+    reason: "stale" | "behind";
 };
 /**
- * Apply a broadcast message to the client's cached state.
- *
- * Handles both full state and incremental patches with version validation.
- * Returns the new state on success, or a failure reason that the client
- * can use to decide whether to resync.
+ * Apply a version-keyed patch message to the client's cached state.
  *
  * ## Version logic
  *
- * - **Full state**: accepted if `msg._v >= cachedV` (or no cached state)
- * - **Patch**:
- *   - `_baseV < cachedV` → "stale" (client ahead, skip — mutation response arrived first)
- *   - `_baseV > cachedV` → "behind" (client missed a version, must resync)
- *   - `_baseV === cachedV` → apply patch ops
+ * - All patches older than cached → "stale" (client already ahead)
+ * - Gap between cached version and first patch → "behind" (client missed versions, must resync)
+ * - Contiguous from cached version → apply in order
  *
  * ## Usage (React Query)
  *
  * ```typescript
  * onData: (msg) => {
  *   const cached = utils.getState.getData({ streamId });
- *   const result = applyBroadcastMessage(msg, cached);
+ *   const result = applyPatchMessage(msg, cached);
  *   if (result.ok) {
  *     utils.getState.setData({ streamId }, result.state);
  *   } else if (result.reason === "behind") {
@@ -39,5 +33,5 @@ export type ApplyResult<S extends BroadcastState = BroadcastState> = {
  * }
  * ```
  */
-export declare function applyBroadcastMessage<S extends BroadcastState>(msg: BroadcastMessage<S>, cached: S | null | undefined): ApplyResult<S>;
+export declare function applyPatchMessage<S extends BroadcastState>(msg: PatchMessage<S>, cached: S | null | undefined): ApplyResult<S>;
 //# sourceMappingURL=apply-patch.d.ts.map

package/dist/@types/apply-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/apply-patch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAC7D;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,cAAc,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,cAAc,EAC5D,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,EACxB,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAC3B,WAAW,CAAC,CAAC,CAAC,CAyBhB"}
+{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/apply-patch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/D;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAC7D;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAA;CAAE,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,cAAc,EACxD,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAC3B,WAAW,CAAC,CAAC,CAAC,CAuBhB"}

package/dist/@types/broadcast.d.ts

@@ -1,12 +1,11 @@
 import { StateCache } from "./state-cache.js";
-import type { BroadcastMessage, BroadcastOptions, BroadcastState, Subscriber } from "./types.js";
+import type { BroadcastState, PatchMessage, Subscriber } from "./types.js";
 /**
  * Server-side broadcast channel for incremental state sync over SSE.
  *
  * Manages per-stream subscriber sets and an LRU state cache. When state
- * changes, computes an RFC 6902 JSON Patch against the previous cached
- * state and pushes either a patch (small diff) or full state (large diff
- * or first broadcast) to all subscribers.
+ * changes, forwards domain patches (from event handlers) to all subscribers
+ * as version-keyed messages.
  *
  * ## Usage
  *
@@ -14,9 +13,10 @@ import type { BroadcastMessage, BroadcastOptions, BroadcastState, Subscriber } f
  * const broadcast = new BroadcastChannel<MyState>();
  *
  * // After every app.do():
- * const snap = await doAction(...);
- * const state = deriveState(snap);       // app-specific state derivation
- * broadcast.publish(streamId, state);    // computes patch + pushes to SSE
+ * const snaps = await app.do(...);
+ * const patches = snaps.map(s => s.patch).filter(Boolean);
+ * const state = deriveState(snaps.at(-1));
+ * broadcast.publish(streamId, state, patches);
  *
  * // In SSE subscription:
  * const cleanup = broadcast.subscribe(streamId, (msg) => {
@@ -26,7 +26,6 @@ import type { BroadcastMessage, BroadcastOptions, BroadcastState, Subscriber } f
  *
  * // Initial state for reconnects:
  * const cached = broadcast.getState(streamId);
- * if (cached) yield { _type: "full", ...cached, serverTime: ... };
  * ```
  *
  * ## Version Contract
@@ -38,25 +37,24 @@ import type { BroadcastMessage, BroadcastOptions, BroadcastState, Subscriber } f
 export declare class BroadcastChannel<S extends BroadcastState = BroadcastState> {
     private channels;
     private stateCache;
-    private maxPatchOps;
-    constructor(options?: BroadcastOptions & {
+    constructor(options?: {
         cacheSize?: number;
     });
     /**
-     * Publish new state for a stream. Computes a patch against the previously
-     * cached state and pushes to all subscribers.
+     * Publish domain patches from a commit.
+     * patches[i] corresponds to version baseV + i + 1.
      *
      * @param streamId - The event store stream ID
      * @param state - Full state with `_v` set from `snap.event.version`
-     * @returns The broadcast message that was sent (or undefined if no subscribers and no cache change)
+     * @param patches - Array of domain patches, one per emitted event
      */
-    publish(streamId: string, state: S): BroadcastMessage<S>;
+    publish(streamId: string, state: S, patches?: Partial<S>[]): PatchMessage<S>;
     /**
      * Publish a state update that doesn't change the event version
      * (e.g. presence overlay, computed field refresh).
-     * Uses the same version as the cached state for _baseV and _v.
+     * Uses the same version as the cached state, single entry.
      */
-    publishOverlay(streamId: string, state: S): BroadcastMessage<S> | undefined;
+    publishOverlay(streamId: string, overlayPatch: Partial<S>): PatchMessage<S> | undefined;
     /**
      * Subscribe to broadcast messages for a stream.
      * Returns a cleanup function that removes the subscription.
@@ -68,6 +66,5 @@ export declare class BroadcastChannel<S extends BroadcastState = BroadcastState>
     getState(streamId: string): S | undefined;
     /** Direct access to the state cache (for app-specific reads like presence). */
     get cache(): StateCache<S>;
-    private computeMessage;
 }
 //# sourceMappingURL=broadcast.d.ts.map

package/dist/@types/broadcast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../src/broadcast.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACX,MAAM,YAAY,CAAC;AAIpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc;IACrE,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,CAAC,EAAE,gBAAgB,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAK/D;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC;IAYxD;;;;OAIG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS;IAc3E;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAW1D,kDAAkD;IAClD,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI5C,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAIzC,+EAA+E;IAC/E,IAAI,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAEzB;IAID,OAAO,CAAC,cAAc;CAwBvB"}
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../src/broadcast.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc;IACrE,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,UAAU,CAAgB;gBAEtB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAI5C;;;;;;;OAOG;IACH,OAAO,CACL,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,OAAO,CAAC,CAAC,CAAC,EAAO,GACzB,YAAY,CAAC,CAAC,CAAC;IAgBlB;;;;OAIG;IACH,cAAc,CACZ,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,GACvB,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS;IAe9B;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAW1D,kDAAkD;IAClD,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI5C,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAIzC,+EAA+E;IAC/E,IAAI,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAEzB;CACF"}

package/dist/@types/index.d.ts

@@ -4,34 +4,31 @@
  *
  * Incremental state broadcast over SSE for act event-sourced apps.
  *
- * Provides server-side broadcast with automatic RFC 6902 JSON Patch
- * computation, an LRU state cache, presence tracking, and a client-side
+ * Provides server-side broadcast with domain patch forwarding,
+ * an LRU state cache, presence tracking, and a client-side
  * patch applicator with version validation and resync detection.
  *
  * ## Architecture
  *
  * ```
- *   app.do() → snap
+ *   app.do() → snapshots (each carries its domain patch)
  *       │
  *       ▼
  *   deriveState(snap)          ← app-specific (overlay presence, deadlines, etc.)
  *   state._v = snap.event.version
  *       │
  *       ▼
- *   broadcast.publish(streamId, state)
+ *   broadcast.publish(streamId, state, patches)
  *       │
- *       ├── compare(prev, state) → RFC 6902 ops
- *       ├── if ops ≤ threshold → PatchMessage { _baseV, _v, _patch }
- *       ├── if ops > threshold → FullStateMessage { _v, ...state }
+ *       ├── version-key each patch: { [baseV+1]: patch1, [baseV+2]: patch2 }
  *       └── push to all SSE subscribers
  *       │
  *       ▼
- *   Client: applyBroadcastMessage(msg, cached)
+ *   Client: applyPatchMessage(msg, cached)
  *       │
- *       ├── full  → accept if _v ≥ cachedV
- *       ├── patch → apply if _baseV === cachedV
- *       ├── stale → skip (_baseV < cachedV, mutation response arrived first)
- *       └── behind → resync (_baseV > cachedV, client missed a version)
+ *       ├── contiguous → deep-merge patches in version order
+ *       ├── stale    → skip (client already ahead)
+ *       └── behind   → resync (client missed versions)
  * ```
  *
  * ## Version Contract
@@ -39,10 +36,11 @@
  * `_v` is always the event store stream version (`snap.event.version`).
  * No separate version counters. The event store is the single source of truth.
  */
-export { applyBroadcastMessage } from "./apply-patch.js";
+export { applyPatchMessage } from "./apply-patch.js";
 export type { ApplyResult } from "./apply-patch.js";
 export { BroadcastChannel } from "./broadcast.js";
+export { patch } from "./patch.js";
 export { PresenceTracker } from "./presence.js";
 export { StateCache } from "./state-cache.js";
-export type { BroadcastMessage, BroadcastOptions, BroadcastState, FullStateMessage, PatchMessage, Subscriber, } from "./types.js";
+export type { BroadcastState, PatchMessage, Subscriber } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/@types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/@types/patch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser-safe deep merge utility — identical semantics to @rotorsoft/act's patch().
+ * Inlined here so act-sse has zero Node dependencies.
+ */
+type Schema = Record<string, any>;
+type Patch<T> = {
+    [K in keyof T]?: T[K] extends Schema ? Patch<T[K]> : T[K];
+};
+/** Immutably deep-merge `patches` into `original`. */
+export declare const patch: <S extends Schema>(original: Readonly<S>, patches: Readonly<Patch<S>>) => Readonly<S>;
+export {};
+//# sourceMappingURL=patch.d.ts.map

package/dist/@types/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../src/patch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAClC,KAAK,KAAK,CAAC,CAAC,IAAI;KACb,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AA8BF,sDAAsD;AACtD,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,MAAM,EACpC,UAAU,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAC1B,QAAQ,CAAC,CAAC,CAgBZ,CAAC"}

package/dist/@types/types.d.ts

@@ -1,4 +1,3 @@
-import type { Operation } from "fast-json-patch";
 /**
  * Base constraint for state objects managed by the broadcast system.
  * Apps extend this with their own domain state shape.
@@ -8,39 +7,20 @@ export type BroadcastState = Record<string, unknown> & {
     _v: number;
 };
 /**
- * Full state message — sent on initial connect, resync, or when patch is too large.
+ * Recursive deep partial — mirrors act core's Patch<T>.
  */
-export type FullStateMessage<S extends BroadcastState = BroadcastState> = S & {
-    _type: "full";
-    serverTime: string;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Record<string, any> ? DeepPartial<T[K]> : T[K];
 };
 /**
- * Incremental patch message — sent when the diff is small enough.
- * Client applies RFC 6902 operations to its cached state at _baseV to reach _v.
+ * SSE message: version-keyed domain patches.
+ * Keys are stringified version numbers, values are domain patches (deep partials).
+ * Multi-event commits produce multiple version-keyed entries.
  */
-export type PatchMessage = {
-    _type: "patch";
-    /** Target version after applying the patch */
-    _v: number;
-    /** Version the patch applies to (client must have this version cached) */
-    _baseV: number;
-    /** RFC 6902 JSON Patch operations */
-    _patch: Operation[];
-    serverTime: string;
-};
-/**
- * Discriminated union sent over SSE — client switches on `_type`.
- */
-export type BroadcastMessage<S extends BroadcastState = BroadcastState> = FullStateMessage<S> | PatchMessage;
+export type PatchMessage<S extends BroadcastState = BroadcastState> = Record<number, DeepPartial<S>>;
 /**
- * Subscriber callback — receives either a patch or full state message.
+ * Subscriber callback — receives version-keyed patch messages.
  */
-export type Subscriber<S extends BroadcastState = BroadcastState> = (msg: BroadcastMessage<S>) => void;
-/**
- * Options for creating a broadcast channel.
- */
-export type BroadcastOptions = {
-    /** Max RFC 6902 operations before falling back to full state (default: 50) */
-    maxPatchOps?: number;
-};
+export type Subscriber<S extends BroadcastState = BroadcastState> = (msg: PatchMessage<S>) => void;
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/@types/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACrD,sFAAsF;IACtF,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,CAAC,GAAG;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAClE,gBAAgB,CAAC,CAAC,CAAC,GACnB,YAAY,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,CAClE,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACrB,IAAI,CAAC;AAEV;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACrD,sFAAsF;IACtF,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF;;GAEG;AAEH,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC7E,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,MAAM,CAC1E,MAAM,EACN,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,CAClE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,KACjB,IAAI,CAAC"}