basalt-ui 1.10.0 → 1.12.0

package/dist/agent/adapter.js

@@ -0,0 +1,473 @@
+import { useEffect, useSyncExternalStore } from "react";
+import { mintThreadId } from "./id.js";
+function createAdapterThreadsStore(adapter, opts) {
+  const revalidateOnFocus = opts?.revalidateOnFocus ?? false;
+  const EMPTY = [];
+  const SERVER_SNAPSHOT = {
+    threads: EMPTY,
+    activeId: null,
+    hydrated: false,
+    error: void 0
+  };
+  let base = EMPTY;
+  let baseSeq = 0;
+  let activeId = null;
+  let hydrated = false;
+  let error;
+  let errorToken = 0;
+  let errorFromWrite = false;
+  const pending = [];
+  let snapshot = SERVER_SNAPSHOT;
+  const listeners = /* @__PURE__ */ new Set();
+  function recompute() {
+    let threads = base;
+    let active = activeId;
+    for (const patch of pending) {
+      threads = patch.apply(threads);
+      if (patch.applyActive !== void 0) active = patch.applyActive(active);
+    }
+    snapshot = { threads, activeId: active, hydrated, error };
+    for (const listener of listeners) listener();
+  }
+  function memoizeApply(apply) {
+    let lastIn;
+    let lastOut;
+    return (threads) => {
+      if (lastOut !== void 0 && threads === lastIn) return lastOut;
+      lastIn = threads;
+      lastOut = apply(threads);
+      return lastOut;
+    };
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  function getSnapshot() {
+    return snapshot;
+  }
+  function getServerSnapshot() {
+    return SERVER_SNAPSHOT;
+  }
+  let loadController = null;
+  let loadSeq = 0;
+  let queuedSeq = null;
+  function prune() {
+    const kept = [];
+    for (const patch of pending) {
+      if (patch.confirmSeq !== null && patch.confirmSeq <= baseSeq) {
+        if (patch.applyActive !== void 0) activeId = patch.applyActive(activeId);
+        continue;
+      }
+      kept.push(patch);
+    }
+    if (kept.length !== pending.length) pending.splice(0, pending.length, ...kept);
+  }
+  function startLoad(seq) {
+    const controller = new AbortController();
+    loadController = controller;
+    void (async () => {
+      try {
+        const next = await adapter.listThreads(controller.signal);
+        if (loadController !== controller) return;
+        base = [...next];
+        baseSeq = seq;
+        hydrated = true;
+        if (!errorFromWrite) error = void 0;
+        prune();
+        recompute();
+      } catch (cause) {
+        if (controller.signal.aborted || loadController !== controller) return;
+        error = cause;
+        errorToken += 1;
+        errorFromWrite = false;
+        recompute();
+      } finally {
+        if (loadController === controller) {
+          loadController = null;
+          if (queuedSeq !== null) {
+            const next = queuedSeq;
+            queuedSeq = null;
+            startLoad(next);
+          }
+        }
+      }
+    })();
+  }
+  function revalidate() {
+    if (loadController !== null) {
+      queuedSeq ??= ++loadSeq;
+      return queuedSeq;
+    }
+    const seq = ++loadSeq;
+    startLoad(seq);
+    return seq;
+  }
+  function forceRevalidate() {
+    loadController?.abort();
+    queuedSeq = null;
+    const seq = ++loadSeq;
+    startLoad(seq);
+    return seq;
+  }
+  const chains = /* @__PURE__ */ new Map();
+  function enqueue(threadIds, task) {
+    const ids = [...new Set(threadIds)];
+    const prior = ids.map((id) => chains.get(id)).filter((p) => p !== void 0);
+    const after = prior.length === 0 ? Promise.resolve() : Promise.all(prior).then(() => void 0);
+    const run = after.then(task);
+    for (const id of ids) chains.set(id, run);
+    void run.finally(() => {
+      for (const id of ids) if (chains.get(id) === run) chains.delete(id);
+    });
+  }
+  function drop(patch) {
+    const index = pending.indexOf(patch);
+    if (index !== -1) pending.splice(index, 1);
+  }
+  function mutate(i) {
+    const patch = {
+      apply: memoizeApply(i.apply),
+      ...i.applyActive !== void 0 ? { applyActive: i.applyActive } : {},
+      confirmSeq: null
+    };
+    pending.push(patch);
+    const tokenAtIssue = errorToken;
+    recompute();
+    enqueue(i.threadIds, async () => {
+      try {
+        await i.commit();
+      } catch (cause) {
+        drop(patch);
+        error = cause;
+        errorToken += 1;
+        errorFromWrite = true;
+        recompute();
+        revalidate();
+        return;
+      }
+      if (errorFromWrite && errorToken === tokenAtIssue) {
+        error = void 0;
+        errorFromWrite = false;
+        recompute();
+      }
+      patch.confirmSeq = revalidate();
+    });
+  }
+  function patchThread(id, update) {
+    return (threads) => threads.map((thread) => thread.id === id ? update(thread) : thread);
+  }
+  let mounted = 0;
+  function onFocus() {
+    forceRevalidate();
+  }
+  function retain() {
+    mounted += 1;
+    if (mounted !== 1) return;
+    revalidate();
+    if (revalidateOnFocus && typeof window !== "undefined") {
+      window.addEventListener("focus", onFocus);
+    }
+  }
+  function release() {
+    mounted -= 1;
+    if (mounted !== 0) return;
+    loadController?.abort();
+    loadController = null;
+    queuedSeq = null;
+    if (revalidateOnFocus && typeof window !== "undefined") {
+      window.removeEventListener("focus", onFocus);
+    }
+  }
+  function select(id) {
+    activeId = id;
+    recompute();
+  }
+  function create(createOpts) {
+    const id = mintThreadId();
+    const now = Date.now();
+    const thread = {
+      id,
+      messages: [],
+      outcome: null,
+      status: "pending",
+      read: false,
+      createdAt: now,
+      updatedAt: now,
+      ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
+    };
+    mutate({
+      threadIds: [id],
+      apply: (threads) => threads.some((t) => t.id === id) ? [...threads] : [thread, ...threads],
+      commit: () => adapter.createThread({
+        id,
+        ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
+      })
+    });
+    return id;
+  }
+  function appendMessage(id, message2) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(
+        id,
+        (thread) => thread.messages.some((m) => m.id === message2.id) ? thread : { ...thread, messages: [...thread.messages, message2], updatedAt: now }
+      ),
+      commit: () => adapter.appendMessage({ threadId: id, message: message2 })
+    });
+  }
+  function setOutcome(id, outcome) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(id, (thread) => ({ ...thread, outcome, updatedAt: now })),
+      commit: () => adapter.setOutcome({ threadId: id, outcome })
+    });
+  }
+  function setStatus(id, status) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(id, (thread) => ({ ...thread, status, updatedAt: now })),
+      commit: () => adapter.setStatus({ threadId: id, status })
+    });
+  }
+  function setResumeToken(id, token) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(id, (thread) => {
+        const { resumeToken: _resumeToken, ...rest } = thread;
+        return {
+          ...rest,
+          ...token !== void 0 ? { resumeToken: token } : {},
+          updatedAt: now
+        };
+      }),
+      commit: () => adapter.setResumeToken({ threadId: id, token })
+    });
+  }
+  function markRead(id) {
+    mutate({
+      threadIds: [id],
+      // Identity-preserving when the server already agrees — markRead does not bump updatedAt.
+      apply: patchThread(id, (thread) => thread.read ? thread : { ...thread, read: true }),
+      commit: () => adapter.markRead(id)
+    });
+  }
+  function remove(id) {
+    mutate({
+      threadIds: [id],
+      apply: (threads) => threads.filter((thread) => thread.id !== id),
+      // Inside the patch, so a rejected delete restores the SELECTION along with the row. Written
+      // as a conditional clear rather than a flat `null` so a `select()` issued while the delete
+      // is in flight survives the patch being re-applied on top of it.
+      applyActive: (active) => active === id ? null : active,
+      commit: () => adapter.removeThread(id)
+    });
+  }
+  function clear() {
+    const ids = snapshot.threads.map((thread) => thread.id);
+    const clearedIds = new Set(ids);
+    mutate({
+      threadIds: ids,
+      apply: () => [],
+      // Same idiom as remove(): only null a selection pointing at one of the threads THIS clear
+      // captured, so a select() issued while the clear is in flight — e.g. into a thread created
+      // concurrently by create() — survives the patch being re-applied on top of it.
+      applyActive: (active) => active !== null && clearedIds.has(active) ? null : active,
+      commit: async () => {
+        const results = await Promise.allSettled(ids.map((id) => adapter.removeThread(id)));
+        const failures = results.filter((r) => r.status === "rejected");
+        if (failures.length === 0) return;
+        throw new AggregateError(
+          failures.map((f) => f.reason),
+          `removeThread rejected for ${failures.length} of ${ids.length} threads`
+        );
+      }
+    });
+  }
+  return function useAdapterThreadsStore() {
+    const current = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    useEffect(() => {
+      retain();
+      return () => {
+        release();
+      };
+    }, []);
+    return {
+      threads: current.threads,
+      activeId: current.activeId,
+      hydrated: current.hydrated,
+      error: current.error,
+      select,
+      create,
+      appendMessage,
+      setOutcome,
+      setStatus,
+      setResumeToken,
+      markRead,
+      remove,
+      clear
+    };
+  };
+}
+function assert(condition, message2) {
+  if (!condition) throw new Error(`ThreadsStoreAdapter contract: ${message2}`);
+}
+function message(id) {
+  return { id, role: "user", parts: [], createdAt: Date.now() };
+}
+function threadsStoreAdapterContract(makeAdapter) {
+  function define(name, run) {
+    return {
+      name,
+      run: async () => {
+        await run(await makeAdapter());
+      }
+    };
+  }
+  async function loadOrThrow(adapter, id) {
+    const thread = await adapter.loadThread(id);
+    assert(thread !== null, `loadThread('${id}') returned null for a thread that was created`);
+    return thread;
+  }
+  return [
+    define("createThread then listThreads returns the thread with empty defaults", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      const threads = await a.listThreads();
+      const found = threads.filter((t) => t.id === id);
+      assert(found.length === 1, `listThreads returned ${found.length} threads for one create`);
+      const thread = found[0];
+      assert(thread !== void 0, "listThreads entry was undefined");
+      assert(thread.messages.length === 0, "a new thread must start with no messages");
+      assert(thread.outcome === null, "a new thread's outcome must be null");
+      assert(thread.status === "pending", `a new thread's status must be 'pending'`);
+      assert(thread.read === false, "a new thread must be unread");
+      assert(typeof thread.createdAt === "number", "createdAt must be a number");
+      assert(typeof thread.updatedAt === "number", "updatedAt must be a number");
+    }),
+    define("createThread persists meta", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id, meta: { source: "contract" } });
+      const thread = await loadOrThrow(a, id);
+      assert(thread.meta?.["source"] === "contract", "meta did not round-trip");
+    }),
+    define("loadThread returns null for an unknown id", async (a) => {
+      const thread = await a.loadThread(crypto.randomUUID());
+      assert(thread === null, "loadThread must return null (not throw, not undefined) when absent");
+    }),
+    define("appendMessage is idempotent on message.id", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      const msg = message("contract-msg-1");
+      await a.appendMessage({ threadId: id, message: msg });
+      await a.appendMessage({ threadId: id, message: msg });
+      const thread = await loadOrThrow(a, id);
+      assert(
+        thread.messages.length === 1,
+        `appending the same message.id twice produced ${thread.messages.length} rows \u2014 the id is the only idempotency key`
+      );
+      assert(thread.messages[0]?.id === "contract-msg-1", "the retained message has the wrong id");
+    }),
+    define("appendMessage preserves order for distinct ids", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.appendMessage({ threadId: id, message: message("contract-msg-1") });
+      await a.appendMessage({ threadId: id, message: message("contract-msg-2") });
+      const thread = await loadOrThrow(a, id);
+      assert(
+        thread.messages.map((m) => m.id).join(",") === "contract-msg-1,contract-msg-2",
+        "messages must read back oldest-first in append order"
+      );
+    }),
+    define("setStatus round-trips", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.setStatus({ threadId: id, status: "streaming" });
+      assert((await loadOrThrow(a, id)).status === "streaming", "status did not become 'streaming'");
+      await a.setStatus({ threadId: id, status: "error" });
+      assert((await loadOrThrow(a, id)).status === "error", "status did not become 'error'");
+    }),
+    define("setOutcome round-trips", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      const outcome = { title: "Title", summary: "Summary", status: "done" };
+      await a.setOutcome({ threadId: id, outcome });
+      const thread = await loadOrThrow(a, id);
+      assert(thread.outcome?.title === "Title", "outcome.title did not round-trip");
+      assert(thread.outcome?.summary === "Summary", "outcome.summary did not round-trip");
+      assert(thread.outcome?.status === "done", "outcome.status did not round-trip");
+    }),
+    define("setResumeToken round-trips and clears with undefined", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.setResumeToken({ threadId: id, token: "tok-1" });
+      assert((await loadOrThrow(a, id)).resumeToken === "tok-1", "resumeToken did not round-trip");
+      await a.setResumeToken({ threadId: id, token: void 0 });
+      assert(
+        (await loadOrThrow(a, id)).resumeToken === void 0,
+        "setResumeToken(undefined) must CLEAR the token"
+      );
+    }),
+    define("markRead marks the thread read", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      assert((await loadOrThrow(a, id)).read === false, "a new thread must start unread");
+      await a.markRead(id);
+      assert((await loadOrThrow(a, id)).read === true, "markRead did not set read");
+    }),
+    define("listThreads reflects a write that has already resolved", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.appendMessage({ threadId: id, message: message("contract-msg-raw") });
+      await a.setStatus({ threadId: id, status: "streaming" });
+      const found = (await a.listThreads()).find((t) => t.id === id);
+      assert(found !== void 0, "listThreads omitted a thread created before the call");
+      assert(
+        found.status === "streaming",
+        "listThreads returned a STALE status \u2014 a list started after a write resolves must reflect it"
+      );
+      assert(
+        found.messages.length === 1,
+        `listThreads returned a STALE message list (${found.messages.length} rows) \u2014 a list started after a write resolves must reflect it`
+      );
+    }),
+    define(
+      "dependent writes issued straight after createThread resolves are honoured",
+      async (a) => {
+        const id = crypto.randomUUID();
+        await a.createThread({ id });
+        await a.markRead(id);
+        await a.appendMessage({ threadId: id, message: message("contract-msg-dep") });
+        await a.setStatus({ threadId: id, status: "streaming" });
+        const thread = await loadOrThrow(a, id);
+        assert(thread.read === true, "markRead did not apply to a just-created thread");
+        assert(
+          thread.messages.length === 1,
+          `appendMessage did not apply to a just-created thread (${thread.messages.length} rows)`
+        );
+        assert(thread.status === "streaming", "setStatus did not apply to a just-created thread");
+      }
+    ),
+    define("removeThread removes the thread", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.removeThread(id);
+      assert(await a.loadThread(id).then((t) => t === null), "loadThread must be null after remove");
+      const threads = await a.listThreads();
+      assert(!threads.some((t) => t.id === id), "listThreads still contains the removed thread");
+    }),
+    define("removeThread of an unknown id does not throw", async (a) => {
+      await a.removeThread(crypto.randomUUID());
+    })
+  ];
+}
+export {
+  createAdapterThreadsStore,
+  threadsStoreAdapterContract
+};

package/dist/agent/adapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.test.d.ts.map

package/dist/agent/adapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.test.d.ts","sourceRoot":"","sources":["../../src/agent/adapter.test.ts"],"names":[],"mappings":""}

package/dist/agent/ai-sdk-transport.d.ts

@@ -1,54 +1,5 @@
-/**
- * aiSdkTransport — an AgentTransport backed by Vercel AI SDK's native streaming + resumption
- * primitives (the `ai` npm package). This is the RECOMMENDED DEFAULT transport for LLM chat use
- * cases — edenTransport remains the zero-extra-dependency alternative (see agent/rules/basalt-agent.md).
- *
- * OPTIONAL PEER: `ai` is not a required dependency. Importing 'basalt-ui/agent' (and calling this
- * factory) does NOT eagerly resolve it — the package is loaded via a memoized dynamic import()
- * only when the first stream()/resume() call actually runs, mirroring the lazy-optional-peer
- * contract used by BasaltStickToBottom. Unlike that, there is no meaningful "plain text" fallback
- * for a missing transport: if 'ai' is not installed, the dynamic import
- * rejects and the error propagates through the async generator to the consumer's EXISTING error
- * handling (useAgentStream sets status: 'error'; useAgentThreadRuns falls back to its
- * onFailureStatus) — no separate crash path is introduced.
- *
- * Install the optional peer:
- *   bun add ai
- *
- * WHY DIFFING IS NEEDED: AI SDK's `readUIMessageStream` yields the FULL accumulated `UIMessage`
- * snapshot (a growing `parts` array, with existing parts' content growing in place) on every
- * update — it is not itself a delta stream. basalt-ui's whole part-accumulation model
- * (useAgentStream / useAgentThreadRuns, and every consumer's own coalescing) is delta-based: many
- * small parts merged at render time. This module diffs consecutive snapshots and yields only the
- * new deltas as AgentParts, so nothing is double-rendered.
- *
- * CHAT ID BINDING: AI SDK's convention is that the chat id is known client-side before the
- * request (unlike a river/server-minted id) — `aiSdkTransport(options)` mints ONE stable chat id
- * at construction time, so the returned object is immediately usable with useAgentStream (a single
- * ongoing conversation). `.forThread(threadId)` returns a transport bound to an arbitrary
- * caller-supplied id instead — pass a basalt-ui thread id here to plug into
- * useAgentThreadRuns's per-thread transport-factory form, so a thread's turns (and its mount-time
- * resume) share one continuous AI SDK chat session:
- *
- * @example
- * import { useAgentStream, aiSdkTransport } from 'basalt-ui/agent'
- *
- * const transport = aiSdkTransport({ api: '/api/chat' })
- * const { parts, status, send } = useAgentStream({ transport })
- *
- * @example
- * import { useAgentThreadRuns, aiSdkTransport, createThreadsStore, heuristicOutcome } from 'basalt-ui/agent'
- *
- * const useThreads = createThreadsStore({ key: 'main-threads', version: 1 })
- * const transport = aiSdkTransport({ api: '/api/chat' })
- * const { runs, start } = useAgentThreadRuns({
- *   transport: (threadId) => transport.forThread(threadId),
- *   store: useThreads(),
- *   resolveOutcome: heuristicOutcome,
- * })
- */
 import type { AgentPart } from './parts.js';
-import type { AgentTransport } from './transport.js';
+import type { ResumableAgentTransport } from './transport.js';
 export type AiSdkTransportOptions = {
     /** The API URL AI SDK's transport POSTs new turns to and GETs reconnects from. */
     readonly api: string;
@@ -62,13 +13,13 @@ export type AiSdkTransportOptions = {
      */
     readonly fetch?: typeof globalThis.fetch;
 };
-export type AiSdkTransport<TPart = AgentPart> = AgentTransport<TPart, string> & {
+export type AiSdkTransport<TPart = AgentPart> = ResumableAgentTransport<TPart, string> & {
     /**
      * Returns an AgentTransport bound to a stable chat id (e.g. a basalt-ui thread id) instead of
      * this transport's own fixed one. Use this for useAgentThreadRuns's per-thread transport-factory
      * form so each thread's turns share one continuous AI SDK chat session.
      */
-    readonly forThread: (chatId: string) => AgentTransport<TPart, string>;
+    readonly forThread: (chatId: string) => ResumableAgentTransport<TPart, string>;
 };
 /**
  * Wraps AI SDK's `DefaultChatTransport` + `readUIMessageStream` into an AgentTransport.

package/dist/agent/ai-sdk-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-sdk-transport.d.ts","sourceRoot":"","sources":["../../src/agent/ai-sdk-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,EAAE,SAAS,EAA4B,MAAM,SAAS,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAYjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,kFAAkF;IAClF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAA;IACnD,oFAAoF;IACpF,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IACzC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;CACzC,CAAA;AAID,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG;IAC9E;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CACtE,CAAA;AA8ID;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,GAAG,SAAS,EAC9C,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,KAAK,CAAC,CAuCvB"}
+{"version":3,"file":"ai-sdk-transport.d.ts","sourceRoot":"","sources":["../../src/agent/ai-sdk-transport.ts"],"names":[],"mappings":"AAmDA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAmB1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,kFAAkF;IAClF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAA;IACnD,oFAAoF;IACpF,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IACzC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;CACzC,CAAA;AAID,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG;IACvF;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CAC/E,CAAA;AAwRD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,GAAG,SAAS,EAC9C,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,KAAK,CAAC,CA6CvB"}