@lostgradient/cinder 0.6.0 → 0.7.0

package/dist/server/index.server-bvmwnjx6.js

@@ -0,0 +1,3797 @@
+import {
+  useIntersection
+} from "./index.server-kb6w1a7c.js";
+import {
+  useAnnouncer
+} from "./index.server-gbzsb04q.js";
+import {
+  formatBytes
+} from "./index.server-w6am2dxc.js";
+import {
+  stringify
+} from "./index.server-z1qvwaem.js";
+import {
+  deriveMessageParts,
+  getMessageText,
+  pairToolCallsWithResults,
+  resolveMessageReasoning,
+  resolveMessageSteps,
+  resolveMessageSuggestions
+} from "./index.server-dc35kh7d.js";
+import {
+  appendAssistantMessage,
+  appendMessages,
+  appendUserMessage,
+  createConversationHistory,
+  getMessages
+} from "./index.server-rjap4k7y.js";
+import {
+  useReducedMotion
+} from "./index.server-8hdvr9bt.js";
+import {
+  Arrow_up,
+  Check_check,
+  Chevron_up,
+  Paperclip,
+  Square
+} from "./index.server-j5hn2qds.js";
+import {
+  Ellipsis,
+  Pencil
+} from "./index.server-a59y47rw.js";
+import {
+  Search
+} from "./index.server-qdnsgt12.js";
+import {
+  X
+} from "./index.server-vzc1j5mq.js";
+import {
+  Chevron_down,
+  Chevron_left,
+  Chevron_right,
+  Rotate_ccw
+} from "./index.server-mm1xa3kr.js";
+import {
+  File_code
+} from "./index.server-rqe5bqgm.js";
+import {
+  File_text
+} from "./index.server-yq9evnp4.js";
+import {
+  Code_block
+} from "./index.server-q89dz8h1.js";
+import {
+  Copy_button
+} from "./index.server-z1q7qnb8.js";
+import {
+  Circle_alert
+} from "./index.server-2j52msk2.js";
+import {
+  Check
+} from "./index.server-wwk0f944.js";
+import {
+  Button
+} from "./index.server-t859hsx1.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/chat/chat.svelte
+import * as $36 from "svelte/internal/server";
+
+// src/components/chat/container/chat.svelte
+import * as $35 from "svelte/internal/server";
+import { tick as tick2, untrack as untrack2 } from "svelte";
+
+// src/components/chat/message/chat-date-separator.svelte
+import * as $ from "svelte/internal/server";
+function Chat_date_separator($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      date,
+      dateFormatter,
+      class: className,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const dateObj = $.derived(() => typeof date === "string" ? new Date(date) : date);
+    const isValidDate = $.derived(() => !isNaN(dateObj().getTime()));
+    const formattedDate = $.derived(() => {
+      if (!isValidDate()) {
+        return "Invalid date";
+      }
+      if (dateFormatter) {
+        return dateFormatter(dateObj());
+      }
+      const now = new Date;
+      const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const yesterday = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1);
+      const dateOnly = new Date(dateObj().getFullYear(), dateObj().getMonth(), dateObj().getDate());
+      if (dateOnly.getTime() === today.getTime()) {
+        return "Today";
+      }
+      if (dateOnly.getTime() === yesterday.getTime()) {
+        return "Yesterday";
+      }
+      return new Intl.DateTimeFormat(undefined, { weekday: "long", month: "long", day: "numeric" }).format(dateObj());
+    });
+    const isoDate = $.derived(() => isValidDate() ? dateObj().toISOString().split("T")[0] : "");
+    $$renderer2.push(`<div${$.attributes({
+      class: $.clsx(classNames("chat-date-separator", className)),
+      role: "separator",
+      "aria-label": `Messages from ${formattedDate()}`,
+      ...rest
+    }, "svelte-1ohxdji")}><span class="chat-date-separator-line svelte-1ohxdji" aria-hidden="true"></span> `);
+    if (isValidDate()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<time class="chat-date-separator-text svelte-1ohxdji"${$.attr("datetime", isoDate())}>${$.escape(formattedDate())}</time>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<span class="chat-date-separator-text svelte-1ohxdji">${$.escape(formattedDate())}</span>`);
+    }
+    $$renderer2.push(`<!--]--> <span class="chat-date-separator-line svelte-1ohxdji" aria-hidden="true"></span></div>`);
+  }, Chat_date_separator);
+}
+// src/components/chat/message/chat-message.svelte
+import * as $17 from "svelte/internal/server";
+
+// src/components/chat/message/chat-message-parts-renderer.svelte
+import * as $16 from "svelte/internal/server";
+
+// src/components/chat/message/chat-message-parts.ts
+function toRenderUnits(parts) {
+  const units = [];
+  let imageRun = [];
+  let stepRun = [];
+  let suggestionRun = [];
+  const flushImages = () => {
+    if (imageRun.length > 0) {
+      units.push({ kind: "images", images: imageRun, key: `images:${imageRun[0].key}` });
+      imageRun = [];
+    }
+  };
+  const flushSteps = () => {
+    if (stepRun.length > 0) {
+      units.push({ kind: "steps", steps: stepRun, key: `steps:${stepRun[0].key}` });
+      stepRun = [];
+    }
+  };
+  const flushSuggestions = () => {
+    if (suggestionRun.length > 0) {
+      units.push({
+        kind: "suggestions",
+        suggestions: suggestionRun,
+        key: `suggestions:${suggestionRun[0].key}`
+      });
+      suggestionRun = [];
+    }
+  };
+  for (const part of parts) {
+    if (part.type === "image") {
+      flushSteps();
+      flushSuggestions();
+      imageRun.push(part);
+      continue;
+    }
+    if (part.type === "step") {
+      flushImages();
+      flushSuggestions();
+      stepRun.push(part);
+      continue;
+    }
+    if (part.type === "suggestion") {
+      flushImages();
+      flushSteps();
+      suggestionRun.push(part);
+      continue;
+    }
+    flushImages();
+    flushSteps();
+    flushSuggestions();
+    units.push({ kind: "part", part, key: part.key });
+  }
+  flushImages();
+  flushSteps();
+  flushSuggestions();
+  return units;
+}
+
+// src/components/chat/message/parts/markdown-part.svelte
+import * as $4 from "svelte/internal/server";
+
+// src/components/chat/message/message-content.svelte
+import * as $3 from "svelte/internal/server";
+
+// src/components/chat/message/markdown-preview.svelte
+import * as $2 from "svelte/internal/server";
+function Markdown_preview($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { content, class: className, $$slots, $$events, ...rest } = $$props;
+    let renderedHtml = "";
+    $$renderer2.push(`<div${$2.attributes({
+      class: $2.clsx(classNames("cinder-markdown-content message-content-preview", className)),
+      ...rest
+    })}>`);
+    if (renderedHtml) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`${$2.html(renderedHtml)}`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<p>${$2.escape(content)}</p>`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Markdown_preview);
+}
+
+// src/components/chat/message/message-content.svelte
+function Message_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      content,
+      expanded = true,
+      threshold = 500,
+      streaming = false,
+      overrideContent,
+      class: className,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    function findSafeBoundary(text, limit) {
+      const paragraphBreak = text.lastIndexOf(`
+
+`, limit);
+      if (paragraphBreak > 0)
+        return paragraphBreak;
+      const lineBreak = text.lastIndexOf(`
+`, limit);
+      if (lineBreak > 0)
+        return lineBreak;
+      return limit;
+    }
+    function splitStreamingContent(text) {
+      const codeFenceCount = (text.match(/```/g) ?? []).length;
+      if (codeFenceCount % 2 !== 0) {
+        const lastFenceIndex = text.lastIndexOf("```");
+        return {
+          rendered: text.slice(0, lastFenceIndex),
+          tail: text.slice(lastFenceIndex)
+        };
+      }
+      const boundary = findSafeBoundary(text, text.length);
+      return {
+        rendered: text.slice(0, boundary),
+        tail: text.slice(boundary)
+      };
+    }
+    const effectiveContent = $3.derived(() => overrideContent ?? content);
+    const streamingSplit = $3.derived(() => {
+      if (!streaming)
+        return null;
+      return splitStreamingContent(effectiveContent());
+    });
+    const displayContent = $3.derived(() => {
+      if (streaming) {
+        return streamingSplit()?.rendered ?? "";
+      }
+      if (expanded || effectiveContent().length <= threshold) {
+        return effectiveContent();
+      }
+      const boundary = findSafeBoundary(effectiveContent(), threshold);
+      return effectiveContent().slice(0, boundary);
+    });
+    const streamingTail = $3.derived(() => streaming ? streamingSplit()?.tail ?? "" : "");
+    const isTruncated = $3.derived(() => !streaming && !expanded && effectiveContent().length > threshold);
+    $$renderer2.push(`<div${$3.attributes({
+      class: $3.clsx(classNames("message-content", streaming && "message-content-streaming", className)),
+      ...rest
+    }, "svelte-1ntys16")}>`);
+    if (displayContent()) {
+      $$renderer2.push("<!--[0-->");
+      Markdown_preview($$renderer2, { content: displayContent() });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (streaming && streamingTail()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="message-content-tail svelte-1ntys16">${$3.escape(streamingTail())}</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (streaming) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="message-content-cursor svelte-1ntys16" aria-hidden="true"></span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (isTruncated()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="message-content-ellipsis svelte-1ntys16" aria-hidden="true">...</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Message_content);
+}
+
+// src/components/chat/message/parts/markdown-part.svelte
+function Markdown_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { part } = $$props;
+    Message_content($$renderer2, {
+      content: part.content,
+      streaming: part.streaming,
+      expanded: part.expanded
+    });
+  }, Markdown_part);
+}
+
+// src/components/chat/message/parts/tool-call-part.svelte
+import * as $7 from "svelte/internal/server";
+
+// src/components/chat/message/tool-call-group.svelte
+import * as $6 from "svelte/internal/server";
+
+// src/components/chat/message/tool-payload-code.svelte
+import * as $5 from "svelte/internal/server";
+function Tool_payload_code($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { code, class: className } = $$props;
+    $$renderer2.push(`<div${$5.attr_class($5.clsx(classNames("tool-payload-code", className)), "svelte-1fw63o4")}>`);
+    Code_block($$renderer2, { code, language: "json" });
+    $$renderer2.push(`<!----></div>`);
+  }, Tool_payload_code);
+}
+
+// src/components/chat/message/tool-call-group.svelte
+function Tool_call_group($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      pair,
+      expanded = false,
+      ontoggle,
+      class: className,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const detailsId = $6.derived(() => `tool-call-details-${pair.call.id}`);
+    const hasResult = $6.derived(() => !!pair.result);
+    const isError = $6.derived(() => pair.result?.outcome === "error");
+    const isSuccess = $6.derived(() => pair.result?.outcome === "success");
+    const isActionRequired = $6.derived(() => pair.result?.outcome === "action_required");
+    const status = $6.derived(() => isError() ? "error" : isSuccess() ? "success" : isActionRequired() ? "action-required" : "pending");
+    const errorMessage = $6.derived(() => pair.result?.error?.message ?? "");
+    const actionMessage = $6.derived(() => pair.result?.action?.message ?? "This tool call requires action.");
+    const formattedArguments = $6.derived(() => stringify(pair.call.arguments));
+    const formattedResult = $6.derived(() => pair.result ? stringify(pair.result.content) : "");
+    function handleToggle() {
+      ontoggle?.();
+    }
+    $$renderer2.push(`<div${$6.attributes({
+      class: $6.clsx(classNames("tool-call-group", className)),
+      "data-status": status(),
+      ...rest
+    }, "svelte-1xmm5k6")}><button type="button" class="tool-call-header svelte-1xmm5k6"${$6.attr("aria-expanded", expanded)}${$6.attr("aria-controls", detailsId())}${$6.attr("aria-label", `Toggle tool call details for ${pair.call.name}`)}><span class="tool-call-icon svelte-1xmm5k6" aria-hidden="true">`);
+    if (isError()) {
+      $$renderer2.push("<!--[0-->");
+      X($$renderer2, { class: "cinder-icon-xs" });
+    } else if (isSuccess()) {
+      $$renderer2.push("<!--[1-->");
+      Check($$renderer2, { class: "cinder-icon-xs" });
+    } else if (isActionRequired()) {
+      $$renderer2.push("<!--[2-->");
+      Circle_alert($$renderer2, { class: "cinder-icon-xs" });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      Ellipsis($$renderer2, { class: "cinder-icon-xs" });
+    }
+    $$renderer2.push(`<!--]--></span> <span class="tool-call-name svelte-1xmm5k6">${$6.escape(pair.call.name)}</span> <span class="tool-call-status svelte-1xmm5k6" role="status" aria-live="polite">`);
+    if (isError()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`Failed`);
+    } else if (isSuccess()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`Complete`);
+    } else if (isActionRequired()) {
+      $$renderer2.push("<!--[2-->");
+      $$renderer2.push(`Action required`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`Pending`);
+    }
+    $$renderer2.push(`<!--]--></span> <span class="tool-call-chevron svelte-1xmm5k6" aria-hidden="true"${$6.attr("data-expanded", expanded)}>`);
+    Chevron_down($$renderer2, { class: "cinder-icon-xs" });
+    $$renderer2.push(`<!----></span></button> `);
+    if (expanded) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div${$6.attr("id", detailsId())} class="tool-call-details svelte-1xmm5k6" role="region" aria-label="Tool details"><div class="tool-call-section svelte-1xmm5k6"><h4 class="tool-call-section-title svelte-1xmm5k6">Arguments</h4> `);
+      Tool_payload_code($$renderer2, { code: formattedArguments() });
+      $$renderer2.push(`<!----></div> `);
+      if (hasResult()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="tool-call-section svelte-1xmm5k6"${$6.attr("data-error", isError() || undefined)}><h4 class="tool-call-section-title svelte-1xmm5k6">Result</h4> `);
+        if (isError()) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<div class="tool-call-error svelte-1xmm5k6" role="alert">${$6.escape(errorMessage() || formattedResult())}</div>`);
+        } else if (isActionRequired()) {
+          $$renderer2.push("<!--[1-->");
+          $$renderer2.push(`<div class="tool-call-action svelte-1xmm5k6" role="status">${$6.escape(actionMessage())}</div>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+          Tool_payload_code($$renderer2, { code: formattedResult() });
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Tool_call_group);
+}
+
+// src/components/chat/message/parts/tool-call-part.svelte
+function Tool_call_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const noop = () => {};
+    let { part, expanded = false, ontoggle } = $$props;
+    const handleToggle = $7.derived(() => ontoggle ?? noop);
+    Tool_call_group($$renderer2, { pair: part.pair, expanded, ontoggle: handleToggle() });
+  }, Tool_call_part);
+}
+
+// src/components/chat/message/parts/tool-result-part.svelte
+import * as $8 from "svelte/internal/server";
+function Tool_result_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { part } = $$props;
+    const result = $8.derived(() => part.result);
+    const isError = $8.derived(() => result().outcome === "error");
+    const isActionRequired = $8.derived(() => result().outcome === "action_required");
+    const formatted = $8.derived(() => {
+      if (result().outcome === "error" && result().error) {
+        return result().error.message;
+      }
+      if (result().outcome === "action_required") {
+        return result().action?.message ?? "This tool call requires action.";
+      }
+      return stringify(result().content);
+    });
+    $$renderer2.push(`<div class="chat-message-tool-result svelte-s62laq"${$8.attr("data-error", isError() || undefined)}${$8.attr("data-action-required", isActionRequired() || undefined)}>`);
+    if (isError()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-message-tool-error svelte-s62laq" role="alert">${$8.escape(formatted())}</div>`);
+    } else if (isActionRequired()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`<div class="chat-message-tool-action" role="status">${$8.escape(formatted())}</div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      Tool_payload_code($$renderer2, { code: formatted() });
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Tool_result_part);
+}
+
+// src/components/chat/message/parts/tool-approval-part.svelte
+import * as $9 from "svelte/internal/server";
+function Tool_approval_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { part, onapprove, ondeny } = $$props;
+    const isPending = $9.derived(() => part.approved === undefined);
+    const isApproved = $9.derived(() => part.approved === true);
+    const isDenied = $9.derived(() => part.approved === false);
+    const actionMessage = $9.derived(() => part.action.message ?? "This tool call requires your approval before it can continue.");
+    const actionSchema = $9.derived(() => part.action.schema !== undefined ? stringify(part.action.schema) : undefined);
+    const safeKey = $9.derived(() => part.key.replace(/[^a-z0-9-]/gi, "-"));
+    const labelId = $9.derived(() => `tool-approval-label-${safeKey()}`);
+    const descId = $9.derived(() => `tool-approval-desc-${safeKey()}`);
+    function handleApprove() {
+      if (!isPending())
+        return;
+      onapprove?.(part.toolCallId);
+    }
+    function handleDeny() {
+      if (!isPending())
+        return;
+      ondeny?.(part.toolCallId);
+    }
+    function handleKeydown(event) {
+      if (event.key === "Escape" && isPending()) {
+        handleDeny();
+      }
+    }
+    $$renderer2.push(`<div class="chat-tool-approval svelte-vsdezw" role="group" tabindex="-1"${$9.attr("aria-labelledby", labelId())}${$9.attr("aria-describedby", descId())} data-cinder-tool-approval=""${$9.attr("data-cinder-status", isApproved() ? "approved" : isDenied() ? "denied" : "pending")}><div class="chat-tool-approval-header svelte-vsdezw"><span class="chat-tool-approval-icon svelte-vsdezw" aria-hidden="true">`);
+    if (isApproved()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`✓`);
+    } else if (isDenied()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`✕`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`⚠`);
+    }
+    $$renderer2.push(`<!--]--></span> <span${$9.attr("id", labelId())} class="chat-tool-approval-title svelte-vsdezw">`);
+    if (isApproved()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`Approved: <code class="chat-tool-approval-name svelte-vsdezw">${$9.escape(part.toolName)}</code>`);
+    } else if (isDenied()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`Denied: <code class="chat-tool-approval-name svelte-vsdezw">${$9.escape(part.toolName)}</code>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`Action required: <code class="chat-tool-approval-name svelte-vsdezw">${$9.escape(part.toolName)}</code>`);
+    }
+    $$renderer2.push(`<!--]--></span></div> <p${$9.attr("id", descId())} class="chat-tool-approval-message svelte-vsdezw">${$9.escape(actionMessage())}</p> `);
+    if (actionSchema() !== undefined) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<details class="chat-tool-approval-args svelte-vsdezw"><summary class="chat-tool-approval-args-toggle svelte-vsdezw">View parameters</summary> <pre class="chat-tool-approval-args-code svelte-vsdezw"><code>${$9.escape(actionSchema())}</code></pre></details>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (isPending()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-tool-approval-actions svelte-vsdezw"><button type="button" class="chat-tool-approval-btn chat-tool-approval-btn-approve svelte-vsdezw"${$9.attr("disabled", onapprove === undefined, true)}>Approve</button> <button type="button" class="chat-tool-approval-btn chat-tool-approval-btn-deny svelte-vsdezw"${$9.attr("disabled", ondeny === undefined, true)}>Reject</button></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Tool_approval_part);
+}
+
+// src/components/chat/message/parts/reasoning-part.svelte
+import * as $10 from "svelte/internal/server";
+function Reasoning_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { part, expanded = false, ontoggle } = $$props;
+    const labelId = $10.derived(() => `reasoning-label-${part.key.replace(/[^a-z0-9-]/gi, "-")}`);
+    const contentId = $10.derived(() => `reasoning-content-${part.key.replace(/[^a-z0-9-]/gi, "-")}`);
+    const approximateTokenCount = $10.derived(() => Math.round(part.content.length / 4));
+    const tokenDisplay = $10.derived(() => approximateTokenCount() > 0 ? ` (${approximateTokenCount().toLocaleString()} tokens)` : "");
+    let wasStreaming = false;
+    let announced = false;
+    const announcementText = $10.derived(() => announced ? "Reasoning complete." : "");
+    function handleToggle() {
+      if (!part.streaming) {
+        ontoggle?.();
+      }
+    }
+    $$renderer2.push(`<div class="chat-reasoning svelte-11vyvtm" data-cinder-reasoning=""${$10.attr("data-cinder-streaming", part.streaming ? "" : undefined)}${$10.attr("data-cinder-expanded", expanded ? "" : undefined)}><button type="button" class="chat-reasoning-toggle svelte-11vyvtm"${$10.attr("id", labelId())}${$10.attr("aria-expanded", expanded)}${$10.attr("aria-controls", contentId())}${$10.attr("disabled", part.streaming, true)}><span class="chat-reasoning-label svelte-11vyvtm" aria-hidden="true">`);
+    if (part.streaming) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="chat-reasoning-dot svelte-11vyvtm" aria-hidden="true"></span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> Reasoning${$10.escape(tokenDisplay())}</span> <span class="sr-only svelte-11vyvtm">`);
+    if (part.streaming) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`Reasoning in progress`);
+    } else if (expanded) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`Collapse reasoning`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`Expand reasoning`);
+    }
+    $$renderer2.push(`<!--]--></span> <span class="chat-reasoning-chevron svelte-11vyvtm" aria-hidden="true">${$10.escape(expanded ? "▲" : "▼")}</span></button> <div class="chat-reasoning-body svelte-11vyvtm"><div${$10.attr("id", contentId())} class="chat-reasoning-content svelte-11vyvtm"${$10.attr("aria-hidden", !expanded)}${$10.attr("aria-live", part.streaming ? "off" : undefined)}${$10.attr("aria-busy", part.streaming ? true : undefined)}>${$10.escape(part.content)}</div></div> <div class="sr-only svelte-11vyvtm" aria-live="polite" aria-atomic="true">${$10.escape(announcementText())}</div></div>`);
+  }, Reasoning_part);
+}
+
+// src/components/chat/message/parts/step-part.svelte
+import * as $11 from "svelte/internal/server";
+function Step_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { part } = $$props;
+    const statusIcon = { pending: "○", running: "◉", done: "●", error: "✕" };
+    const statusLabel = {
+      pending: "pending",
+      running: "in progress",
+      done: "complete",
+      error: "failed"
+    };
+    $$renderer2.push(`<li class="chat-step svelte-4godlk"${$11.attr("data-cinder-step-status", part.status)}${$11.attr("aria-current", part.status === "running" ? "step" : undefined)}><span class="chat-step-indicator svelte-4godlk" aria-hidden="true">${$11.escape(statusIcon[part.status])}</span> <span class="chat-step-body svelte-4godlk"><span class="chat-step-title svelte-4godlk">${$11.escape(part.title)} <span class="sr-only svelte-4godlk">— ${$11.escape(statusLabel[part.status])}</span></span> `);
+    if (part.content) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="chat-step-content svelte-4godlk">${$11.escape(part.content)}</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></span></li>`);
+  }, Step_part);
+}
+
+// src/components/chat/message/parts/suggestion-part.svelte
+import * as $12 from "svelte/internal/server";
+function Suggestion_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { part, onsuggestionselect, tabindex = 0 } = $$props;
+    function handleClick() {
+      onsuggestionselect?.(part.label);
+    }
+    $$renderer2.push(`<button type="button" class="chat-suggestion-chip svelte-r2wk4e" data-cinder-suggestion=""${$12.attr("tabindex", tabindex)}>${$12.escape(part.label)}</button>`);
+  }, Suggestion_part);
+}
+
+// src/components/chat/message/parts/image-part.svelte
+import * as $15 from "svelte/internal/server";
+
+// src/components/chat/message/message-attachments.svelte
+import * as $14 from "svelte/internal/server";
+
+// src/components/chat/message/image-lightbox.svelte
+import * as $13 from "svelte/internal/server";
+import { fade } from "svelte/transition";
+function Image_lightbox($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { images, initialIndex = 0, open = false, onclose } = $$props;
+    const reducedMotion = useReducedMotion();
+    const LIGHTBOX_FADE_MS = 150;
+    const fadeDuration = $13.derived(() => reducedMotion.current ? 0 : LIGHTBOX_FADE_MS);
+    const clampedInitialIndex = $13.derived(() => images.length > 0 ? Math.max(0, Math.min(initialIndex, images.length - 1)) : 0);
+    let navigationIndex = null;
+    const effectiveIndex = $13.derived(() => open ? navigationIndex ?? clampedInitialIndex() : clampedInitialIndex());
+    const hasMultiple = $13.derived(() => images.length > 1);
+    const currentImage = $13.derived(() => images[effectiveIndex()]);
+    const counterText = $13.derived(() => `${effectiveIndex() + 1} of ${images.length}`);
+    function close() {
+      navigationIndex = null;
+      open = false;
+      onclose?.();
+    }
+    function previous() {
+      navigationIndex = (effectiveIndex() - 1 + images.length) % images.length;
+    }
+    function next() {
+      navigationIndex = (effectiveIndex() + 1) % images.length;
+    }
+    function handleOverlayClick(event) {
+      if (event.target === event.currentTarget) {
+        close();
+      }
+    }
+    function handleKeyDown(event) {
+      switch (event.key) {
+        case "Escape":
+          event.preventDefault();
+          close();
+          break;
+        case "ArrowLeft":
+          if (hasMultiple()) {
+            event.preventDefault();
+            previous();
+          }
+          break;
+        case "ArrowRight":
+          if (hasMultiple()) {
+            event.preventDefault();
+            next();
+          }
+          break;
+      }
+    }
+    if (open && currentImage()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="lightbox-overlay svelte-nzg1o2" role="dialog" aria-modal="true" aria-label="Image viewer" tabindex="-1"><button type="button" class="lightbox-close svelte-nzg1o2" aria-label="Close image viewer">`);
+      X($$renderer2, { size: 20 });
+      $$renderer2.push(`<!----></button> `);
+      if (hasMultiple()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<button type="button" class="lightbox-nav lightbox-nav-previous svelte-nzg1o2" aria-label="Previous image">`);
+        Chevron_left($$renderer2, { size: 24 });
+        $$renderer2.push(`<!----></button>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> <div class="lightbox-image-container svelte-nzg1o2"><img${$13.attr("src", currentImage().src)}${$13.attr("alt", currentImage().alt)} class="lightbox-image svelte-nzg1o2" decoding="async"/></div> `);
+      if (hasMultiple()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<button type="button" class="lightbox-nav lightbox-nav-next svelte-nzg1o2" aria-label="Next image">`);
+        Chevron_right($$renderer2, { size: 24 });
+        $$renderer2.push(`<!----></button> <div class="lightbox-counter svelte-nzg1o2" aria-live="polite" aria-atomic="true">${$13.escape(counterText())}</div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+    $13.bind_props($$props, { open });
+  }, Image_lightbox);
+}
+
+// src/components/chat/message/message-attachments.svelte
+function Message_attachments($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      images,
+      loading = "lazy",
+      onimageload,
+      onimageerror,
+      class: className,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const validImages = $14.derived(() => images.filter((item) => item.type === "image").map((image) => ({ image, url: getImageUrlFromContent(image) })).filter((item) => item.url !== ""));
+    let lightboxOpen = false;
+    let lightboxIndex = 0;
+    const lightboxImages = $14.derived(() => validImages().map(({ image, url }, index) => ({ src: url, alt: getAltText(image, index + 1) })));
+    function getImageUrlFromContent(image) {
+      if (image.type !== "image")
+        return "";
+      return image.url;
+    }
+    function getAltText(image, displayIndex) {
+      if (image.type !== "image")
+        return "";
+      if (image.text)
+        return image.text;
+      return `Image attachment ${displayIndex}`;
+    }
+    function handleLoad(index) {
+      onimageload?.(index);
+    }
+    function handleError(index, event) {
+      onimageerror?.(index, event);
+    }
+    function openLightbox(index) {
+      lightboxIndex = index;
+      lightboxOpen = true;
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div${$14.attributes({
+        class: $14.clsx(classNames("message-attachments", className)),
+        role: "list",
+        "aria-label": "Message attachments",
+        "data-count": validImages().length,
+        ...rest
+      }, "svelte-mmlgnv")}><!--[-->`);
+      const each_array = $14.ensure_array_like(validImages());
+      for (let loopIndex = 0, $$length = each_array.length;loopIndex < $$length; loopIndex++) {
+        let { image, url } = each_array[loopIndex];
+        const displayIndex = loopIndex + 1;
+        const alt = getAltText(image, displayIndex);
+        $$renderer3.push(`<figure class="message-attachment svelte-mmlgnv" role="listitem"><button type="button" class="message-attachment-button svelte-mmlgnv"${$14.attr("aria-label", `View image: ${alt}`)}><img${$14.attr("src", url)}${$14.attr("alt", alt)}${$14.attr("loading", loading)} decoding="async" class="message-attachment-image svelte-mmlgnv" onload="this.__e=event" onerror="this.__e=event"/></button> `);
+        if (alt && alt !== `Image attachment ${displayIndex}`) {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<figcaption class="sr-only svelte-mmlgnv">${$14.escape(alt)}</figcaption>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+        }
+        $$renderer3.push(`<!--]--></figure>`);
+      }
+      $$renderer3.push(`<!--]--></div> `);
+      Image_lightbox($$renderer3, {
+        images: lightboxImages(),
+        initialIndex: lightboxIndex,
+        get open() {
+          return lightboxOpen;
+        },
+        set open($$value) {
+          lightboxOpen = $$value;
+          $$settled = false;
+        }
+      });
+      $$renderer3.push(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+  }, Message_attachments);
+}
+
+// src/components/chat/message/parts/image-part.svelte
+function Image_part($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { parts } = $$props;
+    const images = $15.derived(() => parts.map((part) => part.image));
+    Message_attachments($$renderer2, { images: images() });
+  }, Image_part);
+}
+
+// src/components/chat/message/chat-message-parts-renderer.svelte
+function Chat_message_parts_renderer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      parts,
+      messagePart,
+      expanded = false,
+      ontoggle,
+      onapprove,
+      ondeny,
+      reasoningExpanded = false,
+      onreasoning,
+      onsuggestionselect
+    } = $$props;
+    const units = $16.derived(() => toRenderUnits(parts));
+    let activeIndex = 0;
+    function activeChipIndex(count) {
+      return count === 0 ? 0 : Math.min(activeIndex, count - 1);
+    }
+    function handleToolbarKeydown(event, toolbar, count) {
+      if (count === 0)
+        return;
+      const current = Math.min(activeIndex, count - 1);
+      let next = current;
+      if (event.key === "ArrowRight") {
+        next = (current + 1) % count;
+      } else if (event.key === "ArrowLeft") {
+        next = (current - 1 + count) % count;
+      } else if (event.key === "Home") {
+        next = 0;
+      } else if (event.key === "End") {
+        next = count - 1;
+      } else {
+        return;
+      }
+      event.preventDefault();
+      activeIndex = next;
+      const chips = toolbar.querySelectorAll("[data-cinder-suggestion]");
+      chips[next]?.focus();
+    }
+    function renderDefault($$renderer3, part) {
+      if (part.type === "markdown") {
+        $$renderer3.push("<!--[0-->");
+        Markdown_part($$renderer3, { part });
+      } else if (part.type === "tool-call") {
+        $$renderer3.push("<!--[1-->");
+        Tool_call_part($$renderer3, { part, expanded, ontoggle });
+      } else if (part.type === "tool-result") {
+        $$renderer3.push("<!--[2-->");
+        Tool_result_part($$renderer3, { part });
+      } else if (part.type === "tool-approval") {
+        $$renderer3.push("<!--[3-->");
+        Tool_approval_part($$renderer3, { part, onapprove, ondeny });
+      } else if (part.type === "reasoning") {
+        $$renderer3.push("<!--[4-->");
+        Reasoning_part($$renderer3, { part, expanded: reasoningExpanded, ontoggle: onreasoning });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<span data-cinder-unhandled-part="" aria-hidden="true"></span>`);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--[-->`);
+    const each_array = $16.ensure_array_like(units());
+    for (let $$index_2 = 0, $$length = each_array.length;$$index_2 < $$length; $$index_2++) {
+      let unit = each_array[$$index_2];
+      if (unit.kind === "images") {
+        $$renderer2.push("<!--[0-->");
+        Image_part($$renderer2, { parts: unit.images });
+      } else if (unit.kind === "steps") {
+        $$renderer2.push("<!--[1-->");
+        $$renderer2.push(`<ol class="chat-step-list svelte-16hfc7o" aria-label="Steps"><!--[-->`);
+        const each_array_1 = $16.ensure_array_like(unit.steps);
+        for (let $$index = 0, $$length2 = each_array_1.length;$$index < $$length2; $$index++) {
+          let step = each_array_1[$$index];
+          Step_part($$renderer2, { part: step });
+        }
+        $$renderer2.push(`<!--]--></ol>`);
+      } else if (unit.kind === "suggestions") {
+        $$renderer2.push("<!--[2-->");
+        $$renderer2.push(`<div class="chat-suggestions svelte-16hfc7o" role="toolbar" aria-label="Suggested replies" data-cinder-suggested-replies=""><!--[-->`);
+        const each_array_2 = $16.ensure_array_like(unit.suggestions);
+        for (let index = 0, $$length2 = each_array_2.length;index < $$length2; index++) {
+          let suggestion = each_array_2[index];
+          Suggestion_part($$renderer2, {
+            part: suggestion,
+            onsuggestionselect,
+            tabindex: index === activeChipIndex(unit.suggestions.length) ? 0 : -1
+          });
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else if (messagePart) {
+        $$renderer2.push("<!--[3-->");
+        messagePart($$renderer2, unit.part, renderDefault);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        renderDefault($$renderer2, unit.part);
+      }
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]-->`);
+  }, Chat_message_parts_renderer);
+}
+
+// src/components/chat/message/chat-message.svelte
+var ROLE_LABELS = {
+  user: "You",
+  assistant: "Assistant",
+  system: "System",
+  developer: "Developer",
+  "tool-call": "Tool Call",
+  "tool-result": "Tool Result",
+  snapshot: "Snapshot"
+};
+function Chat_message($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      message,
+      toolCallPairs = [],
+      expanded = true,
+      class: className,
+      searchMatch = false,
+      actions,
+      status,
+      messagePart,
+      showDefaultActions = true,
+      streaming = false,
+      overrideContent,
+      onexpandedchange,
+      onretry,
+      onedit,
+      approvedToolCallIds,
+      deniedToolCallIds,
+      onapprove,
+      ondeny,
+      reasoning,
+      steps,
+      suggestions,
+      reasoningExpanded = false,
+      onreasoning,
+      toolCallExpanded = false,
+      ontoolcalltoggle,
+      onsuggestionselect,
+      tabindex,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let isEditing = false;
+    let editContent = "";
+    const canEdit = $17.derived(() => message.role === "user" && onedit !== undefined && !streaming);
+    function startEditing() {
+      editContent = textContent();
+      isEditing = true;
+    }
+    function cancelEditing() {
+      isEditing = false;
+      editContent = "";
+    }
+    function saveEdit() {
+      const trimmedContent = editContent.trim();
+      if (trimmedContent && trimmedContent !== textContent()) {
+        onedit?.({ messageId: message.id, content: trimmedContent });
+      }
+      isEditing = false;
+      editContent = "";
+    }
+    function handleEditKeyDown(event) {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        cancelEditing();
+      }
+      if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault();
+        saveEdit();
+      }
+    }
+    const deliveryStatus = $17.derived(() => message.metadata?.["_deliveryStatus"]);
+    const isFailed = $17.derived(() => deliveryStatus() === "failed");
+    const textContent = $17.derived(() => getMessageText(message));
+    const roleLabel = $17.derived(() => ROLE_LABELS[message.role] ?? message.role);
+    const isToolCall = $17.derived(() => message.role === "tool-call");
+    const toolPair = $17.derived(() => {
+      if (!isToolCall() || !message.toolCall)
+        return null;
+      return toolCallPairs.find((pair) => pair.call.id === message.toolCall?.id) ?? null;
+    });
+    const messageParts = $17.derived(() => deriveMessageParts(message, {
+      toolCallPair: toolPair() ?? undefined,
+      overrideContent,
+      streaming,
+      expanded,
+      approvedToolCallIds,
+      deniedToolCallIds,
+      reasoning,
+      steps,
+      suggestions
+    }));
+    const hasMarkdownBody = $17.derived(() => messageParts().some((part) => part.type === "markdown"));
+    const bodyParts = $17.derived(() => messageParts().filter((part) => part.type !== "image"));
+    const imageParts = $17.derived(() => messageParts().filter((part) => part.type === "image"));
+    const TRUNCATE_THRESHOLD = 500;
+    const messageId = $17.derived(() => `message-${message.id}`);
+    const roleId = $17.derived(() => `${messageId()}-role`);
+    function toggleExpanded() {
+      expanded = !expanded;
+      onexpandedchange?.(expanded);
+    }
+    function toggleToolCallExpanded() {
+      toolCallExpanded = !toolCallExpanded;
+      ontoolcalltoggle?.();
+      onexpandedchange?.(toolCallExpanded);
+    }
+    $$renderer2.push(`<div${$17.attributes({
+      class: $17.clsx(classNames("chat-message-wrapper", className)),
+      "data-role": message.role,
+      "data-hidden": message.hidden || undefined,
+      "data-failed": isFailed() || undefined,
+      "data-search-match": searchMatch || undefined,
+      "data-tool-pair": isToolCall() && toolPair() ? "" : undefined,
+      ...rest
+    }, "svelte-1sxbmxn")}><article${$17.attr("id", messageId())} class="chat-message svelte-1sxbmxn"${$17.attr("aria-labelledby", isToolCall() && toolPair() ? undefined : roleId())}${$17.attr("aria-label", isToolCall() && toolPair() ? `Tool call: ${toolPair().call.name}` : undefined)}${$17.attr("tabindex", tabindex)}><header class="chat-message-header svelte-1sxbmxn"><span${$17.attr("id", roleId())} class="chat-message-role svelte-1sxbmxn">${$17.escape(roleLabel())}</span> `);
+    if (status) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-message-status svelte-1sxbmxn">`);
+      status($$renderer2);
+      $$renderer2.push(`<!----></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></header> <div class="chat-message-body svelte-1sxbmxn">`);
+    if (isEditing) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-message-edit svelte-1sxbmxn"><textarea class="chat-message-edit-textarea svelte-1sxbmxn" autofocus="" aria-label="Edit message content"${$17.attr("rows", Math.min(Math.max(editContent.split(`
+`).length, 2), 10))}>`);
+      const $$body = $17.escape(editContent);
+      if ($$body) {
+        $$renderer2.push(`${$$body}`);
+      } else {}
+      $$renderer2.push(`</textarea> <div class="chat-message-edit-actions svelte-1sxbmxn"><button type="button" class="chat-message-edit-save svelte-1sxbmxn">Save &amp; Resend</button> <button type="button" class="chat-message-edit-cancel svelte-1sxbmxn">Cancel</button></div></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      Chat_message_parts_renderer($$renderer2, {
+        parts: bodyParts(),
+        messagePart,
+        expanded: toolCallExpanded,
+        ontoggle: toggleToolCallExpanded,
+        onapprove,
+        ondeny,
+        reasoningExpanded,
+        onreasoning,
+        onsuggestionselect
+      });
+      $$renderer2.push(`<!----> `);
+      if (hasMarkdownBody() && textContent().length > TRUNCATE_THRESHOLD) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<button type="button" class="chat-message-expand svelte-1sxbmxn">${$17.escape(expanded ? "Show less" : "Show more")}</button>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></div> `);
+    if (imageParts().length > 0) {
+      $$renderer2.push("<!--[0-->");
+      Chat_message_parts_renderer($$renderer2, { parts: imageParts() });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (isFailed() && onretry) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-message-failed-actions svelte-1sxbmxn"><span class="chat-message-failed-label svelte-1sxbmxn" role="alert">Failed to send</span> <button type="button" class="chat-message-retry svelte-1sxbmxn">`);
+      Rotate_ccw($$renderer2, { class: "cinder-icon-xs" });
+      $$renderer2.push(`<!----> Retry</button></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></article> `);
+    if (actions || showDefaultActions && textContent() || canEdit()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<footer class="chat-message-footer svelte-1sxbmxn" role="none"><div class="chat-message-actions svelte-1sxbmxn" role="group" aria-label="Message actions">`);
+      if (actions) {
+        $$renderer2.push("<!--[0-->");
+        actions($$renderer2);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (showDefaultActions && textContent()) {
+        $$renderer2.push("<!--[0-->");
+        Copy_button($$renderer2, {
+          value: textContent(),
+          label: "Copy message",
+          copiedLabel: "Copied!",
+          iconOnly: true,
+          confirmDuration: 2000,
+          class: "chat-message-action-button chat-message-copy"
+        });
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (canEdit()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<button type="button" class="chat-message-action-button chat-message-edit-button" aria-label="Edit message">`);
+        Pencil($$renderer2, { class: "cinder-icon-xs" });
+        $$renderer2.push(`<!----></button>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div></footer>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $17.bind_props($$props, { expanded, toolCallExpanded });
+  }, Chat_message);
+}
+// src/components/chat/input/attachment-kind.ts
+var CODE_MIME_TYPES = new Set([
+  "application/json",
+  "application/javascript",
+  "application/typescript",
+  "application/xml",
+  "application/yaml",
+  "application/x-yaml",
+  "application/x-sh",
+  "application/sql",
+  "application/toml"
+]);
+function deriveAttachmentKind(mimeType) {
+  if (mimeType.startsWith("image/"))
+    return "image";
+  if (mimeType.startsWith("text/") || CODE_MIME_TYPES.has(mimeType))
+    return "code";
+  return "document";
+}
+// src/components/chat/input/chat-attachment-preview.svelte
+import * as $18 from "svelte/internal/server";
+function Chat_attachment_preview($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { attachment, class: className } = $$props;
+    const extension = $18.derived(() => attachment.file.name.includes(".") ? attachment.file.name.slice(attachment.file.name.lastIndexOf(".")) : "");
+    const truncatedName = $18.derived(() => {
+      const name = attachment.file.name;
+      const maxLength = 18;
+      if (name.length <= maxLength)
+        return name;
+      const ext = extension();
+      const base = name.slice(0, name.length - ext.length);
+      const availableLength = maxLength - ext.length - 1;
+      if (availableLength < 3)
+        return name.slice(0, maxLength - 1) + "…";
+      return base.slice(0, availableLength) + "…" + ext;
+    });
+    $$renderer2.push(`<div${$18.attr_class($18.clsx(classNames("chat-attachment-preview", className)), "svelte-1svhxp5")}${$18.attr("data-kind", attachment.kind)}${$18.attr("data-error", attachment.status === "error" || undefined)}${$18.attr("data-pending", attachment.status === "pending" || undefined)}>`);
+    if (attachment.kind === "image") {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<img${$18.attr("src", attachment.previewUrl)}${$18.attr("alt", attachment.file.name)} class="chat-attachment-preview-image svelte-1svhxp5"/>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<div class="chat-attachment-preview-file svelte-1svhxp5"><div class="chat-attachment-preview-icon svelte-1svhxp5">`);
+      if (attachment.kind === "code") {
+        $$renderer2.push("<!--[0-->");
+        File_code($$renderer2, { class: "cinder-icon-sm" });
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        File_text($$renderer2, { class: "cinder-icon-sm" });
+      }
+      $$renderer2.push(`<!--]--></div> <div class="chat-attachment-preview-info svelte-1svhxp5"><span class="chat-attachment-preview-name svelte-1svhxp5"${$18.attr("title", attachment.file.name)}>${$18.escape(truncatedName())}</span> <span class="chat-attachment-preview-meta svelte-1svhxp5">`);
+      if (extension()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="chat-attachment-preview-ext svelte-1svhxp5">${$18.escape(extension())}</span>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> <span class="chat-attachment-preview-size svelte-1svhxp5">${$18.escape(formatBytes(attachment.file.size))}</span></span></div></div>`);
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (attachment.status === "error") {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="chat-attachment-preview-error-badge svelte-1svhxp5"${$18.attr("aria-label", attachment.error ?? "Attachment error")}>!</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (attachment.status === "pending") {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-attachment-preview-loading svelte-1svhxp5" role="status" aria-label="Reading file"><div class="chat-attachment-preview-loading-bar svelte-1svhxp5"></div></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Chat_attachment_preview);
+}
+// src/components/chat/input/chat-input.svelte
+import * as $19 from "svelte/internal/server";
+import { onDestroy } from "svelte";
+
+// src/utilities/id-factory.ts
+function createIdFactory(prefix = "") {
+  let counter = 0;
+  return {
+    next() {
+      return `${prefix}-${++counter}`;
+    },
+    reset() {
+      counter = 0;
+    }
+  };
+}
+var defaultIdFactory = createIdFactory("cinder");
+function djb2Hex(value) {
+  let hash = 5381;
+  for (let index = 0;index < value.length; index++) {
+    hash = (hash << 5) + hash + value.charCodeAt(index) | 0;
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function useStableId(seed) {
+  if (seed === undefined) {
+    return defaultIdFactory.next();
+  }
+  return `id-${djb2Hex(seed)}`;
+}
+// src/components/chat/input/chat-input.svelte
+function Chat_input($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const attachmentIdFactory = createIdFactory("attachment");
+    const usedAttachmentIds = new Set;
+    let {
+      id,
+      value = "",
+      placeholder = "Type a message...",
+      composerLabel = "Message",
+      disabled = false,
+      sending = false,
+      error,
+      class: className,
+      action,
+      name = "content",
+      clearOnSubmit = true,
+      allowAttachments = true,
+      maxFileSize = 10 * 1024 * 1024,
+      acceptedTypes = [
+        "image/*",
+        "text/*",
+        "application/json",
+        "application/pdf",
+        "application/javascript",
+        "application/typescript",
+        "application/xml",
+        "application/yaml",
+        "application/x-yaml",
+        "application/x-sh",
+        "application/sql",
+        "application/toml"
+      ],
+      onsubmit,
+      onstop,
+      onattachmentadd,
+      onattachmentremove,
+      onattachmentfailure,
+      actions,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const resolvedComposerLabel = $19.derived(() => composerLabel.trim() || "Message");
+    const showStopButton = $19.derived(() => sending && onstop !== undefined);
+    let formElement = null;
+    let editorElement = null;
+    let fileInputRef = null;
+    let attachments = [];
+    let isDragOver = false;
+    let isComposing = false;
+    const announcer = useAnnouncer();
+    const errorId = $19.derived(() => `${id}-error`);
+    const hintId = $19.derived(() => `${id}-hint`);
+    const shortcutDescriptionId = $19.derived(() => `${id}-shortcut-description`);
+    const isWhitespaceOnly = $19.derived(() => value.trim().length === 0);
+    const hasPendingAttachments = $19.derived(() => attachments.some((a) => a.status === "pending" || a.status === "uploading"));
+    const canSubmit = $19.derived(() => !isWhitespaceOnly() && !disabled && !sending && !hasPendingAttachments());
+    const isFormActionMode = $19.derived(() => !!action);
+    function isValidType(file) {
+      return acceptedTypes.some((type) => {
+        if (type.endsWith("/*")) {
+          const category = type.slice(0, -2);
+          return file.type.startsWith(category);
+        }
+        return file.type === type;
+      });
+    }
+    const KIND_LABELS = { image: "Image", code: "Code file", document: "Document" };
+    function addAttachment(file) {
+      if (!isValidType(file)) {
+        onattachmentfailure?.(file, `Invalid file type: ${file.type}. Accepted types: ${acceptedTypes.join(", ")}.`);
+        return;
+      }
+      if (file.size > maxFileSize) {
+        const maxSizeMB = Math.round(maxFileSize / (1024 * 1024));
+        onattachmentfailure?.(file, `File exceeds ${maxSizeMB}MB limit`);
+        return;
+      }
+      const kind = deriveAttachmentKind(file.type);
+      let attachmentId = file.lastModified !== 0 ? useStableId(`${file.name}\x00${file.size}\x00${file.lastModified}`) : attachmentIdFactory.next();
+      if (usedAttachmentIds.has(attachmentId)) {
+        attachmentId = `${attachmentId}-${attachmentIdFactory.next()}`;
+      }
+      usedAttachmentIds.add(attachmentId);
+      const attachment = {
+        id: attachmentId,
+        file,
+        previewUrl: URL.createObjectURL(file),
+        kind,
+        status: kind === "code" ? "pending" : "ready"
+      };
+      attachments = [...attachments, attachment];
+      onattachmentadd?.(attachment);
+      announcer.announce(`${KIND_LABELS[kind]} attached: ${file.name}`);
+      if (kind === "code") {
+        file.text().then((text) => {
+          attachments = attachments.map((a) => a.id === attachment.id ? { ...a, textContent: text, status: "ready" } : a);
+        }, () => {
+          attachments = attachments.map((a) => a.id === attachment.id ? { ...a, status: "error", error: "Failed to read file" } : a);
+        });
+      }
+    }
+    function removeAttachment(attachmentId) {
+      const attachment = attachments.find((a) => a.id === attachmentId);
+      if (attachment) {
+        URL.revokeObjectURL(attachment.previewUrl);
+        attachments = attachments.filter((a) => a.id !== attachmentId);
+        onattachmentremove?.(attachment);
+        announcer.announce(`${KIND_LABELS[attachment.kind]} removed`);
+      }
+    }
+    function handleFileSelect(event) {
+      const input = event.target;
+      const files = input.files;
+      if (files) {
+        Array.from(files).forEach(addAttachment);
+      }
+      input.value = "";
+    }
+    function handlePaste(event) {
+      if (!allowAttachments)
+        return;
+      const items = event.clipboardData?.items;
+      if (!items)
+        return;
+      const files = [];
+      for (const item of items) {
+        if (item.kind === "file") {
+          const file = item.getAsFile();
+          if (file) {
+            files.push(file);
+          }
+        }
+      }
+      if (files.length > 0) {
+        event.preventDefault();
+        files.forEach(addAttachment);
+      }
+    }
+    function handleDrop(event) {
+      isDragOver = false;
+      if (!allowAttachments)
+        return;
+      event.preventDefault();
+      event.stopPropagation();
+      const files = event.dataTransfer?.files;
+      if (files) {
+        Array.from(files).forEach(addAttachment);
+      }
+    }
+    function handleDragOver(event) {
+      if (!allowAttachments)
+        return;
+      event.preventDefault();
+      isDragOver = true;
+    }
+    function handleDragLeave(event) {
+      if (!formElement?.contains(event.relatedTarget)) {
+        isDragOver = false;
+      }
+    }
+    function handleSubmit(event) {
+      if (!canSubmit()) {
+        event.preventDefault();
+        return;
+      }
+      const latestContent = editorElement?.value ?? value;
+      const trimmedContent = latestContent.trim();
+      if (trimmedContent.length === 0) {
+        event.preventDefault();
+        return;
+      }
+      const message = { role: "user", content: trimmedContent };
+      const readyAttachments = attachments.filter((a) => a.status === "ready");
+      onsubmit?.(message, readyAttachments);
+      if (!isFormActionMode()) {
+        event.preventDefault();
+        if (clearOnSubmit) {
+          value = "";
+          attachments.forEach((a) => URL.revokeObjectURL(a.previewUrl));
+          attachments = [];
+        }
+        editorElement?.focus();
+        announcer.announce("Message sent");
+      } else {
+        value = trimmedContent;
+      }
+    }
+    function handleKeyDown(event) {
+      if (event.isComposing || isComposing) {
+        return;
+      }
+      if (event.key === "Enter" && event.shiftKey) {
+        return;
+      }
+      if (event.key === "Enter" && !event.metaKey && !event.ctrlKey && !event.altKey) {
+        event.preventDefault();
+        if (canSubmit()) {
+          formElement?.requestSubmit();
+        }
+      }
+    }
+    function handleCompositionStart() {
+      isComposing = true;
+    }
+    function handleCompositionEnd() {
+      isComposing = false;
+    }
+    function focus() {
+      editorElement?.focus();
+    }
+    function clear() {
+      value = "";
+      attachments.forEach((a) => URL.revokeObjectURL(a.previewUrl));
+      attachments = [];
+    }
+    function getAttachments() {
+      return [...attachments];
+    }
+    function addFiles(files) {
+      if (!allowAttachments)
+        return;
+      files.forEach(addAttachment);
+    }
+    onDestroy(() => {
+      attachments.forEach((a) => URL.revokeObjectURL(a.previewUrl));
+    });
+    $$renderer2.push(`<form${$19.attributes({
+      class: $19.clsx(classNames("chat-input", isDragOver && "chat-input-dragover", className)),
+      method: "POST",
+      action,
+      "aria-label": "Chat message composer",
+      "aria-busy": sending || undefined,
+      ...rest
+    }, "svelte-1tzweuh")}>`);
+    if (isFormActionMode()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<input type="hidden"${$19.attr("name", name)}${$19.attr("value", value)}/>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (attachments.length > 0) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-input-attachments svelte-1tzweuh" role="list" aria-label="Attached files"><!--[-->`);
+      const each_array = $19.ensure_array_like(attachments);
+      for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+        let attachment = each_array[$$index];
+        $$renderer2.push(`<div class="chat-input-attachment-wrapper svelte-1tzweuh" role="listitem">`);
+        Chat_attachment_preview($$renderer2, { attachment });
+        $$renderer2.push(`<!----> <button type="button" class="chat-input-attachment-remove svelte-1tzweuh"${$19.attr("aria-label", `Remove ${attachment.file.name}`)}>`);
+        X($$renderer2, { class: "cinder-icon-xs" });
+        $$renderer2.push(`<!----></button></div>`);
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="chat-input-editor-container svelte-1tzweuh"><textarea${$19.attr("id", `${id}-editor`)}${$19.attr("placeholder", placeholder)}${$19.attr("aria-label", resolvedComposerLabel())}${$19.attr("disabled", disabled, true)}${$19.attr("readonly", sending, true)} class="chat-input-editor svelte-1tzweuh"${$19.attr("aria-describedby", shortcutDescriptionId())} rows="1">`);
+    const $$body = $19.escape(value);
+    if ($$body) {
+      $$renderer2.push(`${$$body}`);
+    } else {}
+    $$renderer2.push(`</textarea></div> <div class="chat-input-footer svelte-1tzweuh"><div class="chat-input-footer-left svelte-1tzweuh">`);
+    if (allowAttachments) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<input${$19.attr("id", `${id}-file-picker`)} type="file"${$19.attr("accept", acceptedTypes.join(","))} multiple="" class="sr-only svelte-1tzweuh" aria-label="Attach files"${$19.attr("tabindex", -1)}/> `);
+      Button($$renderer2, {
+        type: "button",
+        variant: "ghost",
+        size: "sm",
+        onclick: () => fileInputRef?.click(),
+        disabled: disabled || sending,
+        "aria-label": "Attach file",
+        children: ($$renderer3) => {
+          Paperclip($$renderer3, { class: "cinder-icon-sm" });
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <span${$19.attr("id", shortcutDescriptionId())} class="sr-only svelte-1tzweuh">`);
+    if (showStopButton()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`Response is streaming. Use the stop button to stop generation.`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`Press Enter to send, Shift+Enter for newline`);
+    }
+    $$renderer2.push(`<!--]--></span> `);
+    if (!showStopButton()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span${$19.attr("id", hintId())} class="chat-input-hint svelte-1tzweuh" aria-hidden="true"><kbd class="svelte-1tzweuh">Enter</kbd> to send, <kbd class="svelte-1tzweuh">Shift</kbd>+<kbd class="svelte-1tzweuh">Enter</kbd> for newline</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div> <div class="chat-input-footer-right svelte-1tzweuh">`);
+    if (actions) {
+      $$renderer2.push("<!--[0-->");
+      actions($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (showStopButton()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<button type="button" class="chat-input-send svelte-1tzweuh" data-stop="" aria-label="Stop generating"${$19.attr("aria-describedby", shortcutDescriptionId())}>`);
+      Square($$renderer2, { class: "cinder-icon-sm" });
+      $$renderer2.push(`<!----></button>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<button type="submit" class="chat-input-send svelte-1tzweuh"${$19.attr("disabled", !canSubmit(), true)}${$19.attr("aria-label", sending ? "Sending message" : "Send message")}${$19.attr("aria-describedby", shortcutDescriptionId())}>`);
+      if (sending) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<svg class="chat-input-spinner svelte-1tzweuh" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" aria-hidden="true"><circle class="spinner-track svelte-1tzweuh" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="spinner-head svelte-1tzweuh" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        Arrow_up($$renderer2, { class: "cinder-icon-sm" });
+      }
+      $$renderer2.push(`<!--]--></button>`);
+    }
+    $$renderer2.push(`<!--]--></div></div> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$19.attr("id", errorId())} class="chat-input-error svelte-1tzweuh" role="alert">${$19.escape(error)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div aria-live="polite" aria-atomic="true" class="sr-only svelte-1tzweuh">${$19.escape(announcer.message)}</div></form>`);
+    $19.bind_props($$props, { value, focus, clear, getAttachments, addFiles });
+  }, Chat_input);
+}
+// src/components/chat/container/scroll-utilities.ts
+var DEFAULT_SCROLL_CONFIGURATION = {
+  bottomThreshold: 150,
+  jumpThreshold: 200
+};
+function isAtBottom(state, threshold) {
+  const distanceFromBottom = state.scrollHeight - state.scrollTop - state.clientHeight;
+  return distanceFromBottom <= threshold || state.scrollHeight <= state.clientHeight;
+}
+function shouldShowJumpToLatest(state, threshold) {
+  const distanceFromBottom = state.scrollHeight - state.scrollTop - state.clientHeight;
+  if (state.scrollHeight <= state.clientHeight) {
+    return false;
+  }
+  return distanceFromBottom > threshold;
+}
+function getMessageTimestamp(message) {
+  if (message.createdAt) {
+    const parsed = Date.parse(message.createdAt);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  const metaTimestamp = message.metadata?.["timestamp"];
+  if (typeof metaTimestamp === "number") {
+    return metaTimestamp;
+  }
+  if (typeof metaTimestamp === "string") {
+    const parsed = Date.parse(metaTimestamp);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return null;
+}
+function calculateUnreadCount(messages, lastReadTimestamp) {
+  if (lastReadTimestamp === 0) {
+    return 0;
+  }
+  return messages.filter((message) => {
+    const timestamp = getMessageTimestamp(message);
+    return timestamp != null && timestamp > lastReadTimestamp;
+  }).length;
+}
+function findUnreadBoundaryIndex(messages, lastReadTimestamp) {
+  if (lastReadTimestamp === 0) {
+    return -1;
+  }
+  return messages.findIndex((message) => {
+    const timestamp = getMessageTimestamp(message);
+    return timestamp != null && timestamp > lastReadTimestamp;
+  });
+}
+function calculateScrollToBottom(state) {
+  return Math.max(0, state.scrollHeight - state.clientHeight);
+}
+function formatUnreadCount(count) {
+  if (count <= 0)
+    return "";
+  if (count > 99)
+    return "99+";
+  return count.toString();
+}
+function isLargeCount(count) {
+  return count > 99;
+}
+function extractTimestamp(message) {
+  return getMessageTimestamp(message) ?? Date.now();
+}
+
+// src/components/chat/container/use-chat-scroll-state.svelte.ts
+import * as $20 from "svelte/internal/server";
+var destroy = () => {};
+function useChatScrollState(options) {
+  const {
+    bottomThreshold = DEFAULT_SCROLL_CONFIGURATION.bottomThreshold,
+    getBottomThreshold,
+    jumpThreshold = DEFAULT_SCROLL_CONFIGURATION.jumpThreshold,
+    getJumpThreshold,
+    onScrollStateChange,
+    onReachBottom
+  } = options ?? {};
+  const reducedMotion = useReducedMotion();
+  function getScrollBehavior() {
+    return reducedMotion.current ? "auto" : "smooth";
+  }
+  let atBottom = true;
+  let showJumpButton = false;
+  let scrollTicking = false;
+  let isUserScrolling = false;
+  let activeForcedLayoutCancel = null;
+  function setAtBottom(value) {
+    atBottom = value;
+  }
+  function createScrollAttachment() {
+    return (element) => {
+      function handleScroll() {
+        if (scrollTicking)
+          return;
+        scrollTicking = true;
+        requestAnimationFrame(() => {
+          const state = {
+            scrollTop: element.scrollTop,
+            scrollHeight: element.scrollHeight,
+            clientHeight: element.clientHeight
+          };
+          const scrolledToBottom = isAtBottom(state, getBottomThreshold?.() ?? bottomThreshold);
+          const shouldShowJump = shouldShowJumpToLatest(state, getJumpThreshold?.() ?? jumpThreshold);
+          atBottom = scrolledToBottom;
+          showJumpButton = shouldShowJump;
+          if (scrolledToBottom) {
+            onReachBottom?.();
+          }
+          onScrollStateChange?.({
+            atBottom: scrolledToBottom,
+            scrollTop: state.scrollTop,
+            scrollHeight: state.scrollHeight
+          });
+          scrollTicking = false;
+        });
+      }
+      element.addEventListener("scroll", handleScroll, { passive: true });
+      return () => element.removeEventListener("scroll", handleScroll);
+    };
+  }
+  function handleSentinelEntry(entry) {
+    const sentinelVisible = entry.isIntersecting;
+    if (sentinelVisible && !atBottom) {
+      atBottom = true;
+      onReachBottom?.();
+    }
+  }
+  function createSentinelObserver(viewport, sentinel) {
+    if (!viewport || !sentinel)
+      return;
+    const observer = new IntersectionObserver(([entry]) => {
+      if (!entry)
+        return;
+      handleSentinelEntry(entry);
+    }, {
+      root: viewport,
+      threshold: 0,
+      rootMargin: `0px 0px ${getBottomThreshold?.() ?? bottomThreshold}px 0px`
+    });
+    observer.observe(sentinel);
+    return () => observer.disconnect();
+  }
+  function withForcedLayout(viewport, scroll) {
+    activeForcedLayoutCancel?.();
+    viewport.setAttribute("data-cinder-force-visible", "");
+    viewport.offsetHeight;
+    let settled = false;
+    let backstop;
+    const backstopDuration = reducedMotion.current ? 50 : 500;
+    function cancel() {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(backstop);
+      viewport.removeEventListener("scrollend", restore);
+      viewport.removeEventListener("scroll", armBackstop);
+    }
+    const restore = () => {
+      if (settled)
+        return;
+      cancel();
+      activeForcedLayoutCancel = null;
+      viewport.removeAttribute("data-cinder-force-visible");
+    };
+    function armBackstop() {
+      clearTimeout(backstop);
+      backstop = setTimeout(restore, backstopDuration);
+    }
+    activeForcedLayoutCancel = cancel;
+    viewport.addEventListener("scrollend", restore, { once: true });
+    viewport.addEventListener("scroll", armBackstop, { passive: true });
+    armBackstop();
+    scroll();
+  }
+  function scrollToBottom(viewport) {
+    if (!viewport)
+      return;
+    withForcedLayout(viewport, () => {
+      viewport.scrollTo({ top: viewport.scrollHeight, behavior: getScrollBehavior() });
+    });
+  }
+  function scrollToTop(viewport) {
+    viewport?.scrollTo({ top: 0, behavior: getScrollBehavior() });
+  }
+  function jumpToLatest(viewport, onComplete) {
+    if (!viewport)
+      return;
+    isUserScrolling = true;
+    withForcedLayout(viewport, () => {
+      viewport.scrollTo({ top: viewport.scrollHeight, behavior: getScrollBehavior() });
+    });
+    onReachBottom?.();
+    onComplete?.();
+    const scrollDuration = reducedMotion.current ? 50 : 500;
+    setTimeout(() => {
+      isUserScrolling = false;
+      const wrappers = viewport.querySelectorAll(".chat-message-wrapper");
+      const lastWrapper = wrappers.length > 0 ? wrappers[wrappers.length - 1] : null;
+      const lastMessage = lastWrapper?.querySelector(".chat-message") ?? null;
+      lastMessage?.focus();
+    }, scrollDuration);
+  }
+  return {
+    get atBottom() {
+      return atBottom;
+    },
+    get showJumpButton() {
+      return showJumpButton;
+    },
+    setAtBottom,
+    createScrollAttachment,
+    createSentinelObserver,
+    handleSentinelEntry,
+    scrollToBottom,
+    scrollToTop,
+    jumpToLatest,
+    getScrollBehavior,
+    destroy,
+    get isUserScrolling() {
+      return isUserScrolling;
+    }
+  };
+}
+
+// src/components/chat/container/use-chat-unread-state.svelte.ts
+import * as $21 from "svelte/internal/server";
+import { untrack } from "svelte";
+function useChatUnreadState(options) {
+  const { announcerDebounceMs = 300, onUnreadIndicatorChange } = options ?? {};
+  let unreadCount = 0;
+  let newMessageIndicatorVisible = false;
+  let firstUnreadId = null;
+  let previousMessageCount = 0;
+  let previousLastMessageId = null;
+  let previousConversationId = null;
+  const announcer = useAnnouncer({ debounceMs: announcerDebounceMs });
+  const displayUnreadCount = $21.derived(() => formatUnreadCount(unreadCount));
+  const hasLargeCount = $21.derived(() => isLargeCount(unreadCount));
+  function notifyIndicatorChange() {
+    onUnreadIndicatorChange?.({ unreadCount, newMessageIndicatorVisible });
+  }
+  function markAllAsRead() {
+    const changed = unreadCount !== 0 || newMessageIndicatorVisible;
+    unreadCount = 0;
+    newMessageIndicatorVisible = false;
+    firstUnreadId = null;
+    if (changed)
+      notifyIndicatorChange();
+  }
+  function processMessages(messages, conversationId, getAtBottom) {
+    if (conversationId !== previousConversationId) {
+      previousMessageCount = messages.length;
+      previousLastMessageId = messages.at(-1)?.id ?? null;
+      previousConversationId = conversationId;
+      markAllAsRead();
+      return;
+    }
+    const currentCount = messages.length;
+    const prevCount = previousMessageCount;
+    const currentLastMessageId = messages.at(-1)?.id ?? null;
+    const wasAppended = currentCount > prevCount && prevCount > 0 && currentLastMessageId !== null && currentLastMessageId !== previousLastMessageId;
+    if (wasAppended) {
+      const atBottom = untrack(getAtBottom);
+      if (!atBottom) {
+        const newMessageCount = currentCount - prevCount;
+        unreadCount += newMessageCount;
+        newMessageIndicatorVisible = true;
+        if (firstUnreadId === null) {
+          const firstNewIndex = currentCount - newMessageCount;
+          const firstNewMessage = messages[firstNewIndex];
+          if (firstNewMessage) {
+            firstUnreadId = firstNewMessage.id;
+          }
+        }
+        announcer.announce(unreadCount === 1 ? "New message received" : `${unreadCount} new messages received`);
+        notifyIndicatorChange();
+      }
+    }
+    previousMessageCount = currentCount;
+    previousLastMessageId = currentLastMessageId;
+  }
+  function destroy2() {
+    announcer.destroy();
+  }
+  return {
+    get unreadCount() {
+      return unreadCount;
+    },
+    get newMessageIndicatorVisible() {
+      return newMessageIndicatorVisible;
+    },
+    get firstUnreadId() {
+      return firstUnreadId;
+    },
+    get displayUnreadCount() {
+      return displayUnreadCount();
+    },
+    get hasLargeCount() {
+      return hasLargeCount();
+    },
+    get announcerMessage() {
+      return announcer.message;
+    },
+    markAllAsRead,
+    processMessages,
+    destroy: destroy2
+  };
+}
+
+// src/components/chat/container/use-chat-keyboard-nav.svelte.ts
+import * as $22 from "svelte/internal/server";
+import { tick } from "svelte";
+function useChatKeyboardNav(options) {
+  const {
+    onJumpToLatest,
+    onJumpToStart,
+    getScrollBehavior,
+    getHistoryTrigger,
+    onVirtualMessageNavigation
+  } = options;
+  function navigateMessages(viewport, direction) {
+    const allMessages = viewport.querySelectorAll(".chat-message");
+    if (allMessages.length === 0)
+      return;
+    const currentIndex = Array.from(allMessages).findIndex((msg) => msg === document.activeElement);
+    let targetIndex;
+    if (currentIndex === -1) {
+      targetIndex = direction === "next" ? 0 : allMessages.length - 1;
+    } else if (direction === "next") {
+      targetIndex = currentIndex < allMessages.length - 1 ? currentIndex + 1 : currentIndex;
+    } else {
+      targetIndex = currentIndex > 0 ? currentIndex - 1 : currentIndex;
+    }
+    const targetMessage = allMessages[targetIndex];
+    if (targetMessage && targetMessage !== document.activeElement) {
+      targetMessage.focus();
+      targetMessage.scrollIntoView({ behavior: getScrollBehavior(), block: "nearest" });
+    }
+  }
+  const TEXT_EDITING_SELECTOR = "input, textarea, select, [contenteditable]";
+  function handleKeyDown(event, viewport) {
+    if (!viewport)
+      return;
+    if (document.activeElement?.closest(".chat-input") || document.activeElement?.matches(TEXT_EDITING_SELECTOR))
+      return;
+    const behavior = getScrollBehavior();
+    switch (event.key) {
+      case "End":
+        event.preventDefault();
+        onJumpToLatest();
+        break;
+      case "Home":
+        event.preventDefault();
+        if (onJumpToStart) {
+          onJumpToStart();
+        } else {
+          viewport.scrollTo({ top: 0, behavior });
+        }
+        tick().then(() => {
+          const historyTrigger = getHistoryTrigger?.();
+          if (historyTrigger) {
+            historyTrigger.focus();
+          } else {
+            const firstMessage = viewport.querySelector(".chat-message");
+            firstMessage?.focus();
+          }
+          return;
+        }, () => {
+          return;
+        });
+        break;
+      case "PageDown":
+        event.preventDefault();
+        viewport.scrollBy({ top: viewport.clientHeight * 0.9, behavior });
+        break;
+      case "PageUp":
+        event.preventDefault();
+        viewport.scrollBy({ top: -viewport.clientHeight * 0.9, behavior });
+        break;
+      case "ArrowDown":
+        if (document.activeElement?.classList.contains("chat-message")) {
+          event.preventDefault();
+          if (!onVirtualMessageNavigation?.("next")) {
+            navigateMessages(viewport, "next");
+          }
+        }
+        break;
+      case "ArrowUp":
+        if (document.activeElement?.classList.contains("chat-message")) {
+          event.preventDefault();
+          if (!onVirtualMessageNavigation?.("previous")) {
+            navigateMessages(viewport, "previous");
+          }
+        }
+        break;
+    }
+  }
+  return { handleKeyDown };
+}
+
+// src/components/chat/container/use-chat-search.svelte.ts
+import * as $23 from "svelte/internal/server";
+function useChatSearch(options) {
+  const { getMessages: getMessages2 } = options;
+  let query = "";
+  let isOpen = false;
+  let currentMatchIndex = 0;
+  const matches = $23.derived(() => {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery)
+      return [];
+    const lowercasedQuery = trimmedQuery.toLowerCase();
+    const messages = getMessages2();
+    return messages.map((message, messageIndex) => ({ message, messageIndex })).filter(({ message }) => getMessageText(message).toLowerCase().includes(lowercasedQuery));
+  });
+  const matchCount = $23.derived(() => matches().length);
+  const clampedMatchIndex = $23.derived(() => matchCount() > 0 ? Math.min(currentMatchIndex, matchCount() - 1) : 0);
+  const currentMatch = $23.derived(() => matches()[clampedMatchIndex()] ?? null);
+  function open() {
+    isOpen = true;
+  }
+  function close() {
+    isOpen = false;
+    query = "";
+    currentMatchIndex = 0;
+  }
+  function nextMatch() {
+    if (matchCount() > 0) {
+      currentMatchIndex = (clampedMatchIndex() + 1) % matchCount();
+    }
+  }
+  function previousMatch() {
+    if (matchCount() > 0) {
+      currentMatchIndex = (clampedMatchIndex() - 1 + matchCount()) % matchCount();
+    }
+  }
+  function setQuery(value) {
+    query = value;
+    currentMatchIndex = 0;
+  }
+  return {
+    get query() {
+      return query;
+    },
+    get isOpen() {
+      return isOpen;
+    },
+    get matches() {
+      return matches();
+    },
+    get matchCount() {
+      return matchCount();
+    },
+    get currentMatch() {
+      return currentMatch();
+    },
+    get currentMatchIndex() {
+      return clampedMatchIndex();
+    },
+    open,
+    close,
+    nextMatch,
+    previousMatch,
+    setQuery
+  };
+}
+
+// src/components/chat/container/chat-jump-controls.svelte
+import * as $24 from "svelte/internal/server";
+function Chat_jump_controls($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      showJumpButton,
+      hasNewMessageIndicator,
+      unreadCount,
+      displayUnreadCount,
+      hasLargeCount,
+      onjumptolatest
+    } = $$props;
+    function handleJump() {
+      onjumptolatest?.();
+    }
+    if (showJumpButton) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<button type="button" class="chat-jump-button svelte-1ornxh"${$24.attr("aria-label", unreadCount > 0 ? `Jump to ${unreadCount} new message${unreadCount !== 1 ? "s" : ""}` : "Jump to latest")}>`);
+      Chevron_down($$renderer2, { class: "cinder-icon-sm" });
+      $$renderer2.push(`<!----> `);
+      if (unreadCount > 0) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="chat-jump-badge svelte-1ornxh"${$24.attr("data-large", hasLargeCount || undefined)}>${$24.escape(displayUnreadCount)}</span>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></button>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (hasNewMessageIndicator && !showJumpButton) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<button type="button" class="chat-new-indicator svelte-1ornxh"${$24.attr("aria-label", `Jump to ${$24.stringify(displayUnreadCount)} new message${unreadCount !== 1 ? "s" : ""}`)}>`);
+      Chevron_down($$renderer2, { class: "cinder-icon-xs" });
+      $$renderer2.push(`<!----> <span aria-hidden="true">${$24.escape(displayUnreadCount)} new message${$24.escape(unreadCount !== 1 ? "s" : "")}</span></button>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  }, Chat_jump_controls);
+}
+
+// src/components/chat/container/chat-history-trigger.svelte
+import * as $25 from "svelte/internal/server";
+function Chat_history_trigger($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      loading = false,
+      label = "Load earlier messages",
+      loadingLabel = "Loading earlier messages",
+      onload
+    } = $$props;
+    let buttonElement = null;
+    const buttonAttachment = (node) => {
+      buttonElement = node;
+      return () => {
+        if (buttonElement === node) {
+          buttonElement = null;
+        }
+      };
+    };
+    function focus(options = undefined) {
+      buttonElement?.focus(options);
+    }
+    $$renderer2.push(`<div class="chat-history-trigger svelte-y4b3t5" data-cinder-history-trigger=""><button type="button" class="chat-history-trigger-button svelte-y4b3t5"${$25.attr("disabled", loading, true)}${$25.attr("aria-busy", loading ? "true" : undefined)}>${$25.escape(loading ? loadingLabel : label)}</button> `);
+    if (loading) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="sr-only svelte-y4b3t5" role="status">${$25.escape(loadingLabel)}</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+    $25.bind_props($$props, { focus });
+  }, Chat_history_trigger);
+}
+
+// src/components/chat/container/chat-status-announcer.svelte
+import * as $26 from "svelte/internal/server";
+function Chat_status_announcer($$renderer, $$props) {
+  let { statusId, messageCount, announcerMessage, assertiveMessage } = $$props;
+  $$renderer.push(`<div${$26.attr("id", statusId)} class="cinder-sr-only">${$26.escape(messageCount)} messages in conversation</div> <div class="cinder-sr-only" aria-live="polite" aria-atomic="true">${$26.escape(announcerMessage)}</div> <div class="cinder-sr-only" aria-live="assertive" aria-atomic="true">${$26.escape(assertiveMessage ?? "")}</div>`);
+}
+
+// src/components/chat/container/chat-search-bar.svelte
+import * as $27 from "svelte/internal/server";
+function Chat_search_bar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      instanceId,
+      query,
+      matchCount,
+      currentMatchIndex,
+      onquerychange,
+      onnext,
+      onprevious,
+      onclose
+    } = $$props;
+    const searchResultsId = $27.derived(() => `${instanceId}-search-results`);
+    let inputElement = null;
+    const autoFocus = (element) => {
+      element.focus();
+      inputElement = element;
+    };
+    function focusInput() {
+      inputElement?.focus();
+    }
+    const matchLabel = $27.derived(() => {
+      if (!query.trim())
+        return "";
+      if (matchCount === 0)
+        return "No matches";
+      return `${currentMatchIndex + 1} of ${matchCount}`;
+    });
+    const hasQuery = $27.derived(() => query.trim().length > 0);
+    function handleInput(event) {
+      const target = event.currentTarget;
+      onquerychange(target.value);
+    }
+    function handleKeyDown(event) {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onclose();
+      } else if (event.key === "Enter" && matchCount > 0) {
+        event.preventDefault();
+        if (event.shiftKey) {
+          onprevious();
+        } else {
+          onnext();
+        }
+      }
+    }
+    $$renderer2.push(`<div class="chat-search-bar svelte-13rzt40" role="search" aria-label="Search messages"><span class="chat-search-icon svelte-13rzt40" aria-hidden="true">`);
+    Search($$renderer2, { class: "cinder-icon-sm" });
+    $$renderer2.push(`<!----></span> <input type="search" class="chat-search-input svelte-13rzt40" placeholder="Search messages…"${$27.attr("value", query)} autocomplete="off" aria-label="Search messages"${$27.attr("aria-controls", hasQuery() ? searchResultsId() : undefined)}/> `);
+    if (hasQuery()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span${$27.attr("id", searchResultsId())} class="chat-search-match-count svelte-13rzt40" aria-live="polite" aria-atomic="true">${$27.escape(matchLabel())}</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="chat-search-navigation svelte-13rzt40" role="group" aria-label="Navigate search results"><button type="button" class="chat-search-nav-button svelte-13rzt40"${$27.attr("disabled", matchCount === 0, true)} aria-label="Previous match" title="Previous match (Shift+Enter)">`);
+    Chevron_up($$renderer2, { class: "cinder-icon-sm" });
+    $$renderer2.push(`<!----></button> <button type="button" class="chat-search-nav-button svelte-13rzt40"${$27.attr("disabled", matchCount === 0, true)} aria-label="Next match" title="Next match (Enter)">`);
+    Chevron_down($$renderer2, { class: "cinder-icon-sm" });
+    $$renderer2.push(`<!----></button></div> <button type="button" class="chat-search-close svelte-13rzt40" aria-label="Close search" title="Close search (Escape)">`);
+    X($$renderer2, { class: "cinder-icon-sm" });
+    $$renderer2.push(`<!----></button></div>`);
+    $27.bind_props($$props, { focusInput });
+  }, Chat_search_bar);
+}
+
+// src/components/chat/container/use-chat-message-groups.svelte.ts
+import * as $28 from "svelte/internal/server";
+function findPairedToolResultIds(messages) {
+  const visibleToolCallIds = new Set;
+  const pairedResultIds = new Set;
+  for (const message of messages) {
+    if (message.role === "tool-call" && message.toolCall) {
+      visibleToolCallIds.add(message.toolCall.id);
+    }
+  }
+  for (const message of messages) {
+    if (message.role === "tool-result" && message.toolResult && visibleToolCallIds.has(message.toolResult.callId)) {
+      pairedResultIds.add(message.id);
+    }
+  }
+  return pairedResultIds;
+}
+function buildMessagesWithDateSeparators(messages, pairedToolResultIds) {
+  const result = [];
+  let lastDate = null;
+  for (const message of messages) {
+    if (message.role === "tool-result" && pairedToolResultIds.has(message.id)) {
+      continue;
+    }
+    const timestamp = message.createdAt ?? message.metadata?.["timestamp"];
+    if (timestamp != null) {
+      const messageDate = new Date(timestamp);
+      const isValidDate = !isNaN(messageDate.getTime());
+      if (isValidDate) {
+        const dateKey = messageDate.toDateString();
+        if (dateKey !== lastDate) {
+          result.push({ type: "date", date: messageDate });
+          lastDate = dateKey;
+        }
+      }
+    }
+    result.push({ type: "message", message });
+  }
+  return result;
+}
+function buildChatRenderRows(items, options) {
+  const rows = [];
+  const firstUnreadId = options?.firstUnreadId ?? null;
+  let previousMessageId = null;
+  for (const item of items) {
+    if (item.type === "message") {
+      if (item.message.id === firstUnreadId) {
+        rows.push({ type: "unread-divider", afterMessageId: previousMessageId });
+      }
+      previousMessageId = item.message.id;
+    }
+    rows.push(item);
+  }
+  if (options?.showTypingIndicator) {
+    rows.push({ type: "typing" });
+  }
+  return rows;
+}
+function chatRenderRowKey(row) {
+  switch (row.type) {
+    case "date":
+      return `date-${row.date.toISOString()}`;
+    case "message":
+      return `msg-${row.message.id}`;
+    case "unread-divider":
+      return `unread-${row.afterMessageId ?? "start"}`;
+    case "typing":
+      return "typing";
+  }
+}
+function findRenderRowIndexByMessageId(rows, messageId) {
+  return rows.findIndex((row) => row.type === "message" && row.message.id === messageId);
+}
+
+// src/components/chat/container/use-chat-virtualizer.svelte.ts
+import * as $29 from "svelte/internal/server";
+class ChatVirtualizer {
+  options;
+  #scrollElement = null;
+  #scrollOffset = 0;
+  #measurementVersion = 0;
+  #offsetsCache = null;
+  #offsetsCacheCount = -1;
+  #offsetsCacheMeasurementVersion = -1;
+  #measuredSizes = new Map;
+  constructor(options) {
+    this.options = options;
+  }
+  get virtualItems() {
+    return this.#virtualItems();
+  }
+  get totalSize() {
+    const offsets = this.#offsets();
+    return offsets[offsets.length - 1] ?? 0;
+  }
+  get scrollPaddingStart() {
+    return this.#scrollPaddingStart();
+  }
+  get scrollSize() {
+    return this.scrollPaddingStart + this.totalSize;
+  }
+  get scrollOffset() {
+    return this.#scrollOffset;
+  }
+  setScrollElement(element) {
+    if (this.#scrollElement === element)
+      return;
+    this.#scrollElement?.removeEventListener("scroll", this.#handleScroll);
+    this.#scrollElement = element;
+    this.#scrollOffset = element?.scrollTop ?? 0;
+    this.#scrollElement?.addEventListener("scroll", this.#handleScroll, { passive: true });
+  }
+  scrollElement = (node) => {
+    this.setScrollElement(node);
+    return () => {
+      if (this.#scrollElement === node) {
+        this.setScrollElement(null);
+      }
+    };
+  };
+  measureElement = (node) => {
+    this.measureElementNode(node);
+    if (typeof ResizeObserver !== "function")
+      return;
+    const resizeObserver = new ResizeObserver(() => {
+      this.measureElementNode(node);
+    });
+    resizeObserver.observe(node);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  };
+  measureElementNode(node) {
+    if (!node)
+      return;
+    this.#measureNode(node);
+  }
+  syncOptions() {
+    const count = this.options.getCount();
+    const currentKeys = new Set;
+    for (let index = 0;index < count; index += 1) {
+      currentKeys.add(this.options.getItemKey(index));
+    }
+    let changed = false;
+    for (const key of this.#measuredSizes.keys()) {
+      if (!currentKeys.has(key)) {
+        this.#measuredSizes.delete(key);
+        changed = true;
+      }
+    }
+    if (changed)
+      this.#measurementVersion += 1;
+  }
+  scrollToIndex(index, options = { align: "auto" }) {
+    const count = this.options.getCount();
+    if (count === 0)
+      return;
+    const clampedIndex = Math.max(0, Math.min(Math.trunc(index), count - 1));
+    const offsets = this.#offsets();
+    const itemStart = offsets[clampedIndex] ?? 0;
+    const itemEnd = offsets[clampedIndex + 1] ?? itemStart + this.#estimatedSize();
+    const itemSize = itemEnd - itemStart;
+    const viewportHeight = this.#containerHeight();
+    const paddingStart = this.#scrollPaddingStart();
+    const viewportStart = Math.max(0, this.scrollOffset - paddingStart);
+    const viewportEnd = viewportStart + viewportHeight;
+    let offset = itemStart + paddingStart;
+    if (options.align === "end") {
+      offset = itemEnd + paddingStart - viewportHeight;
+    } else if (options.align === "center") {
+      offset = itemStart + paddingStart - (viewportHeight - itemSize) / 2;
+    } else if (options.align === "auto") {
+      if (itemStart >= viewportStart && itemEnd <= viewportEnd)
+        return;
+      offset = itemStart < viewportStart ? itemStart + paddingStart : itemEnd + paddingStart - viewportHeight;
+    }
+    this.scrollToOffset(offset, options);
+  }
+  getVirtualItem(index) {
+    const count = this.options.getCount();
+    if (count === 0)
+      return null;
+    const clampedIndex = Math.max(0, Math.min(Math.trunc(index), count - 1));
+    return this.#virtualItemAt(clampedIndex, this.#offsets());
+  }
+  scrollToOffset(offset, options) {
+    const element = this.#getScrollElement();
+    const maximumOffset = Math.max(0, this.scrollSize - this.#containerHeight());
+    const top = Math.min(maximumOffset, Math.max(0, offset));
+    this.#scrollOffset = top;
+    if (element) {
+      const behavior = options?.behavior === "instant" ? "auto" : options?.behavior;
+      if (typeof element.scrollTo === "function" && behavior && behavior !== "auto") {
+        element.scrollTo({ top, behavior });
+        return;
+      }
+      element.scrollTop = top;
+      return;
+    }
+  }
+  #handleScroll = () => {
+    this.#scrollOffset = this.#scrollElement?.scrollTop ?? 0;
+  };
+  #getScrollElement() {
+    return this.#scrollElement ?? this.options.getScrollElement();
+  }
+  #containerHeight() {
+    const element = this.#getScrollElement();
+    return element?.clientHeight || this.options.getInitialHeight();
+  }
+  #scrollPaddingStart() {
+    return Math.max(0, this.options.getScrollPaddingStart?.() ?? 0);
+  }
+  #estimatedSize() {
+    return Math.max(1, this.options.getEstimatedSize());
+  }
+  #itemSize(index) {
+    const key = this.options.getItemKey(index);
+    return this.#measuredSizes.get(key) ?? this.#estimatedSize();
+  }
+  #offsets() {
+    const count = this.options.getCount();
+    const measurementVersion = this.#measurementVersion;
+    if (this.#offsetsCache && this.#offsetsCacheCount === count && this.#offsetsCacheMeasurementVersion === measurementVersion) {
+      return this.#offsetsCache;
+    }
+    const offsets = Array.from({ length: count + 1 });
+    let offset = 0;
+    offsets[0] = 0;
+    for (let index = 0;index < count; index += 1) {
+      offset += this.#itemSize(index);
+      offsets[index + 1] = offset;
+    }
+    this.#offsetsCache = offsets;
+    this.#offsetsCacheCount = count;
+    this.#offsetsCacheMeasurementVersion = measurementVersion;
+    return offsets;
+  }
+  #readElementSize(node) {
+    const rectHeight = node.getBoundingClientRect().height;
+    return Math.ceil(rectHeight || node.scrollHeight || node.offsetHeight || 0);
+  }
+  #measureNode(node) {
+    const index = Number(node.dataset["cinderVirtualIndex"]);
+    if (!Number.isInteger(index) || index < 0 || index >= this.options.getCount())
+      return;
+    const measuredSize = this.#readElementSize(node);
+    if (measuredSize <= 0)
+      return;
+    const key = this.options.getItemKey(index);
+    if (this.#measuredSizes.get(key) === measuredSize)
+      return;
+    this.#measuredSizes.set(key, measuredSize);
+    this.#measurementVersion += 1;
+  }
+  #startIndex(offsets, scrollTop) {
+    const count = Math.max(0, offsets.length - 1);
+    let low = 0;
+    let high = count;
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if ((offsets[mid + 1] ?? 0) <= scrollTop) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    return low;
+  }
+  #endIndex(offsets, viewportEnd) {
+    const count = Math.max(0, offsets.length - 1);
+    let low = 0;
+    let high = count;
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if ((offsets[mid] ?? 0) < viewportEnd) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    return low;
+  }
+  #virtualItemAt(index, offsets) {
+    const start = offsets[index] ?? 0;
+    const end = offsets[index + 1] ?? start + this.#estimatedSize();
+    return {
+      key: this.options.getItemKey(index),
+      index,
+      start,
+      end,
+      size: end - start,
+      lane: 0
+    };
+  }
+  #virtualItems() {
+    const count = this.options.getCount();
+    if (count === 0)
+      return [];
+    const offsets = this.#offsets();
+    const overscan = Math.max(0, Math.trunc(this.options.getOverscan()));
+    const scrollTop = Math.max(0, this.scrollOffset - this.#scrollPaddingStart());
+    const viewportEnd = scrollTop + Math.max(0, this.#containerHeight());
+    const visibleStartIndex = this.#startIndex(offsets, scrollTop);
+    const visibleEndIndex = Math.max(visibleStartIndex + 1, this.#endIndex(offsets, viewportEnd));
+    const startIndex = Math.max(0, visibleStartIndex - overscan);
+    const endIndex = Math.min(count, visibleEndIndex + overscan);
+    return Array.from({ length: endIndex - startIndex }, (_, offset) => {
+      const index = startIndex + offset;
+      return this.#virtualItemAt(index, offsets);
+    });
+  }
+}
+
+// src/components/chat/container/use-chat-disclosure-state.svelte.ts
+import * as $30 from "svelte/internal/server";
+function useChatDisclosureState(options) {
+  const { onRemeasureRow } = options;
+  let expandedIds = new Set;
+  function isExpanded(messageId) {
+    return expandedIds.has(messageId);
+  }
+  function toggle(messageId) {
+    const next = new Set(expandedIds);
+    if (next.has(messageId)) {
+      next.delete(messageId);
+    } else {
+      next.add(messageId);
+    }
+    expandedIds = next;
+    onRemeasureRow?.(messageId);
+  }
+  function reset() {
+    expandedIds = new Set;
+  }
+  return { isExpanded, toggle, reset };
+}
+
+// src/components/chat/container/use-chat-typing-indicator.svelte.ts
+import * as $31 from "svelte/internal/server";
+var ADAPTER_PARTICIPANT_ID = "__adapter__";
+var ADAPTER_PARTICIPANT_NAME = "Someone";
+function deriveTypingLabel(participants) {
+  const count = participants.length;
+  if (count === 0)
+    return "";
+  if (count === 1)
+    return `${participants[0].name} is typing…`;
+  if (count === 2)
+    return `${participants[0].name} and ${participants[1].name} are typing…`;
+  if (count <= 4)
+    return `${count} people are typing…`;
+  return "Several people are typing…";
+}
+function deriveAnnouncedLabel(participants) {
+  const count = participants.length;
+  if (count === 0)
+    return "";
+  if (count === 1)
+    return `${participants[0].name} is typing`;
+  if (count === 2)
+    return `${participants[0].name} and ${participants[1].name} are typing`;
+  if (count <= 4)
+    return `${count} people are typing`;
+  return "Several people are typing";
+}
+function useChatTypingIndicator(options) {
+  let adapterIsTyping = false;
+  let announcedLabel = "";
+  let debounceHandle;
+  const mergedParticipants = $31.derived(() => {
+    const propParticipants = options.getTypingParticipants();
+    if (propParticipants !== undefined)
+      return propParticipants;
+    if (!adapterIsTyping)
+      return [];
+    return [
+      { id: ADAPTER_PARTICIPANT_ID, name: ADAPTER_PARTICIPANT_NAME }
+    ];
+  });
+  const typingLabel = $31.derived(() => deriveTypingLabel(mergedParticipants()));
+  const participantCount = $31.derived(() => mergedParticipants().length);
+  const announcementText = $31.derived(() => deriveAnnouncedLabel(mergedParticipants()));
+  function handleAdapterTypingChange(isTyping) {
+    adapterIsTyping = isTyping;
+  }
+  function reset() {
+    adapterIsTyping = false;
+  }
+  return {
+    get typingLabel() {
+      return typingLabel();
+    },
+    get announcedLabel() {
+      return announcedLabel;
+    },
+    get participantCount() {
+      return participantCount();
+    },
+    handleAdapterTypingChange,
+    reset
+  };
+}
+
+// src/components/chat/container/use-chat-read-receipts.svelte.ts
+import * as $32 from "svelte/internal/server";
+function useChatReadReceipts(options) {
+  let adapterReceipts = {};
+  function getReceipt(messageId) {
+    const propReceipts = options.getReadReceipts();
+    if (propReceipts !== undefined)
+      return propReceipts.get(messageId);
+    return adapterReceipts[messageId];
+  }
+  function handleAdapterReadReceipt(event) {
+    const existing = adapterReceipts[event.messageId];
+    if (existing === undefined) {
+      adapterReceipts[event.messageId] = {
+        status: "read",
+        ...event.readBy !== undefined ? { readBy: event.readBy } : {}
+      };
+      return;
+    }
+    if (event.readBy !== undefined && event.readBy.length > 0) {
+      const merged = Array.from(new Set([...existing.readBy ?? [], ...event.readBy]));
+      adapterReceipts[event.messageId] = { ...existing, readBy: merged };
+    }
+  }
+  function reset() {
+    adapterReceipts = {};
+  }
+  return { getReceipt, handleAdapterReadReceipt, reset };
+}
+
+// src/components/chat/container/chat-participant-typing.svelte
+import * as $33 from "svelte/internal/server";
+function Chat_participant_typing($$renderer, $$props) {
+  let { typingLabel, participantCount } = $$props;
+  const isActive = $33.derived(() => participantCount > 0);
+  $$renderer.push(`<div class="chat-participant-typing svelte-1i35kwx"${$33.attr("data-cinder-participant-typing", isActive() ? "" : undefined)}${$33.attr("data-cinder-participant-count", participantCount)} aria-hidden="true">`);
+  if (isActive()) {
+    $$renderer.push("<!--[0-->");
+    $$renderer.push(`<div class="chat-participant-typing-indicator svelte-1i35kwx"><span class="chat-typing-dot svelte-1i35kwx" aria-hidden="true"></span> <span class="chat-typing-dot svelte-1i35kwx" aria-hidden="true"></span> <span class="chat-typing-dot svelte-1i35kwx" aria-hidden="true"></span> <span class="chat-participant-typing-label svelte-1i35kwx">${$33.escape(typingLabel)}</span></div>`);
+  } else {
+    $$renderer.push("<!--[-1-->");
+  }
+  $$renderer.push(`<!--]--></div>`);
+}
+
+// src/components/chat/message/chat-read-receipt.svelte
+import * as $34 from "svelte/internal/server";
+function Chat_read_receipt($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { receipt } = $$props;
+    const status = $34.derived(() => receipt.status);
+    const ariaLabel = $34.derived(() => {
+      if (status() === "sent")
+        return "Sent";
+      if (status() === "delivered")
+        return "Delivered";
+      const readers = receipt.readBy;
+      if (readers && readers.length > 0) {
+        return `Read by ${readers.join(", ")}`;
+      }
+      return "Read";
+    });
+    const visibleLabel = $34.derived(() => status() === "sent" ? "Sent" : status() === "delivered" ? "Delivered" : "Read");
+    const isDoubleCheck = $34.derived(() => status() === "delivered" || status() === "read");
+    $$renderer2.push(`<span class="chat-read-receipt svelte-1r00g9n" role="img"${$34.attr("data-cinder-receipt-status", status())}${$34.attr("aria-label", ariaLabel())}><span class="chat-read-receipt-icon svelte-1r00g9n" aria-hidden="true">`);
+    if (isDoubleCheck()) {
+      $$renderer2.push("<!--[0-->");
+      Check_check($$renderer2, { size: 12 });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      Check($$renderer2, { size: 12 });
+    }
+    $$renderer2.push(`<!--]--></span> <span class="chat-read-receipt-label svelte-1r00g9n">${$34.escape(visibleLabel())}</span></span>`);
+  }, Chat_read_receipt);
+}
+
+// src/components/chat/container/chat.svelte
+function Chat($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const noopAttachment = () => {};
+    let {
+      id,
+      conversation,
+      atBottom = true,
+      unreadCount = 0,
+      newMessageIndicatorVisible = false,
+      class: className,
+      surfaceMode = "default",
+      density = "comfortable",
+      variant = "bubble",
+      bottomThreshold = DEFAULT_SCROLL_CONFIGURATION.bottomThreshold,
+      jumpThreshold = DEFAULT_SCROLL_CONFIGURATION.jumpThreshold,
+      streaming = false,
+      streamingStatus,
+      capabilities,
+      virtualized = false,
+      virtualizationEstimatedRowHeight = 88,
+      virtualizationOverscan = 3,
+      virtualizationInitialHeight = 640,
+      moreHistoryAvailable = true,
+      loadEarlierLabel = "Load earlier messages",
+      loadingEarlierLabel = "Loading earlier messages",
+      header,
+      empty,
+      emptyPrompts,
+      messageActions,
+      messageStatus,
+      row,
+      messagePart,
+      viewportAttachment,
+      typingParticipants,
+      readReceipts,
+      adapter,
+      onadaptererror,
+      onpushmessage,
+      ontypingchange,
+      onreadreceipt,
+      onsubmit,
+      onretry,
+      onedit,
+      onapprove,
+      ondeny,
+      messageReasoning,
+      messageSteps,
+      messageSuggestions,
+      onsuggestionselect,
+      onloadhistory,
+      onstopgenerating,
+      onjumptolatest,
+      onscrollstatechange,
+      onunreadindicatorchange,
+      onexpandedchange,
+      onattachmentadd,
+      onattachmentremove,
+      onattachmentfailure,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let viewport = null;
+    let containerRef = null;
+    let inputRef;
+    let searchBarRef = undefined;
+    let historyTriggerRef = undefined;
+    let isContainerDragOver = false;
+    let streamingContent = "";
+    let streamingMessageId = null;
+    let streamingRowElement = null;
+    let tokenBuffer = [];
+    let streamingScrollRaf;
+    let approvedToolCallIds = new Set;
+    let deniedToolCallIds = new Set;
+    function remeasureRow(messageId) {
+      if (!isVirtualized() || !viewport)
+        return;
+      const rowNode = viewport.querySelector(`#message-${CSS.escape(messageId)}`);
+      if (rowNode) {
+        chatVirtualizer.measureElementNode(rowNode);
+      }
+    }
+    const reasoningState = useChatDisclosureState({ onRemeasureRow: remeasureRow });
+    const toolCallState = useChatDisclosureState({ onRemeasureRow: remeasureRow });
+    let isLoadingHistory = false;
+    let adapterHasMoreHistory = undefined;
+    let historyAnnouncement = "";
+    let pendingHistoryScroll = null;
+    let deferredAdapterHasMoreHistory = null;
+    let historyAnchorMessageId = null;
+    let historyAnchorViewportOffset = null;
+    let historyAnchorRestoredScrollTop = null;
+    let previousHistoryConversationId;
+    let previousHistoryAdapter;
+    const scrollState = useChatScrollState({
+      getBottomThreshold: () => bottomThreshold,
+      getJumpThreshold: () => jumpThreshold,
+      onScrollStateChange: handleScrollStateChange,
+      onReachBottom: () => {
+        atBottom = true;
+        if (unreadState.unreadCount > 0 || unreadState.newMessageIndicatorVisible) {
+          unreadState.markAllAsRead();
+        }
+      }
+    });
+    const unreadState = useChatUnreadState({
+      onUnreadIndicatorChange: (event) => {
+        unreadCount = event.unreadCount;
+        newMessageIndicatorVisible = event.newMessageIndicatorVisible;
+        onunreadindicatorchange?.(event);
+      }
+    });
+    const keyboardNav = useChatKeyboardNav({
+      onJumpToLatest: handleJumpToLatest,
+      onJumpToStart: () => {
+        if (isVirtualized()) {
+          chatVirtualizer.scrollToOffset(0, { behavior: scrollState.getScrollBehavior() });
+        }
+      },
+      getScrollBehavior: scrollState.getScrollBehavior,
+      getHistoryTrigger: () => showHistoryTrigger() ? historyTriggerRef : null,
+      onVirtualMessageNavigation: (direction) => navigateVirtualMessage(direction)
+    });
+    const messages = $35.derived(() => getMessages(conversation));
+    const lastMessageId = $35.derived(() => messages().at(-1)?.id);
+    let previousAutoScrollMessageCount = getMessages(conversation).length;
+    const conversationId = $35.derived(() => conversation.id);
+    const showTypingIndicator = $35.derived(() => streaming && !streamingMessageId);
+    const allowAttachments = $35.derived(() => capabilities?.attachments ?? true);
+    const allowSearch = $35.derived(() => capabilities?.search ?? true);
+    const allowCopy = $35.derived(() => capabilities?.copy ?? true);
+    const allowEditing = $35.derived(() => capabilities?.editing ?? true);
+    const allowRetry = $35.derived(() => capabilities?.retry ?? true);
+    const toolCallPairsByCallId = $35.derived(() => {
+      const toolCallPairs = pairToolCallsWithResults(messages());
+      const map = new Map;
+      for (const pair of toolCallPairs) {
+        const existing = map.get(pair.call.id);
+        if (existing) {
+          existing.push(pair);
+        } else {
+          map.set(pair.call.id, [pair]);
+        }
+      }
+      return map;
+    });
+    const renderRows = $35.derived(() => {
+      const pairedToolResultIds = findPairedToolResultIds(messages());
+      const messagesWithDates = buildMessagesWithDateSeparators(messages(), pairedToolResultIds);
+      return buildChatRenderRows(messagesWithDates, {
+        firstUnreadId: unreadState.firstUnreadId,
+        showTypingIndicator: showTypingIndicator()
+      });
+    });
+    let hasMounted = false;
+    const isVirtualized = $35.derived(() => virtualized && hasMounted && messages().length > 0);
+    const timelineResetIdentity = $35.derived(() => `${conversationId()}:${isVirtualized() ? "virtualized" : "full"}`);
+    const staticRowsResetIdentity = $35.derived(() => messages()[0]?.id ?? "");
+    const chatVirtualizer = new ChatVirtualizer({
+      getScrollElement: () => viewport,
+      getCount: () => isVirtualized() ? renderRows().length : 0,
+      getItemKey: (index) => chatRenderRowKey(renderRows()[index] ?? { type: "typing" }),
+      getEstimatedSize: () => virtualizationEstimatedRowHeight,
+      getOverscan: () => virtualizationOverscan,
+      getInitialHeight: () => virtualizationInitialHeight,
+      getScrollPaddingStart: () => virtualSpacerOffsetTop()
+    });
+    const virtualRows = $35.derived(() => {
+      if (!isVirtualized())
+        return [];
+      const renderedIndexes = new Set;
+      const rows = [];
+      for (const virtualItem of chatVirtualizer.virtualItems) {
+        const row2 = renderRows()[virtualItem.index];
+        if (!row2)
+          continue;
+        renderedIndexes.add(virtualItem.index);
+        rows.push({
+          row: row2,
+          virtualItem: pinHistoryAnchorVirtualItem(row2, virtualItem)
+        });
+      }
+      if (streamingMessageId) {
+        const streamingIndex = findRenderRowIndexByMessageId(renderRows(), streamingMessageId);
+        if (streamingIndex >= 0 && !renderedIndexes.has(streamingIndex)) {
+          const virtualItem = chatVirtualizer.getVirtualItem(streamingIndex);
+          if (!virtualItem)
+            return rows;
+          rows.push({ row: renderRows()[streamingIndex], virtualItem });
+        }
+      }
+      if (historyAnchorMessageId) {
+        const historyAnchorIndex = findRenderRowIndexByMessageId(renderRows(), historyAnchorMessageId);
+        if (historyAnchorIndex >= 0 && !renderedIndexes.has(historyAnchorIndex)) {
+          const virtualItem = chatVirtualizer.getVirtualItem(historyAnchorIndex);
+          if (!virtualItem)
+            return rows;
+          const row2 = renderRows()[historyAnchorIndex];
+          if (row2) {
+            rows.push({
+              row: row2,
+              virtualItem: pinHistoryAnchorVirtualItem(row2, virtualItem)
+            });
+          }
+        }
+      }
+      rows.sort((a, b) => a.virtualItem.index - b.virtualItem.index);
+      return rows;
+    });
+    function pinHistoryAnchorVirtualItem(row2, virtualItem) {
+      if (historyAnchorViewportOffset === null || row2.type !== "message" || row2.message.id !== historyAnchorMessageId) {
+        return virtualItem;
+      }
+      const scrollTop = viewport?.scrollTop ?? chatVirtualizer.scrollOffset;
+      const start = Math.max(0, scrollTop - chatVirtualizer.scrollPaddingStart + historyAnchorViewportOffset);
+      return { ...virtualItem, start, end: start + virtualItem.size };
+    }
+    const searchState = useChatSearch({ getMessages: () => messages() });
+    const typingIndicatorState = useChatTypingIndicator({ getTypingParticipants: () => typingParticipants });
+    const readReceiptsState = useChatReadReceipts({ getReadReceipts: () => readReceipts });
+    const viewportAttach = $35.derived(() => viewportAttachment ?? noopAttachment);
+    const effectiveHasMoreHistory = $35.derived(() => adapterHasMoreHistory ?? moreHistoryAvailable);
+    const hasHistoryLoader = $35.derived(() => onloadhistory !== undefined || adapter?.loadOlderMessages !== undefined);
+    const showHistoryTrigger = $35.derived(() => hasHistoryLoader() && effectiveHasMoreHistory());
+    const canRetry = $35.derived(() => onretry !== undefined || adapter?.retryMessage !== undefined);
+    const canEdit = $35.derived(() => onedit !== undefined || adapter?.editMessage !== undefined);
+    const sentinelAttach = $35.derived(() => isVirtualized() ? noopAttachment : useIntersection(scrollState.handleSentinelEntry, {
+      root: viewport,
+      rootMargin: `0px 0px ${bottomThreshold}px 0px`
+    }));
+    const timelineId = $35.derived(() => `${id}-timeline`);
+    const inputId = $35.derived(() => `${id}-input`);
+    const statusId = $35.derived(() => `${id}-status`);
+    const toolApprovalAssertiveMessage = $35.derived(() => {
+      for (const message of messages()) {
+        if (message.role === "tool-result" && message.toolResult?.outcome === "action_required" && message.toolResult.action && !approvedToolCallIds.has(message.toolResult.callId) && !deniedToolCallIds.has(message.toolResult.callId)) {
+          const actionMessage = message.toolResult.action.message ?? "This tool call requires your approval before it can continue.";
+          return `Action required: ${actionMessage}`;
+        }
+      }
+      return "";
+    });
+    async function waitForLayoutFrame() {
+      await tick2();
+      if (typeof requestAnimationFrame !== "function")
+        return;
+      await new Promise((resolve) => {
+        requestAnimationFrame(() => resolve());
+      });
+    }
+    async function restorePendingHistoryScrollAfterLayout(pending) {
+      await waitForLayoutFrame();
+      if (pendingHistoryScroll !== pending)
+        return false;
+      return restoreHistoryScroll(pending);
+    }
+    function restoreHistoryScroll(pending) {
+      if (!viewport)
+        return false;
+      const currentFirstMessageId = messages()[0]?.id ?? null;
+      const currentCount = messages().length;
+      if (currentCount <= pending.previousCount || currentFirstMessageId === pending.previousFirstTranscriptMessageId) {
+        return false;
+      }
+      const prependedCount = currentCount - pending.previousCount;
+      pendingHistoryScroll = null;
+      finishDeferredAdapterHistoryLoading();
+      if (isVirtualized()) {
+        setHistoryAnchor(pending);
+      }
+      if (isVirtualized()) {
+        const newTotalSize = chatVirtualizer.scrollSize;
+        const delta = newTotalSize - pending.previousTotalSize;
+        const targetScrollTop = pending.previousScrollTop + delta;
+        chatVirtualizer.scrollToOffset(targetScrollTop, { behavior: "instant" });
+        historyAnchorRestoredScrollTop = viewport?.scrollTop ?? chatVirtualizer.scrollOffset;
+      } else {
+        clearHistoryAnchor();
+        const newTotalSize = viewport.scrollHeight;
+        const delta = newTotalSize - pending.previousScrollHeight;
+        viewport.scrollTo({ top: pending.previousScrollTop + delta, behavior: "instant" });
+      }
+      const announcement = prependedCount === 1 ? "1 earlier message loaded." : `${prependedCount} earlier messages loaded.`;
+      historyAnnouncement = announcement;
+      setTimeout(() => {
+        if (historyAnnouncement === announcement) {
+          historyAnnouncement = "";
+        }
+      }, 1000);
+      tick2().then(() => {
+        focusAfterHistoryRestore(pending);
+      });
+      return true;
+    }
+    function setHistoryAnchor(pending) {
+      historyAnchorMessageId = pending.previousFirstMessageId;
+      historyAnchorViewportOffset = pending.previousFirstMessageViewportOffset;
+      historyAnchorRestoredScrollTop = null;
+    }
+    function clearHistoryAnchor() {
+      historyAnchorMessageId = null;
+      historyAnchorViewportOffset = null;
+      historyAnchorRestoredScrollTop = null;
+    }
+    function clearHistoryAnchorAfterScroll(scrollTop) {
+      if (historyAnchorMessageId !== null && historyAnchorRestoredScrollTop !== null && Math.abs(scrollTop - historyAnchorRestoredScrollTop) > 2) {
+        clearHistoryAnchor();
+      }
+    }
+    function handleScrollStateChange(event) {
+      clearHistoryAnchorAfterScroll(event.scrollTop);
+      atBottom = event.atBottom;
+      onscrollstatechange?.(event);
+    }
+    function virtualSpacerOffsetTop() {
+      if (!viewport)
+        return 0;
+      const spacer = viewport.querySelector(".chat-virtual-spacer");
+      if (!spacer)
+        return 0;
+      const offsetTop = spacer.offsetTop;
+      const spacerRect = spacer.getBoundingClientRect();
+      const viewportRect = viewport.getBoundingClientRect();
+      const hasLayoutBox = spacerRect.top !== 0 || spacerRect.bottom !== 0 || viewportRect.top !== 0 || viewportRect.bottom !== 0;
+      if (!hasLayoutBox)
+        return Math.max(0, offsetTop);
+      const rectOffset = spacerRect.top - viewportRect.top + viewport.scrollTop;
+      return Math.max(0, Number.isFinite(rectOffset) ? rectOffset : offsetTop);
+    }
+    function focusAfterHistoryRestore(pending) {
+      if (!viewport)
+        return;
+      if (showHistoryTrigger() && historyTriggerRef) {
+        historyTriggerRef.focus({ preventScroll: true });
+        return;
+      }
+      const anchor = pending.previousFirstMessageId ? viewport.querySelector(`#message-${CSS.escape(pending.previousFirstMessageId)}`) : null;
+      const target = anchor ?? viewport.querySelector(".chat-message");
+      target?.focus({ preventScroll: true });
+    }
+    const scrollAttachment = scrollState.createScrollAttachment();
+    const historyAnchorScrollAttachment = $35.derived(() => historyAnchorMessageId === null || historyAnchorRestoredScrollTop === null ? noopAttachment : (node) => {
+      const handleScroll = () => clearHistoryAnchorAfterScroll(node.scrollTop);
+      node.addEventListener("scroll", handleScroll, { passive: true });
+      return () => node.removeEventListener("scroll", handleScroll);
+    });
+    function handleJumpToLatest() {
+      if (isVirtualized()) {
+        chatVirtualizer.scrollToIndex(Math.max(0, renderRows().length - 1), { align: "end", behavior: scrollState.getScrollBehavior() });
+        unreadState.markAllAsRead();
+        onjumptolatest?.();
+        tick2().then(() => {
+          const lastMessage = viewport?.querySelector(`.chat-message-wrapper:last-of-type .chat-message`);
+          lastMessage?.focus();
+        });
+        return;
+      }
+      scrollState.jumpToLatest(viewport, () => {
+        unreadState.markAllAsRead();
+        onjumptolatest?.();
+      });
+    }
+    function dispatchCommand(command, runAdapterMethod, callback) {
+      if (adapter) {
+        try {
+          const run = runAdapterMethod(adapter);
+          if (run !== undefined) {
+            return run.catch((error) => {
+              onadaptererror?.({ command, error });
+            });
+          }
+        } catch (error) {
+          onadaptererror?.({ command, error });
+          return;
+        }
+      }
+      callback?.();
+    }
+    function handleSubmit(message, attachments) {
+      dispatchCommand("sendMessage", (resolvedAdapter) => Promise.resolve(resolvedAdapter.sendMessage(message, attachments)), () => onsubmit?.({ message, attachments }));
+      scrollState.setAtBottom(true);
+      atBottom = true;
+      tick2().then(() => {
+        if (isVirtualized()) {
+          chatVirtualizer.scrollToOffset(chatVirtualizer.scrollSize, { behavior: "instant" });
+        } else {
+          viewport?.scrollTo({ top: viewport.scrollHeight, behavior: "instant" });
+        }
+      });
+    }
+    function captureHistoryScroll() {
+      const previousFirstTranscriptMessageId = messages()[0]?.id ?? null;
+      const visibleAnchor = firstVisibleRenderedMessage();
+      const previousFirstMessageId = visibleAnchor?.messageId ?? previousFirstTranscriptMessageId;
+      const previousScrollTop = viewport?.scrollTop ?? chatVirtualizer.scrollOffset;
+      const previousFirstMessageElement = previousFirstMessageId !== null ? renderedMessageById(previousFirstMessageId) : null;
+      const previousFirstMessageViewportOffset = visibleAnchor?.viewportOffset ?? (previousFirstMessageElement && viewport ? previousFirstMessageElement.getBoundingClientRect().top - viewport.getBoundingClientRect().top : 0);
+      pendingHistoryScroll = {
+        previousFirstMessageId,
+        previousFirstTranscriptMessageId,
+        previousFirstMessageViewportOffset,
+        previousCount: messages().length,
+        previousScrollTop,
+        previousScrollHeight: viewport?.scrollHeight ?? 0,
+        previousTotalSize: chatVirtualizer.scrollSize
+      };
+    }
+    async function settlePendingHistoryScroll(pending) {
+      for (let attempt = 0;attempt < 5; attempt += 1) {
+        if (pendingHistoryScroll !== pending)
+          return;
+        if (await restorePendingHistoryScrollAfterLayout(pending))
+          return;
+      }
+      if (pendingHistoryScroll === pending) {
+        pendingHistoryScroll = null;
+        finishDeferredAdapterHistoryLoading();
+      }
+    }
+    function finishDeferredAdapterHistoryLoading() {
+      if (deferredAdapterHasMoreHistory === null)
+        return;
+      adapterHasMoreHistory = deferredAdapterHasMoreHistory;
+      deferredAdapterHasMoreHistory = null;
+      isLoadingHistory = false;
+    }
+    function historyTranscriptChanged(pending) {
+      return messages().length > pending.previousCount || messages()[0]?.id !== pending.previousFirstTranscriptMessageId;
+    }
+    async function handleLoadHistory() {
+      if (isLoadingHistory || !showHistoryTrigger())
+        return;
+      isLoadingHistory = true;
+      captureHistoryScroll();
+      const pending = pendingHistoryScroll;
+      if (pending === null) {
+        isLoadingHistory = false;
+        return;
+      }
+      if (adapter?.loadOlderMessages) {
+        let nextHasMoreHistory;
+        try {
+          const result = await adapter.loadOlderMessages(conversationId());
+          nextHasMoreHistory = result.hasMore;
+        } catch (error) {
+          pendingHistoryScroll = null;
+          isLoadingHistory = false;
+          onadaptererror?.({ command: "loadOlderMessages", error });
+          return;
+        }
+        const transcriptChanged = historyTranscriptChanged(pending);
+        if (isVirtualized() && !transcriptChanged) {
+          deferredAdapterHasMoreHistory = nextHasMoreHistory ?? null;
+          await tick2();
+          if (historyTranscriptChanged(pending)) {
+            await settlePendingHistoryScroll(pending);
+          } else if (pendingHistoryScroll === pending) {
+            pendingHistoryScroll = null;
+            finishDeferredAdapterHistoryLoading();
+          } else {
+            finishDeferredAdapterHistoryLoading();
+          }
+          return;
+        }
+        if (isVirtualized() || transcriptChanged) {
+          await settlePendingHistoryScroll(pending);
+        } else {
+          pendingHistoryScroll = null;
+        }
+        adapterHasMoreHistory = nextHasMoreHistory;
+        isLoadingHistory = false;
+        return;
+      }
+      try {
+        await onloadhistory?.();
+        await settlePendingHistoryScroll(pending);
+      } catch (error) {
+        pendingHistoryScroll = null;
+        throw error;
+      } finally {
+        isLoadingHistory = false;
+      }
+    }
+    function handleRetry(messageId) {
+      dispatchCommand("retryMessage", (resolvedAdapter) => resolvedAdapter.retryMessage ? Promise.resolve(resolvedAdapter.retryMessage(messageId)) : undefined, () => onretry?.(messageId));
+    }
+    function handleEdit(event) {
+      dispatchCommand("editMessage", (resolvedAdapter) => resolvedAdapter.editMessage ? Promise.resolve(resolvedAdapter.editMessage(event)) : undefined, () => onedit?.(event));
+    }
+    function handleSuggestionSelect(label) {
+      onsuggestionselect?.(label);
+      inputRef?.focus();
+    }
+    const canApprove = $35.derived(() => onapprove !== undefined || adapter?.approveToolCall !== undefined);
+    const canDeny = $35.derived(() => ondeny !== undefined || adapter?.denyToolCall !== undefined);
+    function resolveToolApproval(toolCallId, command, canHandle, commit, rollback, runAdapter, callback) {
+      if (!canHandle)
+        return;
+      if (approvedToolCallIds.has(toolCallId) || deniedToolCallIds.has(toolCallId))
+        return;
+      commit(toolCallId);
+      if (adapter) {
+        let run;
+        try {
+          run = runAdapter(adapter);
+        } catch (error) {
+          rollback(toolCallId);
+          onadaptererror?.({ command, error });
+          return;
+        }
+        if (run !== undefined) {
+          run.then(() => callback?.(), (error) => {
+            rollback(toolCallId);
+            onadaptererror?.({ command, error });
+          });
+          return;
+        }
+      }
+      callback?.();
+    }
+    function handleApprove(toolCallId) {
+      resolveToolApproval(toolCallId, "approveToolCall", canApprove(), (id2) => approvedToolCallIds = new Set([...approvedToolCallIds, id2]), (id2) => approvedToolCallIds = removeFromSet(approvedToolCallIds, id2), (resolvedAdapter) => resolvedAdapter.approveToolCall ? Promise.resolve(resolvedAdapter.approveToolCall(toolCallId)) : undefined, () => onapprove?.(toolCallId));
+    }
+    function handleDeny(toolCallId) {
+      resolveToolApproval(toolCallId, "denyToolCall", canDeny(), (id2) => deniedToolCallIds = new Set([...deniedToolCallIds, id2]), (id2) => deniedToolCallIds = removeFromSet(deniedToolCallIds, id2), (resolvedAdapter) => resolvedAdapter.denyToolCall ? Promise.resolve(resolvedAdapter.denyToolCall(toolCallId)) : undefined, () => ondeny?.(toolCallId));
+    }
+    function removeFromSet(set, value) {
+      const next = new Set(set);
+      next.delete(value);
+      return next;
+    }
+    function handleStopGenerating() {
+      let streamingMessage;
+      for (let i = messages().length - 1;i >= 0; i--) {
+        const message = messages()[i];
+        if (message?.role === "assistant") {
+          streamingMessage = message;
+          break;
+        }
+      }
+      if (streamingMessage) {
+        const targetMessageId = streamingMessage.id;
+        dispatchCommand("stopGenerating", (resolvedAdapter) => resolvedAdapter.stopGenerating ? Promise.resolve(resolvedAdapter.stopGenerating(targetMessageId)) : undefined, () => onstopgenerating?.({ messageId: targetMessageId }));
+      }
+    }
+    function handlePromptClick(prompt) {
+      const currentAttachments = (inputRef?.getAttachments() ?? []).filter((a) => a.status === "ready");
+      handleSubmit({ role: "user", content: prompt }, currentAttachments);
+      inputRef?.clear();
+    }
+    function handleKeyDown(event) {
+      if (allowSearch() && (event.ctrlKey || event.metaKey) && event.key === "f") {
+        event.preventDefault();
+        if (searchState.isOpen) {
+          searchBarRef?.focusInput();
+        } else {
+          searchState.open();
+        }
+        return;
+      }
+      keyboardNav.handleKeyDown(event, viewport);
+    }
+    function messageIdFromElement(element) {
+      if (!element.id.startsWith("message-"))
+        return null;
+      return element.id.slice("message-".length);
+    }
+    function renderedMessageById(messageId) {
+      return viewport?.querySelector(`#message-${CSS.escape(messageId)}`) ?? null;
+    }
+    function firstVisibleRenderedMessage() {
+      if (!viewport)
+        return null;
+      const viewportRect = viewport.getBoundingClientRect();
+      for (const message of viewport.querySelectorAll(".chat-message")) {
+        const messageId = messageIdFromElement(message);
+        if (!messageId)
+          continue;
+        const rect = message.getBoundingClientRect();
+        if (rect.bottom <= viewportRect.top || rect.top >= viewportRect.bottom)
+          continue;
+        return { messageId, viewportOffset: rect.top - viewportRect.top };
+      }
+      return null;
+    }
+    async function focusVirtualMessage(messageId) {
+      const existing = renderedMessageById(messageId);
+      if (existing) {
+        existing.focus();
+        existing.scrollIntoView({ behavior: scrollState.getScrollBehavior(), block: "nearest" });
+        return;
+      }
+      const targetIndex = findRenderRowIndexByMessageId(renderRows(), messageId);
+      if (targetIndex < 0)
+        return;
+      chatVirtualizer.scrollToIndex(targetIndex, { align: "auto", behavior: scrollState.getScrollBehavior() });
+      await tick2();
+      const target = renderedMessageById(messageId);
+      target?.focus();
+      target?.scrollIntoView({ behavior: scrollState.getScrollBehavior(), block: "nearest" });
+    }
+    function navigateVirtualMessage(direction) {
+      if (!isVirtualized() || !viewport)
+        return false;
+      const activeElement = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+      if (!activeElement?.classList.contains("chat-message"))
+        return false;
+      const currentMessageId = messageIdFromElement(activeElement);
+      if (!currentMessageId)
+        return false;
+      const currentIndex = findRenderRowIndexByMessageId(renderRows(), currentMessageId);
+      if (currentIndex < 0)
+        return false;
+      const step = direction === "next" ? 1 : -1;
+      for (let targetIndex = currentIndex + step;targetIndex >= 0 && targetIndex < renderRows().length; targetIndex += step) {
+        const targetRow = renderRows()[targetIndex];
+        if (targetRow?.type !== "message")
+          continue;
+        focusVirtualMessage(targetRow.message.id);
+        return true;
+      }
+      return true;
+    }
+    async function scrollCurrentSearchMatch(messageId) {
+      if (!viewport)
+        return;
+      if (isVirtualized()) {
+        const targetIndex = findRenderRowIndexByMessageId(renderRows(), messageId);
+        if (targetIndex >= 0) {
+          chatVirtualizer.scrollToIndex(targetIndex, { align: "center", behavior: "auto" });
+          await tick2();
+        }
+      }
+      const messageElement = viewport.querySelector(`#message-${CSS.escape(messageId)}`);
+      if (messageElement) {
+        messageElement.scrollIntoView({ behavior: "auto", block: "nearest" });
+      }
+    }
+    function handleContainerDrop(event) {
+      if (!event.dataTransfer?.types.includes("Files"))
+        return;
+      isContainerDragOver = false;
+      if (!allowAttachments())
+        return;
+      event.preventDefault();
+      const files = event.dataTransfer.files;
+      if (files.length > 0) {
+        inputRef?.addFiles(Array.from(files));
+      }
+    }
+    function handleContainerDragOver(event) {
+      if (!event.dataTransfer?.types.includes("Files"))
+        return;
+      if (!allowAttachments())
+        return;
+      event.preventDefault();
+      event.dataTransfer.dropEffect = "copy";
+      isContainerDragOver = true;
+    }
+    function handleContainerDragLeave(event) {
+      const container = event.currentTarget;
+      if (!container.contains(event.relatedTarget)) {
+        isContainerDragOver = false;
+      }
+    }
+    function scrollToBottom() {
+      if (isVirtualized()) {
+        chatVirtualizer.scrollToOffset(chatVirtualizer.scrollSize, { behavior: scrollState.getScrollBehavior() });
+      } else {
+        scrollState.scrollToBottom(viewport);
+      }
+    }
+    function scrollToTop() {
+      if (isVirtualized()) {
+        chatVirtualizer.scrollToOffset(0, { behavior: scrollState.getScrollBehavior() });
+      } else {
+        scrollState.scrollToTop(viewport);
+      }
+    }
+    function focusInput() {
+      inputRef?.focus();
+    }
+    function beginStreaming(messageId) {
+      if (streamingScrollRaf !== undefined) {
+        cancelAnimationFrame(streamingScrollRaf);
+        streamingScrollRaf = undefined;
+      }
+      streamingMessageId = messageId;
+      streamingContent = "";
+      tokenBuffer = [];
+    }
+    function pushToken(token) {
+      tokenBuffer.push(token);
+      if (streamingScrollRaf === undefined) {
+        streamingScrollRaf = requestAnimationFrame(() => {
+          streamingScrollRaf = undefined;
+          streamingContent = tokenBuffer.join("");
+          if (streamingRowElement) {
+            tick2().then(() => {
+              if (streamingRowElement) {
+                chatVirtualizer.measureElementNode(streamingRowElement);
+              }
+            });
+          }
+          if (scrollState.atBottom && viewport) {
+            if (isVirtualized()) {
+              chatVirtualizer.scrollToOffset(chatVirtualizer.scrollSize, { behavior: "instant" });
+            } else {
+              viewport.scrollTo({ top: viewport.scrollHeight, behavior: "instant" });
+            }
+          }
+        });
+      }
+    }
+    function endStreaming() {
+      if (streamingScrollRaf !== undefined) {
+        cancelAnimationFrame(streamingScrollRaf);
+        streamingScrollRaf = undefined;
+      }
+      streamingMessageId = null;
+      streamingContent = "";
+      tokenBuffer = [];
+    }
+    function virtualizedSpacerStyle() {
+      return `height: ${chatVirtualizer.totalSize}px; position: relative; width: 100%;`;
+    }
+    function virtualizedRowStyle(virtualItem) {
+      return `position: absolute; inset-inline: 0; top: 0; transform: translateY(${virtualItem.start}px);`;
+    }
+    function virtualRowAttachment(row2) {
+      return (node) => {
+        const detachMeasurement = chatVirtualizer.measureElement(node);
+        if (row2.type === "message" && row2.message.id === streamingMessageId) {
+          streamingRowElement = node;
+        }
+        return () => {
+          detachMeasurement?.();
+          if (streamingRowElement === node) {
+            streamingRowElement = null;
+          }
+        };
+      };
+    }
+    function renderTypingIndicator($$renderer3) {
+      $$renderer3.push(`<div class="chat-typing-indicator svelte-932akd" role="status"${$35.attr("aria-label", streamingStatus ?? "Assistant is typing")}>`);
+      if (streamingStatus) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<span class="chat-typing-status svelte-932akd">${$35.escape(streamingStatus)}</span>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<span class="chat-typing-dot svelte-932akd" aria-hidden="true"></span> <span class="chat-typing-dot svelte-932akd" aria-hidden="true"></span> <span class="chat-typing-dot svelte-932akd" aria-hidden="true"></span>`);
+      }
+      $$renderer3.push(`<!--]--></div>`);
+    }
+    function renderMessageRow($$renderer3, messageRow) {
+      const message = messageRow.message;
+      const pairs = message.toolCall?.id ? toolCallPairsByCallId().get(message.toolCall.id) ?? [] : [];
+      const isStreamingMessage = streamingMessageId === message.id;
+      const isCurrentSearchMatch = searchState.isOpen && searchState.currentMatch !== null && searchState.currentMatch.message.id === message.id;
+      const derivedReasoning = resolveMessageReasoning(message, messageReasoning);
+      const derivedSteps = resolveMessageSteps(message, messageSteps);
+      const derivedSuggestions = message.id === lastMessageId() ? resolveMessageSuggestions(message, messageSuggestions) : undefined;
+      function renderDefaultRow($$renderer4) {
+        const receipt = message.role === "user" ? readReceiptsState.getReceipt(message.id) : undefined;
+        {
+          let actions = function($$renderer5) {
+            if (messageActions) {
+              $$renderer5.push("<!--[0-->");
+              messageActions($$renderer5, message);
+              $$renderer5.push(`<!---->`);
+            } else {
+              $$renderer5.push("<!--[-1-->");
+            }
+            $$renderer5.push(`<!--]-->`);
+          }, status = function($$renderer5) {
+            if (messageStatus) {
+              $$renderer5.push("<!--[0-->");
+              messageStatus($$renderer5, message);
+              $$renderer5.push(`<!---->`);
+            } else if (receipt) {
+              $$renderer5.push("<!--[1-->");
+              Chat_read_receipt($$renderer5, { receipt });
+            } else {
+              $$renderer5.push("<!--[-1-->");
+            }
+            $$renderer5.push(`<!--]-->`);
+          };
+          Chat_message($$renderer4, {
+            message,
+            toolCallPairs: pairs,
+            messagePart,
+            onretry: allowRetry() && canRetry() ? handleRetry : undefined,
+            onedit: allowEditing() && canEdit() ? handleEdit : undefined,
+            showDefaultActions: allowCopy(),
+            onexpandedchange,
+            streaming: isStreamingMessage,
+            overrideContent: isStreamingMessage ? streamingContent : undefined,
+            searchMatch: isCurrentSearchMatch,
+            tabindex: -1,
+            approvedToolCallIds: approvedToolCallIds.size > 0 ? approvedToolCallIds : undefined,
+            deniedToolCallIds: deniedToolCallIds.size > 0 ? deniedToolCallIds : undefined,
+            onapprove: canApprove() ? handleApprove : undefined,
+            ondeny: canDeny() ? handleDeny : undefined,
+            reasoning: derivedReasoning,
+            steps: derivedSteps,
+            suggestions: derivedSuggestions,
+            reasoningExpanded: reasoningState.isExpanded(message.id),
+            onreasoning: () => reasoningState.toggle(message.id),
+            toolCallExpanded: toolCallState.isExpanded(message.id),
+            ontoolcalltoggle: () => toolCallState.toggle(message.id),
+            onsuggestionselect: handleSuggestionSelect,
+            actions,
+            status,
+            $$slots: { actions: true, status: true }
+          });
+        }
+      }
+      if (row) {
+        $$renderer3.push("<!--[0-->");
+        row($$renderer3, message, renderDefaultRow);
+        $$renderer3.push(`<!---->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        renderDefaultRow($$renderer3);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    function renderChatRow($$renderer3, renderRow) {
+      if (renderRow.type === "date") {
+        $$renderer3.push("<!--[0-->");
+        Chat_date_separator($$renderer3, { date: renderRow.date });
+      } else if (renderRow.type === "unread-divider") {
+        $$renderer3.push("<!--[1-->");
+        $$renderer3.push(`<div class="chat-unread-divider svelte-932akd" role="separator" aria-label="New messages below"><span class="chat-unread-divider-line svelte-932akd" aria-hidden="true"></span> <span class="chat-unread-divider-label svelte-932akd">New</span> <span class="chat-unread-divider-line svelte-932akd" aria-hidden="true"></span></div>`);
+      } else if (renderRow.type === "typing") {
+        $$renderer3.push("<!--[2-->");
+        renderTypingIndicator($$renderer3);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        renderMessageRow($$renderer3, renderRow);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<div${$35.attributes({
+      id,
+      class: $35.clsx(classNames("cinder-chat", "chat-container", className)),
+      "data-surface-mode": surfaceMode,
+      "data-cinder-density": density,
+      "data-cinder-variant": variant,
+      role: "region",
+      "aria-label": "Chat conversation",
+      ...rest
+    }, "svelte-932akd")}>`);
+    if (isContainerDragOver && allowAttachments()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-drop-overlay svelte-932akd" aria-hidden="true"><span class="chat-drop-label svelte-932akd">Drop files here</span></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (header) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="chat-header svelte-932akd">`);
+      header($$renderer2);
+      $$renderer2.push(`<!----></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (allowSearch() && searchState.isOpen) {
+      $$renderer2.push("<!--[0-->");
+      Chat_search_bar($$renderer2, {
+        instanceId: id,
+        query: searchState.query,
+        matchCount: searchState.matchCount,
+        currentMatchIndex: searchState.currentMatchIndex,
+        onquerychange: searchState.setQuery,
+        onnext: searchState.nextMatch,
+        onprevious: searchState.previousMatch,
+        onclose: searchState.close
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->  <!---->`);
+    {
+      $$renderer2.push(`<div${$35.attr("id", timelineId())} class="chat-timeline svelte-932akd" role="log" aria-label="Messages"${$35.attr("aria-describedby", statusId())}${$35.attr("aria-live", isVirtualized() ? "off" : "polite")}${$35.attr("aria-relevant", isVirtualized() ? undefined : "additions")}${$35.attr("data-cinder-virtualized", isVirtualized() ? "" : undefined)} tabindex="0">`);
+      if (showHistoryTrigger()) {
+        $$renderer2.push("<!--[0-->");
+        Chat_history_trigger($$renderer2, {
+          loading: isLoadingHistory,
+          label: loadEarlierLabel,
+          loadingLabel: loadingEarlierLabel,
+          onload: () => void handleLoadHistory()
+        });
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (messages().length === 0) {
+        $$renderer2.push("<!--[0-->");
+        if (empty) {
+          $$renderer2.push("<!--[0-->");
+          empty($$renderer2);
+          $$renderer2.push(`<!---->`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+          $$renderer2.push(`<div class="chat-empty svelte-932akd" role="status"><p class="svelte-932akd">No messages yet</p> `);
+          if (emptyPrompts && emptyPrompts.length > 0) {
+            $$renderer2.push("<!--[0-->");
+            $$renderer2.push(`<div class="chat-empty-prompts svelte-932akd" role="group" aria-label="Suggested prompts"><!--[-->`);
+            const each_array = $35.ensure_array_like(emptyPrompts);
+            for (let index = 0, $$length = each_array.length;index < $$length; index++) {
+              let prompt = each_array[index];
+              $$renderer2.push(`<button type="button" class="chat-empty-prompt svelte-932akd">${$35.escape(prompt)}</button>`);
+            }
+            $$renderer2.push(`<!--]--></div>`);
+          } else {
+            $$renderer2.push("<!--[-1-->");
+          }
+          $$renderer2.push(`<!--]--></div>`);
+        }
+        $$renderer2.push(`<!--]-->`);
+      } else if (isVirtualized()) {
+        $$renderer2.push("<!--[1-->");
+        $$renderer2.push(`<div class="chat-virtual-spacer svelte-932akd"${$35.attr_style(virtualizedSpacerStyle())}><!--[-->`);
+        const each_array_1 = $35.ensure_array_like(virtualRows());
+        for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+          let virtualRow = each_array_1[$$index_1];
+          $$renderer2.push(`<div class="chat-virtual-row svelte-932akd"${$35.attr("data-cinder-virtual-index", virtualRow.virtualItem.index)}${$35.attr_style(virtualizedRowStyle(virtualRow.virtualItem))}>`);
+          renderChatRow($$renderer2, virtualRow.row);
+          $$renderer2.push(`<!----></div>`);
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        $$renderer2.push(`<!---->`);
+        {
+          $$renderer2.push(`<!--[-->`);
+          const each_array_2 = $35.ensure_array_like(renderRows());
+          for (let $$index_2 = 0, $$length = each_array_2.length;$$index_2 < $$length; $$index_2++) {
+            let renderRow = each_array_2[$$index_2];
+            renderChatRow($$renderer2, renderRow);
+          }
+          $$renderer2.push(`<!--]-->`);
+        }
+        $$renderer2.push(`<!---->`);
+      }
+      $$renderer2.push(`<!--]--> `);
+      Chat_participant_typing($$renderer2, {
+        typingLabel: typingIndicatorState.typingLabel,
+        participantCount: typingIndicatorState.participantCount
+      });
+      $$renderer2.push(`<!----> <div class="chat-bottom-sentinel svelte-932akd" aria-hidden="true"></div></div>`);
+    }
+    $$renderer2.push(`<!----> <div class="chat-input-wrapper svelte-932akd">`);
+    Chat_jump_controls($$renderer2, {
+      showJumpButton: scrollState.showJumpButton,
+      hasNewMessageIndicator: unreadState.newMessageIndicatorVisible,
+      unreadCount: unreadState.unreadCount,
+      displayUnreadCount: unreadState.displayUnreadCount,
+      hasLargeCount: unreadState.hasLargeCount,
+      onjumptolatest: handleJumpToLatest
+    });
+    $$renderer2.push(`<!----> <div class="chat-input-area svelte-932akd">`);
+    Chat_input($$renderer2, {
+      id: inputId(),
+      onsubmit: (message, attachments) => handleSubmit(message, attachments),
+      disabled: streaming,
+      sending: streaming,
+      allowAttachments: allowAttachments(),
+      onstop: streaming ? handleStopGenerating : undefined,
+      onattachmentadd,
+      onattachmentremove,
+      onattachmentfailure
+    });
+    $$renderer2.push(`<!----></div></div> `);
+    Chat_status_announcer($$renderer2, {
+      statusId: statusId(),
+      messageCount: messages().length,
+      announcerMessage: historyAnnouncement || unreadState.announcerMessage,
+      assertiveMessage: toolApprovalAssertiveMessage()
+    });
+    $$renderer2.push(`<!----> <div class="cinder-sr-only svelte-932akd" aria-live="polite" aria-atomic="true">${$35.escape(typingIndicatorState.announcedLabel)}</div></div>`);
+    $35.bind_props($$props, {
+      atBottom,
+      unreadCount,
+      newMessageIndicatorVisible,
+      scrollToBottom,
+      scrollToTop,
+      focusInput,
+      beginStreaming,
+      pushToken,
+      endStreaming
+    });
+  }, Chat);
+}
+
+// src/components/chat/chat.svelte
+function Chat2($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { class: className, $$slots, $$events, ...rest } = $$props;
+    const mergedClassName = $36.derived(() => classNames(className));
+    let impl;
+    function beginStreaming(messageId) {
+      impl?.beginStreaming(messageId);
+    }
+    function pushToken(token) {
+      impl?.pushToken(token);
+    }
+    function endStreaming() {
+      impl?.endStreaming();
+    }
+    function scrollToBottom() {
+      impl?.scrollToBottom();
+    }
+    function scrollToTop() {
+      impl?.scrollToTop();
+    }
+    function focusInput() {
+      impl?.focusInput();
+    }
+    Chat($$renderer2, $36.spread_props([{ class: mergedClassName() }, rest]));
+    $36.bind_props($$props, {
+      beginStreaming,
+      pushToken,
+      endStreaming,
+      scrollToBottom,
+      scrollToTop,
+      focusInput
+    });
+  }, Chat2);
+}
+
+// src/components/chat/builders.ts
+var createConversation = createConversationHistory;
+function appendMessages2(conversation, ...inputs) {
+  if (inputs.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...inputs);
+}
+var appendUserMessage2 = appendUserMessage;
+var appendAssistantMessage2 = appendAssistantMessage;
+// src/components/chat/artifact/artifact-panel.svelte
+import * as $37 from "svelte/internal/server";
+function Artifact_panel($$renderer, $$props) {
+  let { instanceId = "artifact", title, onclose, children } = $$props;
+  const titleId = $37.derived(() => `${instanceId}-panel-title`);
+  function focusOnMount(element) {
+    element.focus();
+  }
+  $$renderer.push(`<div class="artifact-panel svelte-o3c2et" role="complementary"${$37.attr("aria-label", title ?? "Artifact panel")}><div class="artifact-panel-header svelte-o3c2et"><span class="artifact-panel-title svelte-o3c2et"${$37.attr("id", titleId())}>${$37.escape(title ?? "Artifact")}</span> <button type="button" class="artifact-panel-close svelte-o3c2et" aria-label="Close artifact panel">`);
+  X($$renderer, { class: "cinder-icon-sm" });
+  $$renderer.push(`<!----></button></div> <div class="artifact-panel-content svelte-o3c2et">`);
+  children($$renderer);
+  $$renderer.push(`<!----></div></div>`);
+}
+// src/components/chat/artifact/artifact-viewer.svelte
+import * as $38 from "svelte/internal/server";
+function wrapSvgInHtml(svg) {
+  return `<!DOCTYPE html><html><body style="margin:0;display:flex;align-items:center;justify-content:center;min-height:100vh;">${svg}</body></html>`;
+}
+function Artifact_viewer($$renderer, $$props) {
+  let { type, content, language, title } = $$props;
+  const svgDocument = $38.derived(() => type === "svg" ? wrapSvgInHtml(content) : "");
+  if (type === "html") {
+    $$renderer.push("<!--[0-->");
+    $$renderer.push(`<iframe class="artifact-viewer artifact-viewer-html svelte-c4pced"${$38.attr("srcdoc", content)} sandbox=""${$38.attr("title", title ?? "HTML artifact")}${$38.attr("aria-label", title ?? "HTML artifact")}></iframe>`);
+  } else if (type === "svg") {
+    $$renderer.push("<!--[1-->");
+    $$renderer.push(`<iframe class="artifact-viewer artifact-viewer-svg svelte-c4pced"${$38.attr("srcdoc", svgDocument())} sandbox=""${$38.attr("title", title ?? "SVG artifact")}${$38.attr("aria-label", title ?? "SVG artifact")}></iframe>`);
+  } else if (type === "code") {
+    $$renderer.push("<!--[2-->");
+    $$renderer.push(`<div class="artifact-viewer artifact-viewer-code svelte-c4pced"><pre class="artifact-code-block svelte-c4pced"${$38.attr("data-language", language)}><code class="svelte-c4pced">${$38.escape(content)}</code></pre></div>`);
+  } else if (type === "mermaid") {
+    $$renderer.push("<!--[3-->");
+    $$renderer.push(`<div class="artifact-viewer artifact-viewer-mermaid svelte-c4pced"><pre class="artifact-code-block svelte-c4pced" data-language="mermaid"><code class="svelte-c4pced">${$38.escape(content)}</code></pre> <p class="artifact-mermaid-note svelte-c4pced" aria-live="polite">Mermaid diagram source. Install the Mermaid library to render diagrams.</p></div>`);
+  } else {
+    $$renderer.push("<!--[-1-->");
+  }
+  $$renderer.push(`<!--]-->`);
+}
+// src/components/chat/artifact/chat-artifact-layout.svelte
+import * as $39 from "svelte/internal/server";
+function Chat_artifact_layout($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      instanceId = "artifact",
+      open = false,
+      children,
+      panel,
+      panelTitle,
+      onclose,
+      class: className
+    } = $$props;
+    $$renderer2.push(`<div${$39.attr_class($39.clsx(classNames("chat-artifact-layout", className)), "svelte-ed4g6")}${$39.attr("data-panel-open", open)}><div class="chat-artifact-main svelte-ed4g6">`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div> `);
+    if (open && panel) {
+      $$renderer2.push("<!--[0-->");
+      Artifact_panel($$renderer2, {
+        instanceId,
+        title: panelTitle,
+        onclose,
+        children: ($$renderer3) => {
+          panel($$renderer3);
+          $$renderer3.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Chat_artifact_layout);
+}
+// src/components/chat/index.ts
+var chat_default = Chat2;
+export { Chat_date_separator, Message_content, Tool_call_group, Message_attachments, Chat_message, deriveAttachmentKind, Chat_attachment_preview, Chat_input, DEFAULT_SCROLL_CONFIGURATION, isAtBottom, shouldShowJumpToLatest, calculateUnreadCount, findUnreadBoundaryIndex, calculateScrollToBottom, extractTimestamp, Chat2 as Chat, createConversation, appendMessages2 as appendMessages, appendUserMessage2 as appendUserMessage, appendAssistantMessage2 as appendAssistantMessage, Artifact_panel, Artifact_viewer, Chat_artifact_layout, chat_default };
+
+//# debugId=C6DF556ADAD5FCBD64756E2164756E21