@slices.sh/ai-chat 0.1.0

package/dist/headless/suggestion.js

@@ -0,0 +1,14 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ComposerContext } from "./contexts.js";
+function Suggestion({ text, ...props }) {
+  const composer = useRequired(ComposerContext, "Chat.Suggestion must be inside <Chat.Root>.");
+  return usePart("button", props, {
+    defaults: { type: "button", children: text },
+    behavior: { onClick: () => composer.submit(text) },
+    locked: { disabled: composer.disabled }
+  });
+}
+export {
+  Suggestion
+};

package/dist/headless/suggestions.d.ts

@@ -0,0 +1,8 @@
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * Starters, and only on an empty transcript.
+ *
+ * Once there is a conversation they are no longer suggestions, they are a row of buttons
+ * competing with what the person was about to type.
+ */
+export declare function Suggestions({ children }: GateProps): import("react").ReactNode;

package/dist/headless/suggestions.js

@@ -0,0 +1,12 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext } from "./contexts.js";
+function Suggestions({ children }) {
+  const chat = useRequired(ChatContext, "Chat.Suggestions must be inside <Chat.Root>.");
+  const { messages } = useChat({ chat });
+  return messages.length === 0 ? children : null;
+}
+export {
+  Suggestions
+};

package/dist/headless/thread.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Custom renderers retain MessageScroller.Content so anchor children and resizing stay registered. */
+export declare function Thread({ ref, ...props }: PartProps<"div">): import("react").ReactNode;

package/dist/headless/thread.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useMergedRef } from "./use-merged-ref.js";
+import { MessageScroller } from "@shadcn/react/message-scroller";
+import { usePart } from "@slices.sh/core/part";
+function Thread({ ref, ...props }) {
+  const element = useRef(null);
+  const merged = useMergedRef(element, ref);
+  useEffect(() => {
+    const content = element.current;
+    if (!content) return;
+    const registration = content.ownerDocument.createComment("initial-anchor");
+    content.append(registration);
+    registration.remove();
+  }, []);
+  return usePart(
+    "div",
+    { ...props, ref: merged, render: props.render ?? /* @__PURE__ */ jsx(MessageScroller.Content, {}) },
+    { locked: { role: "presentation" } }
+  );
+}
+export {
+  Thread
+};

package/dist/headless/timing.d.ts

@@ -0,0 +1,5 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { AiChatMetadata } from "../services/types";
+export declare function Timing({ children }: GateProps<{
+    timing: NonNullable<AiChatMetadata["timing"]>;
+}>): import("react").ReactNode;

package/dist/headless/timing.js

@@ -0,0 +1,13 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Timing({ children }) {
+  const message = useRequired(MessageScope, "Chat.Timing must be inside <Chat.Messages>.");
+  const timing = message.metadata?.timing;
+  if (!timing) return null;
+  return gateContent(children, { timing });
+}
+export {
+  Timing
+};

package/dist/headless/toggle-tool.d.ts

@@ -0,0 +1,4 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function ToggleTool({ tool, ...props }: PartProps<"button"> & {
+    tool: string;
+}): import("react").ReactNode;

package/dist/headless/toggle-tool.js

@@ -0,0 +1,15 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { SettingsContext } from "./contexts.js";
+function ToggleTool({ tool, ...props }) {
+  const settings = useRequired(SettingsContext, "Chat.ToggleTool requires Chat.Root.");
+  const part = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: settings.blocked, "aria-pressed": settings.selection.tools?.includes(tool) ?? false },
+    behavior: { onClick: () => settings.toggle(tool) }
+  });
+  return settings.choices?.tools?.some((option) => option.id === tool) ? part : null;
+}
+export {
+  ToggleTool
+};

package/dist/headless/tool-error.d.ts

@@ -0,0 +1,4 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function ToolError({ children }: GateProps<{
+    value: string;
+}>): import("react").ReactNode;

package/dist/headless/tool-error.js

@@ -0,0 +1,13 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function ToolError({ children }) {
+  const part = useRequired(PartScope, "Chat.ToolError requires Chat.Parts.");
+  if (!isToolUIPart(part) || !(part.state === "output-error")) return null;
+  return gateContent(children, { value: part.errorText });
+}
+export {
+  ToolError
+};

package/dist/headless/tool-input.d.ts

@@ -0,0 +1,4 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function ToolInput({ children }: GateProps<{
+    value: unknown;
+}>): import("react").ReactNode;

package/dist/headless/tool-input.js

@@ -0,0 +1,13 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function ToolInput({ children }) {
+  const part = useRequired(PartScope, "Chat.ToolInput requires Chat.Parts.");
+  if (!isToolUIPart(part) || !(part.input !== void 0)) return null;
+  return gateContent(children, { value: part.input });
+}
+export {
+  ToolInput
+};

package/dist/headless/tool-output.d.ts

@@ -0,0 +1,4 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function ToolOutput({ children }: GateProps<{
+    value: unknown;
+}>): import("react").ReactNode;

package/dist/headless/tool-output.js

@@ -0,0 +1,13 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function ToolOutput({ children }) {
+  const part = useRequired(PartScope, "Chat.ToolOutput requires Chat.Parts.");
+  if (!isToolUIPart(part) || !(part.state === "output-available")) return null;
+  return gateContent(children, { value: part.output });
+}
+export {
+  ToolOutput
+};

package/dist/headless/tool-renderer.d.ts

@@ -0,0 +1,13 @@
+import { type DynamicToolUIPart, type ToolUIPart } from "ai";
+import type { ComponentType } from "react";
+import { type RootProps } from "@slices.sh/core/part";
+export type ToolView = (ToolUIPart | DynamicToolUIPart) & {
+    toolName: string;
+};
+export type ToolRenderers = Record<string, ComponentType<{
+    tool: ToolView;
+}>>;
+/** Render only the tool body; approval controls stay outside the app's renderer. */
+export declare function ToolRenderer({ renderers, children }: RootProps & {
+    renderers?: ToolRenderers;
+}): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/headless/tool-renderer.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { getToolName, isToolUIPart } from "ai";
+import { useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+function ToolRenderer({ renderers, children }) {
+  const part = useRequired(PartScope, "Chat.ToolRenderer requires Chat.Parts.");
+  if (!isToolUIPart(part)) return null;
+  const name = getToolName(part);
+  const Renderer = renderers && Object.hasOwn(renderers, name) ? renderers[name] : void 0;
+  return Renderer ? /* @__PURE__ */ jsx(Renderer, { tool: { ...part, toolName: name } }) : children;
+}
+export {
+  ToolRenderer
+};

package/dist/headless/transcript.d.ts

@@ -0,0 +1,23 @@
+import { type PartProps } from "@slices.sh/core/part";
+/**
+ * The scroller, and the only one.
+ *
+ * A second scroller inside it produces a transcript that follows an end nobody can see: the
+ * outer one is already at its bottom, and the words arrive somewhere off screen.
+ *
+ * `role="log"` with `tabIndex` is the pair the APG asks for and the pair this was missing:
+ * the role makes arriving messages announce themselves, and the tab stop is the only way a
+ * keyboard reaches a scrolling region whose contents — bubbles, avatars — are not focusable.
+ *
+ * The busy flag belongs on the message being written and not here. On the region it held
+ * back everything the region was for: a polite log defers what arrives inside a busy node,
+ * so the question the person just sent and the note saying an answer is coming were both
+ * announced late or not at all — the two announcements that matter most, suppressed to
+ * defer the one that already defers itself. → components/headless/ai-chat/message.tsx
+ *
+ * The reader's own wheel, touch, keys and scrollbar are what take the transcript away from
+ * where the scroller put it; the scroller's own moves never do. → hooks/ai-chat/use-follow.ts
+ */
+export declare function Transcript(props: PartProps<"div", {
+    following: boolean;
+}>): import("react").ReactNode;

package/dist/headless/transcript.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { MessageScroller } from "@shadcn/react/message-scroller";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { FollowContext } from "./contexts.js";
+function Transcript(props) {
+  const follow = useRequired(FollowContext, "Chat.Transcript must be inside <Chat.Root>.");
+  const own = (event) => {
+    if (event.target === event.currentTarget) follow.release();
+  };
+  return usePart(
+    "div",
+    { ...props, render: props.render ?? /* @__PURE__ */ jsx(MessageScroller.Viewport, {}) },
+    {
+      behavior: { onWheel: follow.release, onTouchMove: follow.release, onKeyDown: own, onPointerDown: own },
+      state: { following: follow.following },
+      defaults: { role: "log", tabIndex: 0, "aria-live": "polite", "aria-relevant": "additions" },
+      attributes: { active: follow.following }
+    }
+  );
+}
+export {
+  Transcript
+};

package/dist/headless/try-again.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function TryAgain(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/try-again.js

@@ -0,0 +1,24 @@
+"use client";
+import { useRetryDelay } from "../hooks/use-retry-delay.js";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ChatContext } from "./contexts.js";
+function TryAgain(props) {
+  const chat = useRequired(ChatContext, "Chat.TryAgain must be inside <Chat.Root>.");
+  const { messages, regenerate, error, status } = useChat({ chat });
+  const { seconds, deadline } = useRetryDelay(error);
+  const disabled = status !== "error" || seconds > 0;
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled },
+    behavior: {
+      onClick: () => {
+        if (status === "error" && (deadline === null || Date.now() >= deadline)) void regenerate();
+      }
+    }
+  });
+  return messages.some((message) => message.role === "user") ? element : null;
+}
+export {
+  TryAgain
+};

package/dist/headless/unavailable.d.ts

@@ -0,0 +1,8 @@
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * No chat backend is installed at all, and the screen was handed no chat.
+ *
+ * Distinct from a refused turn, because nothing the person does will help: the app is
+ * missing an implementation, and the only useful sentence names the command that adds one.
+ */
+export declare function Unavailable({ children }: GateProps): import("react").ReactNode;

package/dist/headless/unavailable.js

@@ -0,0 +1,9 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { SourceContext } from "./contexts.js";
+function Unavailable({ children }) {
+  return useRequired(SourceContext, "Chat.Unavailable must be inside <Chat.Root>.") === "missing" ? children : null;
+}
+export {
+  Unavailable
+};

package/dist/headless/usage.d.ts

@@ -0,0 +1,13 @@
+import type { LanguageModelUsage } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * What the turn cost, where the provider said: the SDK's usage, as the route put it on the
+ * message's metadata when the turn finished.
+ *
+ * Nothing at all where it did not: this field went years declared and never written, and the
+ * website that needed it estimated from the length of the text. An estimate on screen is a
+ * number people plan against. → docs/rules/capability-honesty.md
+ */
+export declare function Usage({ children }: GateProps<{
+    usage: LanguageModelUsage;
+}>): import("react").ReactNode;

package/dist/headless/usage.js

@@ -0,0 +1,15 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Usage({ children }) {
+  const message = useRequired(MessageScope, "Chat.Usage must be inside <Chat.Messages>.");
+  const usage = message.metadata?.usage;
+  if (!usage || ![usage.totalTokens, usage.inputTokens, usage.outputTokens].some((count) => typeof count === "number")) {
+    return null;
+  }
+  return gateContent(children, { usage });
+}
+export {
+  Usage
+};

package/dist/headless/use-merged-ref.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from "react";
+export declare function useMergedRef<T>(ownRef: Ref<T> | undefined, callerRef: Ref<T> | undefined): (node: T | null) => void;

package/dist/headless/use-merged-ref.js

@@ -0,0 +1,17 @@
+import { useCallback } from "react";
+function useMergedRef(ownRef, callerRef) {
+  return useCallback(
+    (node) => {
+      assign(ownRef, node);
+      assign(callerRef, node);
+    },
+    [ownRef, callerRef]
+  );
+}
+function assign(ref, node) {
+  if (typeof ref === "function") ref(node);
+  else if (ref) ref.current = node;
+}
+export {
+  useMergedRef
+};

package/dist/headless/use-question.d.ts

@@ -0,0 +1,3 @@
+import type { Question } from "../services/types";
+/** The question a part is about, by the name the pattern gave it. */
+export declare function useQuestion(name: string, part: string): Question | undefined;

package/dist/headless/use-question.js

@@ -0,0 +1,9 @@
+import { useRequired } from "@slices.sh/core/part";
+import { QuestionInputContext } from "./contexts.js";
+function useQuestion(name, part) {
+  const input = useRequired(QuestionInputContext, `Chat.${part} requires Chat.PartQuestion.`);
+  return input.questions.find((question) => question.name === name);
+}
+export {
+  useQuestion
+};

package/dist/headless/waiting.d.ts

@@ -0,0 +1,13 @@
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * Sent, and nothing back yet: the SDK's `submitted`.
+ *
+ * Its own gate rather than a flag on a wider one, so the condition lives where the rule
+ * wants it and the pattern never writes `waiting ? … : null`. Once the words start arriving
+ * they are the answer to "is anything happening", and this renders nothing.
+ * → docs/rules/states-gate-themselves.md
+ *
+ * It belongs inside `Chat.Transcript`, whose `role="log"` announces what arrives in it. A
+ * second live region around this note would have a screen reader say it twice.
+ */
+export declare function Waiting({ children }: GateProps): import("react").ReactNode;

package/dist/headless/waiting.js

@@ -0,0 +1,12 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext } from "./contexts.js";
+function Waiting({ children }) {
+  const chat = useRequired(ChatContext, "Chat.Waiting must be inside <Chat.Root>.");
+  const { status } = useChat({ chat });
+  return status === "submitted" ? children : null;
+}
+export {
+  Waiting
+};

package/dist/headless/writing.d.ts

@@ -0,0 +1,13 @@
+import type { ChatStatus } from "ai";
+import type { AiChatMessage } from "../services/types";
+/** Whether this is the answer the chat is writing right now. */
+export declare function isWriting(message: AiChatMessage, messages: AiChatMessage[], status: ChatStatus): boolean;
+/**
+ * Whether an answer ended before it finished.
+ *
+ * The SDK keeps no flag for it and needs none: a text or a trace is `streaming` until its
+ * `-end` chunk arrives, so one still `streaming` on a message nobody is writing is one whose
+ * stream was cut — stopped, or broken — and it says so in a transcript saved and read back
+ * next week too. An answer with nothing in it at all was cut before it said anything.
+ */
+export declare function isCutOff(message: AiChatMessage, writing: boolean): boolean;

package/dist/headless/writing.js

@@ -0,0 +1,12 @@
+function isWriting(message, messages, status) {
+  return message.role === "assistant" && (status === "submitted" || status === "streaming") && messages.at(-1)?.id === message.id;
+}
+function isCutOff(message, writing) {
+  if (message.role !== "assistant" || writing) return false;
+  const content = message.parts.filter((part) => part.type !== "step-start");
+  return message.metadata?.finishReason === "length" || content.length === 0 || content.some((part) => (part.type === "text" || part.type === "reasoning") && part.state === "streaming");
+}
+export {
+  isCutOff,
+  isWriting
+};

package/dist/hooks/chat-refusal.d.ts

@@ -0,0 +1,18 @@
+import { type ChatErrorSlug } from "../services/types";
+/**
+ * Which refusal the AI SDK's error was, so a screen can say something true about it.
+ *
+ * The SDK holds a failed turn as an `Error`: an `APICallError` with the status and the body
+ * when the route refused before streaming, a plain one with the `error` chunk's text when it
+ * failed once the stream was open. A route writes the same JSON in both places
+ * (→ services/ai-chat/errors.ts), and something in front of it — a proxy, a platform — may
+ * answer with a bare status instead, which still says which refusal it was.
+ */
+export declare function refusalOf(error: unknown): ChatErrorSlug;
+/**
+ * The JSON a route refused with, wherever the SDK put it, or `null` when the failure was not
+ * one a route wrote (a dropped connection, a proxy's page).
+ */
+export declare function refusalBody(error: unknown): unknown;
+/** Only the contract's absolute deadline survives both HTTP and streaming refusals. */
+export declare function retryAtOf(error: unknown): number | null;

package/dist/hooks/chat-refusal.js

@@ -0,0 +1,44 @@
+import { APICallError } from "ai";
+import { MISSING_CONFIGURATION } from "@slices.sh/core/configuration";
+import { isChatErrorSlug } from "../services/types.js";
+function refusalOf(error) {
+  const said = slugIn(refusalBody(error));
+  if (said) return said;
+  if (APICallError.isInstance(error) && typeof error.statusCode === "number") {
+    return STATUS_SLUGS[error.statusCode] ?? "ai-chat/unavailable";
+  }
+  return "ai-chat/unavailable";
+}
+function refusalBody(error) {
+  if (!(error instanceof Error)) return null;
+  try {
+    return JSON.parse(error.message);
+  } catch {
+    return null;
+  }
+}
+function slugIn(body) {
+  const slug = body?.error;
+  if (slug === MISSING_CONFIGURATION) return "ai-chat/model-unavailable";
+  return isChatErrorSlug(slug) ? slug : null;
+}
+const STATUS_SLUGS = {
+  400: "ai-chat/invalid-request",
+  401: "ai-chat/unauthorized",
+  402: "ai-chat/quota-exceeded",
+  403: "ai-chat/forbidden",
+  404: "ai-chat/unknown-chat",
+  429: "ai-chat/rate-limited",
+  502: "ai-chat/model-unavailable",
+  503: "ai-chat/unavailable"
+};
+function retryAtOf(error) {
+  const body = refusalBody(error);
+  const value = body?.retryAt;
+  return isChatErrorSlug(body?.error) && typeof value === "number" && Number.isFinite(value) && value > 0 && value <= 864e13 ? value : null;
+}
+export {
+  refusalBody,
+  refusalOf,
+  retryAtOf
+};

package/dist/hooks/turn-mailbox.d.ts

@@ -0,0 +1,14 @@
+import type { FileUIPart } from "ai";
+import type { AiChat } from "./use-chat-instance";
+import type { QueuedTurn, QueueChange } from "./use-turn-queue";
+export declare function createMailbox(): {
+    open(): () => void;
+    snapshot: () => readonly QueuedTurn[];
+    watch(listener: () => void): () => void;
+    drain: (chat: AiChat, settled?: boolean) => void;
+    apply: (action: QueueChange | {
+        type: "enqueue";
+        text: string;
+        files?: readonly FileUIPart[];
+    }, chat: AiChat) => void;
+};

package/dist/hooks/turn-mailbox.js

@@ -0,0 +1,114 @@
+import { approvalDecided, blockedBy, skipQuestions } from "../services/types.js";
+function createMailbox() {
+  let items = [];
+  let sequence = 0;
+  let open = false;
+  let holds = 0;
+  const watchers = /* @__PURE__ */ new Set();
+  const change = (next) => {
+    items = next;
+    for (const watcher of [...watchers]) watcher();
+  };
+  const running = (chat) => chat.status === "submitted" || chat.status === "streaming";
+  const blocker = (chat) => blockedBy(chat.messages, running(chat));
+  function hold(chat, work) {
+    holds++;
+    void work().finally(() => {
+      holds--;
+      drain(chat);
+    });
+  }
+  let settling = false;
+  function settle(chat) {
+    if (settling) return;
+    settling = true;
+    setTimeout(() => {
+      settling = false;
+      drain(chat, true);
+    }, 0);
+  }
+  function drain(chat, settled = false) {
+    if (!open || holds || running(chat) || blocker(chat) || !items.length || items[0].draft !== null) return;
+    if (!settled && approvalDecided(chat.messages)) return settle(chat);
+    const item = items[0];
+    change(items.slice(1));
+    hold(chat, () => chat.sendMessage({ text: item.text, ...item.files?.length ? { files: item.files } : {} }));
+  }
+  function skip(chat, id) {
+    hold(chat, async () => {
+      if (!await skipQuestions(chat, id)) return;
+      if (!items.length || items[0].draft !== null) await chat.sendMessage();
+    });
+  }
+  function apply(action, chat) {
+    if (action.type === "enqueue") {
+      change([
+        ...items,
+        {
+          id: `queued-${++sequence}`,
+          text: action.text,
+          draft: null,
+          ...action.files?.length ? { files: action.files.map((file) => ({ ...file })) } : {}
+        }
+      ]);
+      drain(chat);
+      return;
+    }
+    if (action.type === "skip-question") {
+      skip(chat, action.toolCallId);
+      return;
+    }
+    const item = items.find((item2) => item2.id === action.id);
+    if (!item) return;
+    switch (action.type) {
+      case "remove":
+        change(items.filter((row) => row.id !== item.id));
+        break;
+      case "begin-edit":
+        change(items.map((row) => row.id === item.id ? { ...row, draft: row.text } : row));
+        break;
+      case "edit":
+        if (item.draft !== null)
+          change(items.map((row) => row.id === item.id ? { ...row, draft: action.text } : row));
+        break;
+      case "save-edit":
+        if (item.draft === null || !item.draft.trim() && !item.files?.length) return;
+        change(
+          items.map((row) => row.id === item.id ? { ...row, text: item.draft.trim(), draft: null } : row)
+        );
+        break;
+      case "cancel-edit":
+        change(items.map((row) => row.id === item.id ? { ...row, draft: null } : row));
+        break;
+      case "send-now": {
+        const waitingFor = blocker(chat);
+        if (item.draft !== null || waitingFor !== null && waitingFor !== "question") return;
+        change([item, ...items.filter((row) => row.id !== item.id)]);
+        if (waitingFor === "question") hold(chat, () => skipQuestions(chat));
+        else if (running(chat)) void chat.stop().finally(() => drain(chat));
+        break;
+      }
+    }
+    drain(chat);
+  }
+  return {
+    open() {
+      open = true;
+      return () => {
+        open = false;
+      };
+    },
+    snapshot: () => items,
+    watch(listener) {
+      watchers.add(listener);
+      return () => {
+        watchers.delete(listener);
+      };
+    },
+    drain,
+    apply
+  };
+}
+export {
+  createMailbox
+};

package/dist/hooks/use-branches.d.ts

@@ -0,0 +1,10 @@
+import { type BranchPage } from "../services/types";
+import type { AiChat } from "./use-chat-instance";
+export type Branches = {
+    blocked: boolean;
+    page: (messageId: string) => BranchPage | null;
+    regenerate: (messageId: string) => void;
+    edit: (messageId: string, text: string) => boolean;
+    move: (groupId: string, delta: number) => void;
+};
+export declare function useBranches(chat: AiChat, enabled?: boolean): Branches;