@aparte/core 0.3.0-alpha.0 → 0.5.0-alpha.0

package/dist/{index-CW2BCAqn.js → index-Dn7TH14G.js}

@@ -939,6 +939,18 @@ const defaultSanitizer = (html) => {
   sanitizeChildren(doc.body, container, doc);
   return container.innerHTML;
 };
+const DEFAULT_BUBBLE_ACTIONS = {
+  copy: true,
+  retry: false,
+  edit: false,
+  feedback: false,
+  info: false
+};
+const DEFAULT_HOST_HANDLERS = {
+  attachmentPreview: false,
+  terminalRun: false,
+  artifactRedownload: false
+};
 class AparteConfigClass {
   _markdownProvider;
   _streamingMarkdownProvider;
@@ -978,8 +990,11 @@ class AparteConfigClass {
   // Tool Registry
   _tools = /* @__PURE__ */ new Map();
   _toolRenderers = /* @__PURE__ */ new Map();
-  // Bubble Actions
-  _bubbleActionsConfig = { copy: true, retry: true, edit: true, feedback: false };
+  // Host handlers — what the app declares it can actually complete.
+  _hostHandlers = { ...DEFAULT_HOST_HANDLERS };
+  // Bubble Actions — DEFAULT_BUBBLE_ACTIONS is the single source of truth
+  // (init here, restored by reset(), and the fallback in getBubbleActions()).
+  _bubbleActionsConfig = { ...DEFAULT_BUBBLE_ACTIONS };
   // ─────────────────────────────────────────────────────────────────────────
   // Provider Setters (Dependency Injection)
   // ─────────────────────────────────────────────────────────────────────────
@@ -1021,12 +1036,13 @@ class AparteConfigClass {
   }
   /**
    * Configure which action buttons appear in message bubbles.
-   * Unset keys keep their defaults (copy=true, retry=true, edit=true, feedback=false).
+   * Unset keys keep their defaults — see {@link DEFAULT_BUBBLE_ACTIONS}: `copy`
+   * only, because every other button needs a host to honor it.
    *
    * @example
-   * AparteConfig.setBubbleActions({ feedback: true })        // enable feedback, keep rest
-   * AparteConfig.setBubbleActions({ retry: false })          // disable retry only
-   * AparteConfig.setBubbleActions({ copy: false, retry: false, edit: false }) // hide all
+   * AparteConfig.setBubbleActions({ retry: true, edit: true }) // you run AparteClient
+   * AparteConfig.setBubbleActions({ feedback: true })          // you listen for aparte-feedback
+   * AparteConfig.setBubbleActions({ copy: false })             // hide everything
    * // Explicit per-role ordered sets (replace the flag defaults for that role):
    * AparteConfig.setBubbleActions({ user: ['edit', 'copy'], assistant: ['copy', 'thumbUp', 'thumbDown', 'retry'] })
    */
@@ -1034,13 +1050,33 @@ class AparteConfigClass {
     this._bubbleActionsConfig = { ...this._bubbleActionsConfig, ...config };
     this._notify();
   }
+  /**
+   * Declare which host-dependent affordances your app handles. Core renders the
+   * trigger only for the ones you claim — see {@link AparteHostHandlersConfig}.
+   *
+   * @example
+   * AparteConfig.setHostHandlers({ attachmentPreview: true, terminalRun: true });
+   */
+  setHostHandlers(config) {
+    this._hostHandlers = { ...this._hostHandlers, ...config };
+    this._notify();
+  }
+  /** Returns the resolved host-handler declarations (undeclared = false). */
+  getHostHandlers() {
+    return {
+      attachmentPreview: this._hostHandlers.attachmentPreview ?? DEFAULT_HOST_HANDLERS.attachmentPreview,
+      terminalRun: this._hostHandlers.terminalRun ?? DEFAULT_HOST_HANDLERS.terminalRun,
+      artifactRedownload: this._hostHandlers.artifactRedownload ?? DEFAULT_HOST_HANDLERS.artifactRedownload
+    };
+  }
   /** Returns the resolved bubble actions config (flag defaults applied; per-role sets passed through). */
   getBubbleActions() {
     return {
-      copy: this._bubbleActionsConfig.copy ?? true,
-      retry: this._bubbleActionsConfig.retry ?? true,
-      edit: this._bubbleActionsConfig.edit ?? true,
-      feedback: this._bubbleActionsConfig.feedback ?? false,
+      copy: this._bubbleActionsConfig.copy ?? DEFAULT_BUBBLE_ACTIONS.copy,
+      retry: this._bubbleActionsConfig.retry ?? DEFAULT_BUBBLE_ACTIONS.retry,
+      edit: this._bubbleActionsConfig.edit ?? DEFAULT_BUBBLE_ACTIONS.edit,
+      feedback: this._bubbleActionsConfig.feedback ?? DEFAULT_BUBBLE_ACTIONS.feedback,
+      info: this._bubbleActionsConfig.info ?? DEFAULT_BUBBLE_ACTIONS.info,
       user: this._bubbleActionsConfig.user,
       assistant: this._bubbleActionsConfig.assistant
     };
@@ -1165,13 +1201,24 @@ class AparteConfigClass {
     return this._artifactPreviewBuilder;
   }
   /**
-   * Get the current icon provider, or a proxy that falls back to DEFAULT_ICON_FALLBACKS
+   * The icon set as a **complete** provider: every name resolves, falling back
+   * to `DEFAULT_ICON_FALLBACKS` for anything the registered provider doesn't
+   * implement. Callers (bubble action bar, composer controls) can therefore
+   * invoke `icons.copy()` unconditionally.
+   *
+   * It used to hand back the registered provider verbatim, so a provider that
+   * implemented a subset — which `getIcon()` has always supported, and which
+   * the type now states — crashed every other icon with
+   * "icons.retry is not a function".
    */
   getIconProvider() {
-    if (this._iconProvider) return this._iconProvider;
-    return Object.fromEntries(
-      Object.entries(DEFAULT_ICON_FALLBACKS).map(([k, v]) => [k, () => v])
-    );
+    const registered = this._iconProvider;
+    const complete = {};
+    for (const name of Object.keys(DEFAULT_ICON_FALLBACKS)) {
+      const fn = registered?.[name];
+      complete[name] = fn ?? (() => DEFAULT_ICON_FALLBACKS[name]);
+    }
+    return complete;
   }
   /**
    * Set a custom avatar renderer. Lets framework consumers (Angular,
@@ -1296,9 +1343,8 @@ class AparteConfigClass {
    * Falls back to textual representation if no provider is set
    */
   getIcon(name) {
-    if (this._iconProvider && this._iconProvider[name]) {
-      return this._iconProvider[name]();
-    }
+    const icon = this._iconProvider?.[name];
+    if (icon) return icon();
     return DEFAULT_ICON_FALLBACKS[name];
   }
   /**
@@ -1671,7 +1717,8 @@ class AparteConfigClass {
     this._modelConfig = {};
     this._requireModelSelection = false;
     this._modelPreferenceProvider = void 0;
-    this._bubbleActionsConfig = { copy: true, retry: true, edit: true, feedback: false };
+    this._bubbleActionsConfig = { ...DEFAULT_BUBBLE_ACTIONS };
+    this._hostHandlers = { ...DEFAULT_HOST_HANDLERS };
     this._notify();
   }
   // ─────────────────────────────────────────────────────────────────────────
@@ -1808,10 +1855,23 @@ function findClosingFence(s) {
 }
 const renderers = /* @__PURE__ */ new Map();
 let styleElement = null;
+let defaultsInstalled = false;
+let defaultsDeclined = false;
 function registerSegmentRenderer(renderer) {
   renderers.set(renderer.type, renderer);
   injectRendererStyles();
 }
+function declineDefaultRenderers() {
+  defaultsDeclined = true;
+}
+function installDefaultRenderersOnce() {
+  if (defaultsInstalled || defaultsDeclined) return;
+  defaultsInstalled = true;
+  for (const renderer of DEFAULT_RENDERERS) {
+    if (!renderers.has(renderer.type)) renderers.set(renderer.type, renderer);
+  }
+  injectRendererStyles();
+}
 function unregisterSegmentRenderer(type) {
   renderers.delete(type);
 }
@@ -1943,7 +2003,7 @@ const terminalRenderer = {
                 </div>
                 <code class="terminal-command">${escapeHtml(segment.command || "")}</code>
                 <div class="terminal-actions">
-                    ${segment.isRunning ? `<span class="terminal-running"><span class="spinner"></span>${contextConfig().t("running")}</span>` : `<button class="terminal-run-btn" data-action="run" aria-label="${contextConfig().t("run")}" title="${contextConfig().t("run")}">${contextConfig().t("run")}</button>`}
+                    ${segment.isRunning ? `<span class="terminal-running"><span class="spinner"></span>${contextConfig().t("running")}</span>` : contextConfig().getHostHandlers().terminalRun ? `<button class="terminal-run-btn" data-action="run" aria-label="${contextConfig().t("run")}" title="${contextConfig().t("run")}">${contextConfig().t("run")}</button>` : ""}
                     <button class="terminal-copy-btn" data-action="copy" aria-label="${contextConfig().t("copy")}" title="${contextConfig().t("copy")}">
                         ${contextConfig().getIcon("copy")}
                     </button>
@@ -2201,16 +2261,8 @@ const pipelineWaitingRenderer = {
     `
 };
 function registerDefaultRenderers() {
-  registerSegmentRenderer(textRenderer);
-  registerSegmentRenderer(thinkingRenderer);
-  registerSegmentRenderer(codeRenderer);
-  registerSegmentRenderer(terminalRenderer);
-  registerSegmentRenderer(errorRenderer);
-  registerSegmentRenderer(progressRenderer);
-  registerSegmentRenderer(fileTreeRenderer);
-  registerSegmentRenderer(toolCallRenderer);
-  registerSegmentRenderer(artifactRenderer);
-  registerSegmentRenderer(pipelineWaitingRenderer);
+  defaultsInstalled = true;
+  for (const renderer of DEFAULT_RENDERERS) registerSegmentRenderer(renderer);
 }
 const PREVIEWABLE_KINDS = /* @__PURE__ */ new Set(["react", "html", "svg", "js", "css"]);
 const BINARY_FILE_KINDS = /* @__PURE__ */ new Set(["pdf", "xlsx", "docx"]);
@@ -2695,6 +2747,7 @@ function renderBinaryFileArtifact(segment, kind) {
   const title = segment.title?.trim() || labelForKind(kind);
   const iconLabel = FILE_ICON_LABEL[kind] ?? kind.toUpperCase();
   const isStreaming = !!segment.isStreaming;
+  const canRedownload = contextConfig().getHostHandlers().artifactRedownload;
   const cached = _binaryArtifactCache.get(segment.id);
   if (cached && !isStreaming) {
     const previewBody = cached.previewHtml ? contextConfig().sanitizeHtml(cached.previewHtml) : `<div class="aparte-art-file__preview-empty">Preview not available for ${escapeHtml(kind)} yet</div>`;
@@ -2710,7 +2763,7 @@ function renderBinaryFileArtifact(segment, kind) {
                         <div class="aparte-art-file__meta-sub" data-role="file-sub">${escapeHtml(formatBytes(cached.bytes))} · ${escapeHtml(kind.toUpperCase())}</div>
                     </div>
                     <div class="aparte-art-file__actions">
-                        <button type="button" class="aparte-art-file__btn aparte-art-file__btn--primary" data-action="download">Download</button>
+                        ${canRedownload ? '<button type="button" class="aparte-art-file__btn aparte-art-file__btn--primary" data-action="download">Download</button>' : ""}
                     </div>
                 </div>
                 <div class="aparte-art-file__body">
@@ -2736,7 +2789,7 @@ function renderBinaryFileArtifact(segment, kind) {
                     <div class="aparte-art-file__meta-sub" data-role="file-sub">${escapeHtml(subText)}</div>
                 </div>
                 <div class="aparte-art-file__actions">
-                    <button type="button" class="aparte-art-file__btn aparte-art-file__btn--primary" data-action="download" disabled>Download</button>
+                    ${canRedownload ? '<button type="button" class="aparte-art-file__btn aparte-art-file__btn--primary" data-action="download" disabled>Download</button>' : ""}
                 </div>
             </div>
             <div class="aparte-art-file__body">
@@ -3068,6 +3121,18 @@ function escapeClosingScriptTag(body) {
   }
   return out;
 }
+const DEFAULT_RENDERERS = [
+  textRenderer,
+  thinkingRenderer,
+  codeRenderer,
+  terminalRenderer,
+  errorRenderer,
+  progressRenderer,
+  fileTreeRenderer,
+  toolCallRenderer,
+  artifactRenderer,
+  pipelineWaitingRenderer
+];
 function populateBubbleFromMessage(bubble, message, siblingInfo) {
   if (message.segments && message.segments.length > 0) {
     const existing = bubble.getSegments?.() ?? [];
@@ -3319,6 +3384,19 @@ class ConversationManager {
     return text.trim() || "New Chat";
   }
 }
+function attachmentId() {
+  return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function filesToAttachments(files) {
+  return files.map((file) => ({
+    id: attachmentId(),
+    name: file.name,
+    type: file.type || "application/octet-stream",
+    url: URL.createObjectURL(file),
+    size: file.size,
+    blob: file
+  }));
+}
 class AparteConversationController {
   _binding;
   _options;
@@ -3363,16 +3441,7 @@ class AparteConversationController {
       if (targetId && targetId !== this._binding.hostId) return;
       const content = evt.detail?.content ?? "";
       const files = evt.detail?.files;
-      const attachments = files?.length ? files.map((f) => ({
-        id: typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`,
-        name: f.name,
-        type: f.type || "application/octet-stream",
-        url: URL.createObjectURL(f),
-        size: f.size,
-        // Carry the raw File so the storage adapter can persist it
-        // to its attachments table; reload reconstructs `url`.
-        blob: f
-      })) : void 0;
+      const attachments = files?.length ? filesToAttachments(files) : void 0;
       const userMsg = {
         id: typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`,
         role: "user",
@@ -3622,6 +3691,23 @@ class AparteChatHost {
   _pendingSiblings;
   /** Abort handle for an in-flight {@link streamTokens} loop. */
   _streamAbort;
+  /** Segment chunks written to the bubble, awaiting one coalesced state sync. */
+  /**
+   * Buffered segment text, per segment id, as `base + text` — an **absolute**
+   * target, never a delta.
+   *
+   * Why absolute: the immediate paint (`appendToSegment` below) writes through the
+   * viewport into the very segment object the framework list holds — they are the
+   * same object, handed to both by `addSegment`. A delta added at flush time would
+   * therefore land on content that already contains it, and every chunk came out
+   * doubled. `base` is captured before the paint, so whoever mutates the shared
+   * object in between cannot change the result.
+   */
+  _segmentBuffer = /* @__PURE__ */ new Map();
+  /** {@link streamTokens} text written to the bubble, awaiting the same sync. */
+  _tokenBuffer = null;
+  /** Handle of the scheduled coalesced sync, or null when none is pending. */
+  _flushHandle = null;
   _conversationId = null;
   _controller;
   _teardown = [];
@@ -3734,6 +3820,9 @@ class AparteChatHost {
   }
   /** Drop transient streaming state so a new conversation starts clean. */
   _beginConversationSwap() {
+    this._segmentBuffer.clear();
+    this._tokenBuffer = null;
+    this._flushStreamState();
     this.stopTokenStream();
     this._setStreamingId(null);
     this.binding.onTypingChange?.(false);
@@ -3755,12 +3844,14 @@ class AparteChatHost {
    * is the append-specific signal instead.
    */
   appendMessage(message) {
+    this._flushStreamState();
     if (message.role === "user") this._vp()?.setAutoScroll?.(true);
     this.binding.setMessages([...this.binding.getMessages(), message]);
     this.binding.onMessageAppended?.(message);
   }
   /** Atomic partial update of a message by id. */
   updateMessage(messageId, updates) {
+    this._flushStreamState();
     const msgs = this.binding.getMessages();
     const index = msgs.findIndex((m) => m.id === messageId);
     if (index === -1) return;
@@ -3786,6 +3877,7 @@ class AparteChatHost {
   }
   /** Add a segment to the last message (immediate bubble + state sync). */
   addSegment(segment) {
+    this._flushStreamState();
     const msgs = this.binding.getMessages();
     const last = msgs[msgs.length - 1];
     if (last && this._isOrphan(last.id)) return;
@@ -3799,6 +3891,7 @@ class AparteChatHost {
   }
   /** Update a segment in the last message in place. */
   updateSegment(segmentId, updates) {
+    this._flushStreamState();
     const msgs = this.binding.getMessages();
     const last = msgs[msgs.length - 1];
     if (last && this._isOrphan(last.id)) return;
@@ -3813,6 +3906,7 @@ class AparteChatHost {
   }
   /** Remove a transient segment (e.g. pipeline-waiting indicator). */
   removeSegment(segmentId) {
+    this._flushStreamState();
     this._lastBubble()?.removeSegment?.(segmentId);
     const msgs = this.binding.getMessages();
     const last = msgs[msgs.length - 1];
@@ -3823,18 +3917,92 @@ class AparteChatHost {
     this.binding.setMessages(next);
     this.binding.onMessagesChange?.(next);
   }
-  /** Append text to a segment's content in the last message. */
+  /**
+   * Append text to a segment's content in the last message — the streaming path
+   * for thinking blocks, tool pills and any segment that grows token by token.
+   *
+   * Two writes, deliberately asymmetric:
+   *  1. straight into the bubble, every chunk, so the text appears immediately —
+   *     the same direct path `appendToken` uses;
+   *  2. into the framework's message list, **coalesced to once per frame**.
+   *
+   * It used to do only (2), synchronously: a full list rebuild plus
+   * `setMessages` + `onMessagesChange` for every chunk, i.e. one complete
+   * framework render per token. At 60 tok/s from a local model that is unusable,
+   * and nothing in the imperative API hinted that `appendToSegment` cost so much
+   * more than `injectTokenStream`. Consumers had to write their own rAF batcher.
+   *
+   * Any structural change flushes the buffer first (see
+   * {@link _flushStreamState}), so ordering is never observable.
+   */
   appendToSegment(segmentId, content) {
     const msgs = this.binding.getMessages();
     const last = msgs[msgs.length - 1];
     if (!last || !last.segments) return;
     if (this._isOrphan(last.id)) return;
-    const segments = last.segments.map(
-      (s) => s.id === segmentId && "content" in s ? { ...s, content: s.content + content } : s
-    );
-    const next = [...msgs.slice(0, -1), { ...last, segments }];
-    this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    let buffered = this._segmentBuffer.get(segmentId);
+    if (!buffered) {
+      const segment = last.segments.find((s) => s.id === segmentId);
+      const base = segment && "content" in segment ? segment.content ?? "" : "";
+      buffered = { base, text: "" };
+      this._segmentBuffer.set(segmentId, buffered);
+    }
+    buffered.text += content;
+    this._vp()?.appendToSegment?.(last.id, segmentId, content);
+    this._scheduleStreamFlush();
+  }
+  /** Schedule the coalesced segment-state sync (idempotent within a frame). */
+  _scheduleStreamFlush() {
+    if (this._flushHandle !== null) return;
+    const run = () => {
+      this._flushHandle = null;
+      this._flushStreamState();
+    };
+    this._flushHandle = typeof requestAnimationFrame === "function" ? requestAnimationFrame(run) : setTimeout(run, 0);
+  }
+  /**
+   * Write every buffered stream chunk — segment chunks and {@link streamTokens}
+   * text alike — into the framework's message list in **one** update. Called by
+   * the scheduled frame, and eagerly by any mutation that would otherwise observe
+   * a stale list (a new segment, a new message, a conversation swap): flushing
+   * first keeps the emitted order identical to the call order.
+   */
+  _flushStreamState() {
+    if (this._flushHandle !== null) {
+      if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(this._flushHandle);
+      else clearTimeout(this._flushHandle);
+      this._flushHandle = null;
+    }
+    const tokens = this._tokenBuffer;
+    const pending = this._segmentBuffer.size > 0 ? new Map(this._segmentBuffer) : null;
+    if (!tokens && !pending) return;
+    this._tokenBuffer = null;
+    this._segmentBuffer.clear();
+    let msgs = this.binding.getMessages();
+    let changed = false;
+    if (tokens) {
+      const index = msgs.findIndex((m) => m.id === tokens.messageId);
+      if (index !== -1) {
+        const next = [...msgs];
+        next[index] = { ...next[index], content: (next[index].content ?? "") + tokens.text };
+        msgs = next;
+        changed = true;
+      }
+    }
+    if (pending) {
+      const last = msgs[msgs.length - 1];
+      if (last?.segments) {
+        const segments = last.segments.map((s) => {
+          const buffered = pending.get(s.id);
+          return buffered !== void 0 && "content" in s ? { ...s, content: buffered.base + buffered.text } : s;
+        });
+        msgs = [...msgs.slice(0, -1), { ...last, segments }];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    this.binding.setMessages(msgs);
+    this.binding.onMessagesChange?.(msgs);
   }
   /** Read the current message list. */
   getMessages() {
@@ -3880,6 +4048,13 @@ class AparteChatHost {
    * appends each token, completes the message at the end. Per-framework
    * wrappers adapt their native stream type (RxJS Observable, AsyncIterable,
    * ReadableStream) into this.
+   *
+   * Each token reaches the bubble immediately and the framework's message list
+   * is synced **once per frame** (same discipline as {@link appendToSegment}),
+   * with a guaranteed flush before completion and on abort. Before that sync
+   * existed the two disagreed: the DOM had the reply, the framework list still
+   * held `content: ''` — so any re-render from state wiped it, and a custom
+   * bubble (which renders from that state) showed nothing at all.
    */
   async streamTokens(messageId, tokens) {
     this.stopTokenStream();
@@ -3899,10 +4074,13 @@ class AparteChatHost {
         const res = await Promise.race([iterator.next(), aborted]);
         if (res === "aborted" || ac.signal.aborted || res.done) break;
         this._vp()?.appendToken?.(messageId, res.value);
+        this._bufferToken(messageId, res.value);
       }
+      this._flushStreamState();
       if (!ac.signal.aborted) this._vp()?.completeMessage?.(messageId);
       this._setStreamingId(null);
     } catch (err) {
+      this._flushStreamState();
       this._setStreamingId(null);
       throw err;
     } finally {
@@ -3915,11 +4093,22 @@ class AparteChatHost {
       if (this._streamAbort === ac) this._streamAbort = void 0;
     }
   }
+  /**
+   * Buffer a streamed token for the coalesced state sync. A different message id
+   * (a second stream started without stopping the first) flushes the previous
+   * one, so text never migrates between messages.
+   */
+  _bufferToken(messageId, chunk) {
+    if (this._tokenBuffer && this._tokenBuffer.messageId !== messageId) this._flushStreamState();
+    this._tokenBuffer = this._tokenBuffer ? { messageId, text: this._tokenBuffer.text + chunk } : { messageId, text: chunk };
+    this._scheduleStreamFlush();
+  }
   /** Abort an in-flight {@link streamTokens} loop. */
   stopTokenStream() {
     if (this._streamAbort) {
       this._streamAbort.abort();
       this._streamAbort = void 0;
+      this._flushStreamState();
       this._setStreamingId(null);
     }
   }
@@ -4407,6 +4596,8 @@ class AparteClient {
     this._config = options.config ?? AparteConfig;
     if (this.options.autoRegister) {
       registerDefaultRenderers();
+    } else {
+      declineDefaultRenderers();
     }
     this._setupListeners();
   }
@@ -4864,8 +5055,9 @@ ${summary}`,
     const targetId = event.detail?.targetId;
     if (targetId) {
       const byId = document.getElementById(targetId);
-      if (byId && typeof byId.appendMessage === "function") {
-        targetElement = byId;
+      const resolved = this._asRenderTarget(byId);
+      if (resolved) {
+        targetElement = resolved;
       } else {
         console.warn("[AparteClient] ⚠️ targetId present but element not found or missing appendMessage:", targetId);
       }
@@ -6093,6 +6285,10 @@ function applyElementProps(el2, props, transformValue = (value) => value) {
     }
   }
 }
+function isAwaitingReply(message) {
+  if (message.status === "streaming" || message.status === "pending") return true;
+  return message.status === void 0 && message.role === "assistant" && !message.content?.trim() && !message.segments?.length;
+}
 function el(tag, className, text) {
   const node = document.createElement(tag);
   if (className) node.className = className;
@@ -6278,19 +6474,24 @@ export {
   APARTE_CONVERSATION_SCHEMA_VERSION as A,
   BackendTransport as B,
   ConversationManager as C,
-  DEFAULT_ICON_FALLBACKS as D,
-  isSafeUrl as E,
-  parseAparteEventStream as F,
-  parseMarkdownToSegments as G,
-  populateBubbleFromMessage as H,
-  readableToAsyncIterable as I,
-  registerDefaultRenderers as J,
-  registerSegmentRenderer as K,
-  requestUserInput as L,
+  DEFAULT_BUBBLE_ACTIONS as D,
+  filesToAttachments as E,
+  getSegmentRenderer as F,
+  isAwaitingReply as G,
+  isFormatAdapter as H,
+  isSafeUrl as I,
+  parseAparteEventStream as J,
+  parseMarkdownToSegments as K,
+  populateBubbleFromMessage as L,
   MessageRepository as M,
-  resolveConfig as N,
-  runWithConfig as O,
-  unregisterSegmentRenderer as P,
+  readableToAsyncIterable as N,
+  registerDefaultRenderers as O,
+  registerSegmentRenderer as P,
+  requestUserInput as Q,
+  resolveConfig as R,
+  runWithConfig as S,
+  unregisterSegmentRenderer as T,
+  installDefaultRenderersOnce as U,
   APARTE_HOST_ATTR as a,
   AparteChatHost as b,
   AparteClient as c,
@@ -6300,22 +6501,22 @@ export {
   AparteError as g,
   AparteErrorCode as h,
   AparteStreamParser as i,
-  DEFAULT_LOCALE as j,
-  DEFAULT_SKELETON_FALLBACKS as k,
-  DEFAULT_UI_EVENTS as l,
-  DirectTransport as m,
-  applyElementProps as n,
-  attachConfig as o,
-  buildElicitationPanel as p,
-  collectRendererStyles as q,
-  contentToText as r,
-  contextConfig as s,
-  createAparteChatHandler as t,
-  createStreamAdapter as u,
-  defaultSanitizer as v,
-  deriveArtifactKind as w,
-  detachConfig as x,
-  getSegmentRenderer as y,
-  isFormatAdapter as z
+  DEFAULT_HOST_HANDLERS as j,
+  DEFAULT_ICON_FALLBACKS as k,
+  DEFAULT_LOCALE as l,
+  DEFAULT_SKELETON_FALLBACKS as m,
+  DEFAULT_UI_EVENTS as n,
+  DirectTransport as o,
+  applyElementProps as p,
+  attachConfig as q,
+  buildElicitationPanel as r,
+  collectRendererStyles as s,
+  contentToText as t,
+  contextConfig as u,
+  createAparteChatHandler as v,
+  createStreamAdapter as w,
+  defaultSanitizer as x,
+  deriveArtifactKind as y,
+  detachConfig as z
 };
-//# sourceMappingURL=index-CW2BCAqn.js.map
+//# sourceMappingURL=index-Dn7TH14G.js.map