basalt-ui 1.10.0 → 1.11.0

package/AGENTS.md

@@ -22,8 +22,8 @@ Toolchain: Bun runtime, oxlint + oxfmt, conventional commits (empty scope), `mas
 | `basalt-ui/data`            | mantine-coupled | Convenience barrel pulling both TanStack Table + Virtual peer groups: BasaltDataTable, BasaltVirtualList (Mantine-rendered) — prefer ./data/table or ./data/virtual for per-feature opt-in                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `basalt-ui/data/table`      | mantine-coupled | BasaltDataTable: a sortable data table over TanStack Table, rendered with Mantine (Mantine-rendered)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `basalt-ui/data/virtual`    | mantine-coupled | BasaltVirtualList: a windowed virtual list over TanStack Virtual, rendered with Mantine (Mantine-rendered)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `basalt-ui/agent`           | headless        | Headless streaming-chat layer: useAgentStream, aiSdkTransport (recommended default) + edenTransport, PartList, plus the multi-thread createThreadsStore + useAgentThreadRuns + outcome-resolver seam (Mantine-free)                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `basalt-ui/agent-chat`      | mantine-coupled | Mantine-styled thread-chat components over basalt-ui/agent: ThreadWorkspace, ThreadFeed, ThreadOutcomeCard, ThreadDetailPanel, Composer, ThreadTranscript, threadPartRenderers (Mantine-coupled). remend and motion are required, not optional — ThreadTranscript imports content/markdown.tsx (remend eagerly), and ThreadFeed/ThreadDetailPanel import motion/react eagerly, so this subpath fails to resolve without both installed even though peerDependenciesMeta marks them optional (npm has no per-subpath optionality).                                                                                   |
+| `basalt-ui/agent`           | headless        | Headless streaming-chat layer: useAgentStream, aiSdkTransport (recommended default) + edenTransport, isResumable/ResumableAgentTransport (stream-resumption seam), PartList, coalesceParts, the ForeignPart/definePartRenderers/narrowAgentPart open part-registry seam, plus the multi-thread createThreadsStore + useAgentThreadRuns + outcome-resolver seam (Mantine-free)                                                                                                                                                                                                                                       |
+| `basalt-ui/agent-chat`      | mantine-coupled | Mantine-styled thread-chat components over basalt-ui/agent: ThreadWorkspace, ThreadFeed, ThreadOutcomeCard, ThreadDetailPanel, Composer, ThreadTranscript (open part-renderer registry via its renderers/fallbackRenderer props), threadPartRenderers, ToolChip (Mantine-coupled). remend and motion are required, not optional — ThreadTranscript imports content/markdown.tsx (remend eagerly), and ThreadFeed/ThreadDetailPanel import motion/react eagerly, so this subpath fails to resolve without both installed even though peerDependenciesMeta marks them optional (npm has no per-subpath optionality).  |
 | `basalt-ui/content`         | mantine-coupled | Prose (article/chat typography), CodeBlock (shiki, optional peer), Callout, TableOfContents, ReadingProgress, Markdown (react-markdown + remark-gfm, optional peers, streaming-aware), MermaidDiagram (beautiful-mermaid, optional peer), mdxComponents/createMdxComponents, ArticleLayout (docs-page frame), ArticleCard/ArticleGrid (overview cards), Article model (sortArticles/filterArticles/formatArticleDate), ArticleFilterBar (category/tags filter UI), toArticleActions (Spotlight projector, @mantine/spotlight type-only), GuideLink/GuideDrawer (contextual-help drawer) — the content/prose surface |
 | `basalt-ui/state`           | headless        | createPersistedState (versioned localStorage) + useOnlineStatus — Mantine-free state primitives                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `basalt-ui/connectivity`    | mantine-coupled | ConnectivityProvider (aggregates browser online/offline, React Query onlineManager, SSE, and health-check pings into one status), useConnectivity, and ConnectivityIndicator — auto-mounted by BasaltProvider                                                                                                                                                                                                                                                                                                                                                                                                       |

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+# [1.11.0](https://github.com/jkrumm/basalt-ui/compare/v1.10.0...v1.11.0) (2026-08-03)
+
+
+### Features
+
+* give every part a stable id and mirror v7's real tool lifecycle ([d63aac3](https://github.com/jkrumm/basalt-ui/commit/d63aac3267d2322dfd027ba9b78e730eeec95d30))
+* make the transcript addressable, open, and honest about how a turn ended ([f153107](https://github.com/jkrumm/basalt-ui/commit/f1531077b411517226d2f349970677951d95bd59))
+* promote the shade-index guard out of its grace period ([e6a7bf9](https://github.com/jkrumm/basalt-ui/commit/e6a7bf919a1c28246157f918b5462311b37bc192))
+* prove the transcript layer from outside the package boundary ([52bd6d2](https://github.com/jkrumm/basalt-ui/commit/52bd6d2965e780d9d11008c6c449120285983c76))
+
 # [1.10.0](https://github.com/jkrumm/basalt-ui/compare/v1.9.0...v1.10.0) (2026-08-02)
 
 

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"}

package/dist/agent/ai-sdk-transport.js

@@ -1,3 +1,5 @@
+import { assertNever } from "../register.js";
+import { TERMINAL_TOOL_STATES } from "./parts.js";
 function createAiSdkResolver(options) {
   let resolved;
   return function resolveAiSdk() {
@@ -15,55 +17,133 @@ function createAiSdkResolver(options) {
     return resolved;
   };
 }
-function diffPart(prevPart, currPart) {
+function diffPart(chatId, index, prevPart, currPart, toolStartTimes) {
   switch (currPart.type) {
     case "text": {
       const prevText = prevPart?.type === "text" ? prevPart.text : "";
       const delta = currPart.text.slice(prevText.length);
-      return delta.length === 0 ? [] : [{ type: "text", text: delta }];
+      return delta.length === 0 ? [] : [{ id: `${chatId}#${index}`, type: "text", text: delta, offset: prevText.length }];
     }
     case "reasoning": {
       const prevText = prevPart?.type === "reasoning" ? prevPart.text : "";
       const delta = currPart.text.slice(prevText.length);
-      return delta.length === 0 ? [] : [{ type: "reasoning", text: delta }];
+      return delta.length === 0 ? [] : [{ id: `${chatId}#${index}`, type: "reasoning", text: delta, offset: prevText.length }];
     }
     case "source-url": {
       if (prevPart !== void 0) return [];
-      const source = { type: "source", url: currPart.url };
+      const source = { id: `${chatId}#${index}`, type: "source", url: currPart.url };
       return [currPart.title !== void 0 ? { ...source, title: currPart.title } : source];
     }
     default:
-      return currPart.type.startsWith("tool-") ? diffToolPart(prevPart, currPart) : [];
+      return isToolLikePart(currPart) ? diffToolPart(prevPart, currPart, toolStartTimes) : [];
   }
 }
-function diffToolPart(prevPart, currPart) {
-  const curr = currPart;
-  if (curr.state === "input-streaming") return [];
-  const prev = prevPart !== void 0 && prevPart.type === currPart.type ? prevPart : void 0;
-  if (prev?.state === curr.state) return [];
-  const toolName = curr.type.slice("tool-".length);
+function isToolLikePart(part) {
+  return part.type === "dynamic-tool" || part.type.startsWith("tool-");
+}
+function deriveToolName(part) {
+  return part.type === "dynamic-tool" ? part.toolName : part.type.split("-").slice(1).join("-");
+}
+function outputSnapshot(part) {
+  return part.state === "output-available" ? { output: part.output, preliminary: part.preliminary } : void 0;
+}
+function isSameToolState(prev, curr) {
+  if (prev.state !== curr.state) return false;
+  const prevOutput = outputSnapshot(prev);
+  const currOutput = outputSnapshot(curr);
+  if (prevOutput === void 0 || currOutput === void 0) return true;
+  return JSON.stringify(prevOutput.output) === JSON.stringify(currOutput.output) && prevOutput.preliminary === currOutput.preliminary;
+}
+function diffToolPart(prevPart, currPart, toolStartTimes) {
+  if (!toolStartTimes.has(currPart.toolCallId)) {
+    toolStartTimes.set(currPart.toolCallId, Date.now());
+  }
+  const prev = prevPart !== void 0 && isToolLikePart(prevPart) ? prevPart : void 0;
+  if (prev !== void 0 && isSameToolState(prev, currPart)) return [];
+  const settled = TERMINAL_TOOL_STATES.includes(currPart.state);
+  const durationMs = settled ? Date.now() - (toolStartTimes.get(currPart.toolCallId) ?? Date.now()) : void 0;
   const base = {
+    id: `tool#${currPart.toolCallId}`,
     type: "tool",
-    toolName,
-    toolCallId: curr.toolCallId,
-    input: curr.input
+    toolCallId: currPart.toolCallId,
+    toolName: deriveToolName(currPart),
+    ...currPart.providerExecuted !== void 0 ? { providerExecuted: currPart.providerExecuted } : {},
+    ...durationMs !== void 0 ? { durationMs } : {}
   };
-  if (curr.state === "output-available") return [{ ...base, output: curr.output }];
-  if (curr.state === "output-error") return [{ ...base, output: { error: curr.errorText } }];
-  return [base];
+  switch (currPart.state) {
+    case "input-streaming":
+      return [
+        {
+          ...base,
+          state: "input-streaming",
+          ...currPart.input !== void 0 ? { input: currPart.input } : {}
+        }
+      ];
+    case "input-available":
+      return [{ ...base, state: "input-available", input: currPart.input }];
+    case "approval-requested":
+      return [
+        {
+          ...base,
+          state: "approval-requested",
+          input: currPart.input,
+          approval: currPart.approval
+        }
+      ];
+    case "approval-responded":
+      return [
+        {
+          ...base,
+          state: "approval-responded",
+          input: currPart.input,
+          approval: currPart.approval
+        }
+      ];
+    case "output-available":
+      return [
+        {
+          ...base,
+          state: "output-available",
+          input: currPart.input,
+          output: currPart.output,
+          ...currPart.preliminary !== void 0 ? { preliminary: currPart.preliminary } : {},
+          ...currPart.approval !== void 0 ? { approval: currPart.approval } : {}
+        }
+      ];
+    case "output-error": {
+      const rawInput = currPart.type === "dynamic-tool" ? void 0 : currPart.rawInput;
+      return [
+        {
+          ...base,
+          state: "output-error",
+          ...currPart.input !== void 0 ? { input: currPart.input } : {},
+          errorText: currPart.errorText,
+          ...rawInput !== void 0 ? { rawInput } : {},
+          ...currPart.approval !== void 0 ? { approval: currPart.approval } : {}
+        }
+      ];
+    }
+    case "output-denied":
+      return [
+        { ...base, state: "output-denied", input: currPart.input, approval: currPart.approval }
+      ];
+    default:
+      return assertNever(currPart);
+  }
 }
-function diffMessage(prev, curr) {
+function diffMessage(chatId, prev, curr, toolStartTimes) {
   const deltas = [];
   curr.parts.forEach((part, i) => {
-    deltas.push(...diffPart(prev?.parts[i], part));
+    deltas.push(...diffPart(chatId, i, prev?.parts[i], part, toolStartTimes));
   });
   return deltas;
 }
-async function* diffChunkStream(chunkStream, readStream, signal) {
+async function* diffChunkStream(chatId, chunkStream, readStream, signal) {
   let prev;
+  const toolStartTimes = /* @__PURE__ */ new Map();
   for await (const curr of readStream({ stream: chunkStream })) {
     if (signal?.aborted) return;
-    for (const part of diffMessage(prev, curr)) {
+    for (const part of diffMessage(chatId, prev, curr, toolStartTimes)) {
       yield part;
     }
     prev = curr;
@@ -73,8 +153,12 @@ function aiSdkTransport(options) {
   const resolveAiSdk = createAiSdkResolver(options);
   function makeTransport(chatId) {
     return {
+      // Every text/reasoning delta this transport emits carries an authoritative `offset` (see
+      // diffPart), so a replayed run rewrites in place instead of duplicating — the literal
+      // condition this assertion stands for.
+      idempotentReplay: true,
       async *stream(input, signal) {
-        yield { type: "start", runId: chatId, resumeToken: chatId };
+        yield { id: `${chatId}#start`, type: "start", runId: chatId, resumeToken: chatId };
         const { httpTransport, readUIMessageStream: readStream } = await resolveAiSdk();
         const userMessage = {
           id: crypto.randomUUID(),
@@ -88,13 +172,13 @@ function aiSdkTransport(options) {
           messageId: void 0,
           abortSignal: signal
         });
-        yield* diffChunkStream(chunkStream, readStream, signal);
+        yield* diffChunkStream(chatId, chunkStream, readStream, signal);
       },
       async *resume(resumeToken, signal) {
         const { httpTransport, readUIMessageStream: readStream } = await resolveAiSdk();
         const chunkStream = await httpTransport.reconnectToStream({ chatId: resumeToken });
         if (chunkStream === null) return;
-        yield* diffChunkStream(chunkStream, readStream, signal);
+        yield* diffChunkStream(resumeToken, chunkStream, readStream, signal);
       }
     };
   }

package/dist/agent/coalesce.d.ts

@@ -0,0 +1,26 @@
+/**
+ * coalesceParts — merges a rendered-turn's parts array for display.
+ *
+ * Merges consecutive `text`+`text` and `reasoning`+`reasoning` parts (streamed answers arrive as
+ * many small fragments; this renders a streaming reply as one flowing block instead of a stack of
+ * fragments). Merges `tool` parts BY `toolCallId` regardless of adjacency — the AI SDK re-emits a
+ * tool call's `input-available` then `output-available` as two separate parts, not necessarily
+ * adjacent once other parts interleave; without this rule a UI renders two stacked tool blocks for
+ * one call. The later state always wins; the merged part keeps the position of its FIRST
+ * occurrence (stable ordering); and an `input` (or `toolName`) supplied by an earlier state
+ * survives a later state that omits it — `tool-output-available` carries only `output` on the
+ * wire, the SDK re-supplies `input` by reading it back off the stored invocation, and a merge that
+ * replaces wholesale rather than accumulating would lose it outright.
+ *
+ * `approval`-bearing responses can arrive without a usable `toolCallId` (the SDK resolves them by
+ * reverse lookup on `approval.id` instead) — this maintains an `approvalId -> toolCallId` side
+ * index while folding and routes such a part through it. A part resolvable by neither key is kept
+ * as-is rather than dropped; never silently discard a part.
+ *
+ * @example
+ * import { coalesceParts } from 'basalt-ui/agent'
+ * <PartList parts={coalesceParts(parts)} />
+ */
+import type { AgentPart } from './parts.js';
+export declare function coalesceParts<TPart extends AgentPart>(parts: readonly TPart[]): TPart[];
+//# sourceMappingURL=coalesce.d.ts.map

package/dist/agent/coalesce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../src/agent/coalesce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAyC,MAAM,SAAS,CAAA;AA+C/E,wBAAgB,aAAa,CAAC,KAAK,SAAS,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE,CA+CvF"}

package/dist/agent/coalesce.js

@@ -0,0 +1,69 @@
+function isTextLikeType(type) {
+  return type === "text" || type === "reasoning";
+}
+function resolveToolCallId(part, toolCallIdByApprovalId) {
+  if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) return part.toolCallId;
+  const approval = "approval" in part ? part.approval : void 0;
+  return approval !== void 0 ? toolCallIdByApprovalId.get(approval.id) : void 0;
+}
+function registerApprovalIndex(part, toolCallIdByApprovalId) {
+  const approval = "approval" in part ? part.approval : void 0;
+  if (approval === void 0) return;
+  if (typeof part.toolCallId !== "string" || part.toolCallId.length === 0) return;
+  toolCallIdByApprovalId.set(approval.id, part.toolCallId);
+}
+function mergeToolPart(existing, next) {
+  const existingInput = "input" in existing ? existing.input : void 0;
+  const nextInput = "input" in next ? next.input : void 0;
+  const input = nextInput !== void 0 ? nextInput : existingInput;
+  const toolName = next.toolName.length > 0 ? next.toolName : existing.toolName;
+  return {
+    ...existing,
+    ...next,
+    toolName,
+    ...input !== void 0 ? { input } : {}
+  };
+}
+function coalesceParts(parts) {
+  const out = [];
+  const toolIndexByCallId = /* @__PURE__ */ new Map();
+  const toolCallIdByApprovalId = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    if (isTextLikeType(part.type)) {
+      const last = out[out.length - 1];
+      if (last !== void 0 && last.type === part.type) {
+        const merged = {
+          ...part,
+          text: last.text + part.text
+        };
+        out[out.length - 1] = merged;
+        continue;
+      }
+      out.push(part);
+      continue;
+    }
+    if (part.type === "tool") {
+      const toolPart = part;
+      registerApprovalIndex(toolPart, toolCallIdByApprovalId);
+      const resolvedCallId = resolveToolCallId(toolPart, toolCallIdByApprovalId);
+      if (resolvedCallId === void 0) {
+        out.push(part);
+        continue;
+      }
+      const existingIndex = toolIndexByCallId.get(resolvedCallId);
+      if (existingIndex === void 0) {
+        toolIndexByCallId.set(resolvedCallId, out.length);
+        out.push(part);
+        continue;
+      }
+      const existing = out[existingIndex];
+      out[existingIndex] = mergeToolPart(existing, toolPart);
+      continue;
+    }
+    out.push(part);
+  }
+  return out;
+}
+export {
+  coalesceParts
+};

package/dist/agent/foreign.d.ts

@@ -0,0 +1,97 @@
+/**
+ * foreign.ts — the open half of the transcript's part-rendering registry.
+ *
+ * `AgentPart` (`./parts`) is a closed, exhaustively-switched union — adding a variant without
+ * updating every consuming switch is a tsc error (`PartList`'s `assertNever` gate). A transport
+ * that streams app-specific structured data (a chart spec, a progress ping) needs a part type
+ * `AgentPart` will never carry — closing the union around it would defeat the whole point of the
+ * gate. This file is the seam: `ForeignPart` describes what basalt does NOT know, `ConsumerPart`
+ * resolves the augmented union a consumer registers via `declare module 'basalt-ui'`, and
+ * `definePartRenderers` types an exhaustive renderer map against it. See
+ * `agent-chat/thread-message.tsx`'s three-step resolution order for how this plugs into
+ * `ThreadTranscript`: a consumer renderer wins first, `narrowAgentPart` routes the built-in six to
+ * `PartList`'s own exhaustive switch second, and `fallbackRenderer` catches anything left.
+ *
+ * @example
+ * // app-side: src/features/chat/parts.ts
+ * type ChartPart = { type: 'data-chart'; id: string; spec: ChartSpec }
+ * declare module 'basalt-ui' {
+ *   interface BasaltRegister { parts: ChartPart }
+ * }
+ * export const chatRenderers = definePartRenderers({
+ *   'data-chart': ({ part, settled }) => (settled ? <Chart spec={part.spec} /> : <ChartSkeleton />),
+ * })
+ */
+import type { ReactNode } from 'react';
+import type { BasaltRegister } from '../register.js';
+import type { ChatMessage } from './history.js';
+import type { AgentPart } from './parts.js';
+/** A part basalt does not know. NOT a member of AgentPart — the built-in union stays closed. */
+export type ForeignPart = {
+    readonly type: string;
+    readonly id: string;
+    readonly [k: string]: unknown;
+};
+/** What a transcript actually holds — basalt's own six variants plus anything a consumer registers. */
+export type TranscriptPart = AgentPart | ForeignPart;
+/** The consumer's registered foreign-part union, or `never` when un-augmented. */
+export type ConsumerPart = BasaltRegister extends {
+    parts: infer P extends ForeignPart;
+} ? P : never;
+/**
+ * Un-augmented: a loose string-keyed map (any renderer, any key — there is nothing to check
+ * against). Augmented: a MISSING key is a tsc error (`definePartRenderers` requires the full
+ * registered union), and each renderer's `part` is narrowed to exactly its variant. Same
+ * bound-check mechanism as `SeriesKey` (`register.ts:26-58`), applied to a union instead of a map.
+ *
+ * NOT caught: a STALE (extra, unregistered) key. `<const T extends Constraint>` inference does
+ * not excess-property-check an object-literal argument the way a direct assignment to a fixed
+ * target type would (verified against this repo's tsc — see
+ * `apps/playground/src/demo/agent-part-registry.type-guard.ts`'s Fixture 3) — an extra key
+ * compiles as dead code rather than erroring. Catching it would need an `Exact<T, Shape>`-style
+ * wrapper that departs from the `spec: T` "canonical token-factory contract" every other `defineX`
+ * in this codebase follows verbatim; that trade was left as a documented gap rather than a one-off
+ * factory shape.
+ */
+export type PartRenderers = [ConsumerPart] extends [never] ? Readonly<Record<string, PartRenderer<ForeignPart>>> : {
+    readonly [K in ConsumerPart['type']]: PartRenderer<Extract<ConsumerPart, {
+        type: K;
+    }>>;
+};
+/** Everything a foreign-part renderer needs beyond the part itself. */
+export type PartRenderContext<TPart = ForeignPart> = {
+    readonly part: TPart;
+    readonly messageId: string;
+    readonly partId: string;
+    /** false while this part belongs to the in-flight tail of a streaming turn. */
+    readonly settled: boolean;
+    readonly role: ChatMessage['role'];
+};
+export type PartRenderer<TPart = ForeignPart> = (ctx: PartRenderContext<TPart>) => ReactNode;
+/**
+ * Canonical const-generic factory (`packages/basalt-ui/CLAUDE.md`, "Canonical token-factory
+ * contract") — identity passthrough, exact-keyed return, no builder, no config bag. Mirrors
+ * `defineSeries` (`tokens/index.ts:648-650`) and `defineNotifications`
+ * (`notifications/define-notifications.ts:112-115`).
+ *
+ * @example
+ * const chatRenderers = definePartRenderers({
+ *   'data-chart': ({ part }) => <Chart spec={part.spec} />,
+ * })
+ */
+export declare function definePartRenderers<const T extends PartRenderers>(map: T): T;
+/**
+ * Returns `part` as an `AgentPart` when its `type` is one of the six built-in variants, else
+ * `null`. Deliberately NOT routed through `parseAgentPart`: that function is a VALIDATING parser
+ * for untrusted wire data — it checks every field a variant requires (`runId`, `toolCallId`,
+ * `approval`, ...) and would reject an already-well-typed in-memory `AgentPart` on shape grounds
+ * if it doesn't happen to match the wire representation byte-for-byte. `narrowAgentPart` is the
+ * cheap complement: a plain discriminator check on a value already known to be a `TranscriptPart`,
+ * used purely to route rendering — it trusts the caller's typing rather than re-validating it.
+ *
+ * @example
+ * const agentPart = narrowAgentPart(part)
+ * if (agentPart !== null) return <PartList parts={[agentPart]} />
+ */
+export declare function narrowAgentPart(part: TranscriptPart): AgentPart | null;
+//# sourceMappingURL=foreign.d.ts.map

package/dist/agent/foreign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign.d.ts","sourceRoot":"","sources":["../../src/agent/foreign.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC,gGAAgG;AAChG,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAC9B,CAAA;AAED,uGAAuG;AACvG,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,CAAA;AAuBpD,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,cAAc,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC,SAAS,WAAW,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAA;AAIpG;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,GACtD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,GACnD;IAAE,QAAQ,EAAE,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,YAAY,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC;CAAE,CAAA;AAE9F,uEAAuE;AACvE,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,WAAW,IAAI;IACnD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,YAAY,CAAC,KAAK,GAAG,WAAW,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,KAAK,CAAC,KAAK,SAAS,CAAA;AAE5F;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,CAAC,SAAS,aAAa,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE5E;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI,CAEtE"}

package/dist/agent/foreign.js

@@ -0,0 +1,18 @@
+function definePartRenderers(map) {
+  return map;
+}
+const AGENT_PART_TYPES = /* @__PURE__ */ new Set([
+  "start",
+  "text",
+  "reasoning",
+  "tool",
+  "source",
+  "error"
+]);
+function narrowAgentPart(part) {
+  return AGENT_PART_TYPES.has(part.type) ? part : null;
+}
+export {
+  definePartRenderers,
+  narrowAgentPart
+};

package/dist/agent/history.d.ts

@@ -16,6 +16,8 @@ export type ChatMessage<TPart = AgentPart> = {
     readonly role: 'user' | 'assistant';
     readonly parts: TPart[];
     readonly createdAt: number;
+    /** How the turn ended. Absent on user messages and on pre-1.11 persisted assistant messages. */
+    readonly finish?: 'complete' | 'stopped' | 'error';
 };
 export type ChatHistoryStoreOptions = {
     /** localStorage key (namespaced as `basalt:<key>`). Stable — changes key lose history. */

package/dist/agent/history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/agent/history.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,SAAS,IAAI;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,CAAA;AAID,MAAM,MAAM,uBAAuB,GAAG;IACpC,0FAA0F;IAC1F,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,gBAAgB,CAAC,KAAK,GAAG,SAAS,IAAI;IAChD,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAA;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;IACtD,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,GAAG,SAAS,EACtD,IAAI,EAAE,uBAAuB,GAC5B,MAAM,gBAAgB,CAAC,KAAK,CAAC,CAoC/B"}
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/agent/history.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,SAAS,IAAI;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAA;CACnD,CAAA;AAID,MAAM,MAAM,uBAAuB,GAAG;IACpC,0FAA0F;IAC1F,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,gBAAgB,CAAC,KAAK,GAAG,SAAS,IAAI;IAChD,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAA;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;IACtD,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,GAAG,SAAS,EACtD,IAAI,EAAE,uBAAuB,GAC5B,MAAM,gBAAgB,CAAC,KAAK,CAAC,CAoC/B"}

package/dist/agent/id.d.ts

@@ -0,0 +1,35 @@
+/**
+ * withPartIds — stamps a stable id onto every draft part arriving without one.
+ *
+ * A transport is allowed to yield a draft (`AgentPartDraft` — `id` optional); this wraps such a
+ * generator and normalizes it into a fully-identified stream, minting `${runId}#${n}` for any
+ * part that arrives without an `id`. A part that already carries an id passes through untouched
+ * (idempotent) and does not advance the counter.
+ *
+ * NOT a replay-convergence mechanism. The minted id is a bare per-call sequence number with no
+ * relationship to content or offset — it identifies "the nth id-less part THIS invocation saw",
+ * nothing more. Calling `withPartIds` again over a resumed/replayed stream restarts its counter at
+ * 0, so the resumed stream's first delta mints the SAME id as the original run's first delta
+ * (`${runId}#0`) regardless of whether it carries the same content — if the resumed transport
+ * re-sends the full text as one chunk while the original sent it as several deltas, mergePart's
+ * tail-splice will corrupt the accumulated text rather than converge it. A transport that needs
+ * genuine replay convergence (one asserting `ResumableAgentTransport`'s `idempotentReplay: true`)
+ * MUST mint its own content-stable ids — e.g. `aiSdkTransport`'s `${chatId}#${index}` /
+ * `tool#${toolCallId}` — and must not rely on this helper for that guarantee. Combining
+ * `withPartIds` with a transport that asserts `idempotentReplay: true` is only safe when that
+ * transport already mints stable ids itself, in which case every part already carries an `id` and
+ * `withPartIds` is a no-op passthrough (see the idempotent behavior above) — it is never the thing
+ * providing replay safety.
+ *
+ * @example
+ * const identified = withPartIds(runId, transport.stream(input, signal))
+ * for await (const part of identified) {
+ *   // part.id is always defined here
+ * }
+ */
+export declare function withPartIds<TPart extends {
+    id?: string;
+}>(runId: string, source: AsyncGenerator<TPart>): AsyncGenerator<TPart & {
+    id: string;
+}>;
+//# sourceMappingURL=id.d.ts.map

package/dist/agent/id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../src/agent/id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,WAAW,CAAC,KAAK,SAAS;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9D,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,GAC5B,cAAc,CAAC,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAUxC"}

package/dist/agent/id.js

@@ -0,0 +1,14 @@
+async function* withPartIds(runId, source) {
+  let n = 0;
+  for await (const part of source) {
+    if (part.id !== void 0) {
+      yield part;
+      continue;
+    }
+    yield { ...part, id: `${runId}#${n}` };
+    n += 1;
+  }
+}
+export {
+  withPartIds
+};

package/dist/agent/index.d.ts

@@ -30,10 +30,15 @@
  *   )
  * }
  */
-export type { AgentPart, StartPart, TextPart, ReasoningPart, ToolCallPart, SourcePart, ErrorPart, } from './parts.js';
-export { parseAgentPart, isStartPart } from './parts.js';
-export type { AgentTransport } from './transport.js';
-export { edenTransport } from './transport.js';
+export type { AgentPart, AgentPartDraft, Drafted, StartPart, TextPart, ReasoningPart, ToolCallPart, ToolCallState, SourcePart, ErrorPart, } from './parts.js';
+export { parseAgentPart, isStartPart, isToolCallSettled, TERMINAL_TOOL_STATES } from './parts.js';
+export { mergePart } from './merge.js';
+export { withPartIds } from './id.js';
+export { coalesceParts } from './coalesce.js';
+export { definePartRenderers, narrowAgentPart } from './foreign.js';
+export type { ForeignPart, TranscriptPart, ConsumerPart, PartRenderers, PartRenderContext, PartRenderer, } from './foreign.js';
+export type { AgentTransport, ResumableAgentTransport } from './transport.js';
+export { edenTransport, isResumable } from './transport.js';
 export { aiSdkTransport } from './ai-sdk-transport.js';
 export type { AiSdkTransport, AiSdkTransportOptions } from './ai-sdk-transport.js';
 export { useAgentStream } from './use-agent-stream.js';

package/dist/agent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,YAAY,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,UAAU,EACV,SAAS,GACV,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAGrD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAG3C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAG/E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAG5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,yBAAyB,CAAA;AAGhC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,YAAY,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAGjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAClD,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AAGvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC7C,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAG5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,YAAY,EACV,SAAS,EACT,cAAc,EACd,OAAO,EACP,SAAS,EACT,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,aAAa,EACb,UAAU,EACV,SAAS,GACV,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAG9F,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGnC,OAAO,EAAE,WAAW,EAAE,MAAM,MAAM,CAAA;AAGlC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAG1C,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAChE,YAAY,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,WAAW,CAAA;AAGlB,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGxD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAG/E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAG5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,yBAAyB,CAAA;AAGhC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,YAAY,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAGjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAClD,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AAGvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC7C,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAG5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}