@slices.sh/ai-chat 0.1.0

package/dist/headless/clear-answer.js

@@ -0,0 +1,19 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionDraftContext, QuestionWriteContext } from "./contexts.js";
+import { useQuestion } from "./use-question.js";
+function ClearAnswer({ name, ...props }) {
+  const question = useQuestion(name, "ClearAnswer");
+  const draft = useRequired(QuestionDraftContext, "Chat.ClearAnswer requires Chat.PartQuestion.");
+  const write = useRequired(QuestionWriteContext, "Chat.ClearAnswer requires Chat.PartQuestion.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: write.pending },
+    behavior: { onClick: () => draft.change(name, { type: "clear" }) }
+  });
+  const filled = draft.answers[name] !== void 0 || draft.other(name).on;
+  return question && !question.required && filled ? element : null;
+}
+export {
+  ClearAnswer
+};

package/dist/headless/composer-root.d.ts

@@ -0,0 +1,14 @@
+import type { ChatSettings } from "../services/types";
+import type { AiChat } from "../hooks/use-chat-instance";
+import { type RootProps } from "@slices.sh/core/part";
+type ComposerRootProps = RootProps & {
+    name: string;
+    chat?: AiChat;
+    settings?: ChatSettings | null;
+};
+/** Reuses the containing chat, so embedding a composer never starts a second conversation.
+ *
+ * @deprecated Chat.ComposerRoot becomes a nested Chat.Root, which shares the outer conversation for the same config.
+ */
+export declare function ComposerRoot({ children, ...props }: ComposerRootProps): import("react").JSX.Element;
+export {};

package/dist/headless/composer-root.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+import { ChatContext, ComposerStandaloneContext } from "./contexts.js";
+import { Root } from "./root.js";
+function ComposerRoot({ children, ...props }) {
+  const chat = useContext(ChatContext);
+  return /* @__PURE__ */ jsx(ComposerStandaloneContext, { value: chat ? "embedded" : "standalone", children: chat ? children : /* @__PURE__ */ jsx(Root, { ...props, children }) });
+}
+export {
+  ComposerRoot
+};

package/dist/headless/composer-standalone.d.ts

@@ -0,0 +1,3 @@
+import { type GateProps } from "@slices.sh/core/part";
+/** @deprecated Chat.ComposerStandalone has no replacement: a pattern that draws Chat.Settings only when it stands alone takes a prop for it. */
+export declare function ComposerStandalone({ children }: GateProps): import("react").ReactNode;

package/dist/headless/composer-standalone.js

@@ -0,0 +1,10 @@
+"use client";
+import { useContext } from "react";
+import { ComposerStandaloneContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function ComposerStandalone({ children }) {
+  return useContext(ComposerStandaloneContext) === "standalone" ? gateContent(children, {}) : null;
+}
+export {
+  ComposerStandalone
+};

package/dist/headless/composer.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** @deprecated Chat.Composer becomes Composer.Root from @slices.sh/composer: Chat.Root is the sink it sends into. */
+export declare function Composer(props: PartProps<"form">): import("react").ReactNode;

package/dist/headless/composer.js

@@ -0,0 +1,24 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ComposerContext } from "./contexts.js";
+function Composer(props) {
+  const composer = useRequired(ComposerContext, "Chat.Composer must be inside <Chat.Root>.");
+  return usePart("form", props, {
+    behavior: {
+      onClick: (event) => {
+        const target = event.target;
+        if (!(target instanceof Element) || target.closest("button,a,input,textarea,select,label,[role=button]"))
+          return;
+        event.currentTarget.querySelector("textarea")?.focus();
+      },
+      onSubmit: (event) => {
+        event.preventDefault();
+        composer.submit();
+      }
+    },
+    attributes: { pending: composer.disabled }
+  });
+}
+export {
+  Composer
+};

package/dist/headless/context-usage.d.ts

@@ -0,0 +1,3 @@
+import { type ContextUsage as UsageState } from "../hooks/use-context-usage";
+import { type GateProps } from "@slices.sh/core/part";
+export declare function ContextUsage({ children }: GateProps<UsageState>): import("react").ReactNode;

package/dist/headless/context-usage.js

@@ -0,0 +1,13 @@
+"use client";
+import { useContextUsage } from "../hooks/use-context-usage.js";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function ContextUsage({ children }) {
+  const chat = useRequired(ChatContext, "Chat.ContextUsage must be inside <Chat.Root>.");
+  const usage = useContextUsage(chat);
+  return usage ? gateContent(children, usage) : null;
+}
+export {
+  ContextUsage
+};

package/dist/headless/contexts.d.ts

@@ -0,0 +1,77 @@
+import type { ChatFeedbackOptions } from "../services/types";
+import type { Branches } from "../hooks/use-branches";
+import type { SentDraft } from "../hooks/use-sent-draft";
+import type { QueuedTurn } from "../hooks/use-turn-queue";
+import type { Reasoning } from "../hooks/use-reasoning";
+import type { QuestionDraft } from "../hooks/use-question-draft";
+import type { QuestionWrite } from "../hooks/use-question-write";
+import type { QuestionCheck } from "../hooks/use-question-check";
+import type { QuestionSteps } from "../hooks/use-question-steps";
+import type { ToolApprovalMemory } from "../hooks/use-tool-approval-memory";
+import type { ApprovalAutomation } from "../hooks/use-remembered-approvals";
+import type { ToolApproval } from "../hooks/use-tool-approval";
+import type { AiChat, ChatSource } from "../hooks/use-chat-instance";
+import type { Composer, ComposerPlacement, ComposerAttachments } from "../hooks/use-composer";
+import type { Follow } from "../hooks/use-follow";
+import type { TurnQueue } from "../hooks/use-turn-queue";
+import type { AiChatMessage } from "../services/types";
+/**
+ * The AI SDK's chat itself, not a copy of its state: every part that needs the transcript,
+ * the status or the error reads it with the SDK's `useChat({ chat })`.
+ */
+export declare const SettingsContext: import("react").Context<{
+    blocked: boolean;
+    model: (id: string) => void;
+    toggle: (id: string) => void;
+    removeLast: () => boolean;
+    choices: import("../services/choices").ChatChoices | null;
+    selection: import("../services/choices").ChatSelection;
+} | null>;
+export declare const ChatContext: import("react").Context<AiChat | null>;
+/** The config the conversation above talks to, so a Root inside it knows whether it shares it. */
+export declare const ChatConfigContext: import("react").Context<string | null>;
+/** Whether anything answers the chat, for the one gate that says nothing does. */
+export declare const SourceContext: import("react").Context<ChatSource | null>;
+export declare const ComposerContext: import("react").Context<Composer | null>;
+export declare const FollowContext: import("react").Context<Follow | null>;
+export declare const QueueContext: import("react").Context<TurnQueue | null>;
+/** The message a part is drawn for, as the SDK holds it, so `Chat.Copy` needs no props. */
+export declare const MessageScope: import("react").Context<AiChatMessage | null>;
+/** One of its parts, as the SDK holds it, so a gate per kind needs none either. */
+export declare const PartScope: import("react").Context<import("ai").UIMessagePart<import("ai").UIDataTypes, import("ai").UITools> | null>;
+export declare const ApprovalContext: import("react").Context<ToolApproval | null>;
+export declare const ApprovalMemoryContext: import("react").Context<ToolApprovalMemory | null>;
+export declare const ApprovalAutomationContext: import("react").Context<ApprovalAutomation | null>;
+export declare const QuestionInputContext: import("react").Context<{
+    title: string;
+    questions: {
+        name: string;
+        title: string;
+        choices: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[];
+        description?: string | undefined;
+        multiple?: boolean | undefined;
+        required?: boolean | undefined;
+        other?: string | undefined;
+    }[];
+} | null>;
+export declare const QuestionDraftContext: import("react").Context<QuestionDraft | null>;
+export declare const QuestionCheckContext: import("react").Context<QuestionCheck | null>;
+export declare const QuestionStepsContext: import("react").Context<QuestionSteps | null>;
+export declare const QuestionWriteContext: import("react").Context<QuestionWrite | null>;
+export declare const ReasoningContext: import("react").Context<Reasoning | null>;
+export declare const QueueScope: import("react").Context<QueuedTurn | null>;
+export declare const ComposerStandaloneContext: import("react").Context<ComposerPlacement>;
+export declare const ComposerAttachmentsContext: import("react").Context<ComposerAttachments | null>;
+export declare const BranchContext: import("react").Context<Branches | null>;
+export declare const SentDraftContext: import("react").Context<SentDraft | null>;
+export declare const FeedbackOptionsContext: import("react").Context<ChatFeedbackOptions>;
+export declare const FeedbackContext: import("react").Context<{
+    rating: "up" | "down" | null;
+    pending: boolean;
+    failed: boolean;
+    submit: (choice: "up" | "down") => Promise<void>;
+} | null>;

package/dist/headless/contexts.js

@@ -0,0 +1,53 @@
+import { createContext } from "react";
+const SettingsContext = createContext(null);
+const ChatContext = createContext(null);
+const ChatConfigContext = createContext(null);
+const SourceContext = createContext(null);
+const ComposerContext = createContext(null);
+const FollowContext = createContext(null);
+const QueueContext = createContext(null);
+const MessageScope = createContext(null);
+const PartScope = createContext(null);
+const ApprovalContext = createContext(null);
+const ApprovalMemoryContext = createContext(null);
+const ApprovalAutomationContext = createContext(null);
+const QuestionInputContext = createContext(null);
+const QuestionDraftContext = createContext(null);
+const QuestionCheckContext = createContext(null);
+const QuestionStepsContext = createContext(null);
+const QuestionWriteContext = createContext(null);
+const ReasoningContext = createContext(null);
+const QueueScope = createContext(null);
+const ComposerStandaloneContext = createContext("embedded");
+const ComposerAttachmentsContext = createContext(null);
+const BranchContext = createContext(null);
+const SentDraftContext = createContext(null);
+const FeedbackOptionsContext = createContext({});
+const FeedbackContext = createContext(null);
+export {
+  ApprovalAutomationContext,
+  ApprovalContext,
+  ApprovalMemoryContext,
+  BranchContext,
+  ChatConfigContext,
+  ChatContext,
+  ComposerAttachmentsContext,
+  ComposerContext,
+  ComposerStandaloneContext,
+  FeedbackContext,
+  FeedbackOptionsContext,
+  FollowContext,
+  MessageScope,
+  PartScope,
+  QuestionCheckContext,
+  QuestionDraftContext,
+  QuestionInputContext,
+  QuestionStepsContext,
+  QuestionWriteContext,
+  QueueContext,
+  QueueScope,
+  ReasoningContext,
+  SentDraftContext,
+  SettingsContext,
+  SourceContext
+};

package/dist/headless/continue.d.ts

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

package/dist/headless/continue.js

@@ -0,0 +1,26 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ChatContext, MessageScope } from "./contexts.js";
+import { isCutOff, isWriting } from "./writing.js";
+function Continue({ prompt, ...props }) {
+  const chat = useRequired(ChatContext, "Chat.Continue requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.Continue requires Chat.Messages.");
+  const { messages, status } = useChat({ chat });
+  const running = status === "submitted" || status === "streaming";
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: running },
+    behavior: {
+      onClick: () => {
+        if (chat.status === "submitted" || chat.status === "streaming" || chat.messages.at(-1)?.id !== message.id)
+          return;
+        void chat.sendMessage({ text: prompt, metadata: { intent: "continue", continues: message.id } });
+      }
+    }
+  });
+  return messages.at(-1)?.id === message.id && isCutOff(message, isWriting(message, messages, status)) ? element : null;
+}
+export {
+  Continue
+};

package/dist/headless/copy.d.ts

@@ -0,0 +1,11 @@
+import { type PartProps } from "@slices.sh/core/part";
+/**
+ * Puts this message's text on the clipboard, and says so.
+ *
+ * The text and nothing else: a reader copying an answer wants the answer, not the reasoning
+ * trace above it or the JSON of a tool call beside it. Runs of prose a tool call separated
+ * stay separate paragraphs.
+ */
+export declare function Copy(props: PartProps<"button", {
+    copied: boolean;
+}>): import("react").ReactNode;

package/dist/headless/copy.js

@@ -0,0 +1,21 @@
+"use client";
+import { useCopied } from "../hooks/use-copied.js";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+function Copy(props) {
+  const message = useRequired(MessageScope, "Chat.Copy must be inside <Chat.Messages>.");
+  const clipboard = useCopied();
+  return usePart("button", props, {
+    state: { copied: clipboard.copied },
+    defaults: { type: "button" },
+    behavior: {
+      onClick: () => clipboard.copy(
+        message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n\n")
+      )
+    },
+    attributes: { active: clipboard.copied }
+  });
+}
+export {
+  Copy
+};

package/dist/headless/deny.d.ts

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

package/dist/headless/deny.js

@@ -0,0 +1,15 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ApprovalContext } from "./contexts.js";
+function Deny(props) {
+  const write = useRequired(ApprovalContext, "Chat.Deny requires Chat.PartApproval.");
+  return usePart("button", props, {
+    state: { pending: write.pending },
+    defaults: { type: "button" },
+    locked: { disabled: write.pending },
+    behavior: { onClick: () => void write.run({ approved: false }) }
+  });
+}
+export {
+  Deny
+};

package/dist/headless/edit-queued.d.ts

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

package/dist/headless/edit-queued.js

@@ -0,0 +1,15 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QueueContext, QueueScope } from "./contexts.js";
+function EditQueued(props) {
+  const queue = useRequired(QueueContext, "Chat.EditQueued requires Chat.Root.");
+  const item = useRequired(QueueScope, "Chat.EditQueued requires Chat.QueueItems.");
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: false },
+    behavior: { onClick: () => queue.change({ type: "begin-edit", id: item.id }) }
+  });
+}
+export {
+  EditQueued
+};

package/dist/headless/edit.d.ts

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

package/dist/headless/edit.js

@@ -0,0 +1,17 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope, SentDraftContext } from "./contexts.js";
+function Edit(props) {
+  const branches = useRequired(BranchContext, "Chat.Edit requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.Edit requires Chat.Messages.");
+  const draft = useRequired(SentDraftContext, "Chat.Edit requires Chat.MessageEditRoot.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: branches.blocked, hidden: draft.value !== null },
+    behavior: { onClick: draft.start }
+  });
+  return message.role === "user" ? element : null;
+}
+export {
+  Edit
+};

package/dist/headless/edited-attachments.d.ts

@@ -0,0 +1,5 @@
+import type { FileUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+export declare function EditedAttachments({ children }: GateProps<{
+    files: readonly FileUIPart[];
+}>): import("react").ReactNode;

package/dist/headless/edited-attachments.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+function EditedAttachments({ children }) {
+  const message = useRequired(MessageScope, "Chat.EditedAttachments requires Chat.Messages.");
+  const files = message.parts.filter((part) => part.type === "file");
+  return files.length ? typeof children === "function" ? children({ files }) : children : null;
+}
+export {
+  EditedAttachments
+};

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

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

package/dist/headless/edited-input.js

@@ -0,0 +1,28 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, SentDraftContext } from "./contexts.js";
+function EditedInput(props) {
+  const branches = useRequired(BranchContext, "Chat.EditedInput requires Chat.Root.");
+  const draft = useRequired(SentDraftContext, "Chat.EditedInput requires Chat.MessageEditRoot.");
+  return usePart("textarea", props, {
+    defaults: { autoFocus: true },
+    locked: { value: draft.value ?? "", disabled: branches.blocked },
+    behavior: {
+      onChange: (event) => draft.set(event.currentTarget.value),
+      onKeyDown: (event) => {
+        if (event.nativeEvent.isComposing) return;
+        if (event.key === "Escape") {
+          event.preventDefault();
+          draft.cancel();
+        }
+        if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+          event.preventDefault();
+          event.currentTarget.form?.requestSubmit();
+        }
+      }
+    }
+  });
+}
+export {
+  EditedInput
+};

package/dist/headless/empty.d.ts

@@ -0,0 +1,3 @@
+import { type GateProps } from "@slices.sh/core/part";
+/** Nothing has been said yet. Where a greeting and the starters go. */
+export declare function Empty({ children }: GateProps): import("react").ReactNode;

package/dist/headless/empty.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 Empty({ children }) {
+  const chat = useRequired(ChatContext, "Chat.Empty must be inside <Chat.Root>.");
+  const { messages } = useChat({ chat });
+  return messages.length === 0 ? children : null;
+}
+export {
+  Empty
+};

package/dist/headless/failed.d.ts

@@ -0,0 +1,15 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { ChatErrorSlug } from "../services/types";
+/**
+ * The turn was refused — the SDK's `error` status — and the child is told which refusal it
+ * was.
+ *
+ * The slug reaches the screen because the common ones want different things: a quota
+ * refusal wants an upgrade link, an outage wants the retry button, and an unknown chat wants
+ * a developer to open `services/ai-chat/config.ts`. One banner for all three would be three
+ * lies. → docs/rules/capability-honesty.md
+ */
+export declare function Failed({ children }: GateProps<{
+    error: ChatErrorSlug;
+    retryIn: number;
+}>): import("react").ReactNode;

package/dist/headless/failed.js

@@ -0,0 +1,17 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useRetryDelay } from "../hooks/use-retry-delay.js";
+import { refusalOf } from "../hooks/chat-refusal.js";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Failed({ children }) {
+  const chat = useRequired(ChatContext, "Chat.Failed must be inside <Chat.Root>.");
+  const { status, error } = useChat({ chat });
+  const { seconds } = useRetryDelay(error);
+  if (status !== "error") return null;
+  return gateContent(children, { error: refusalOf(error), retryIn: seconds });
+}
+export {
+  Failed
+};

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

@@ -0,0 +1,2 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function FeedbackError({ children }: GateProps): import("react").ReactNode;

package/dist/headless/feedback-error.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { FeedbackContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function FeedbackError({ children }) {
+  const feedback = useRequired(FeedbackContext, "Chat.FeedbackError requires Chat.FeedbackRoot.");
+  return feedback.failed ? gateContent(children, {}) : null;
+}
+export {
+  FeedbackError
+};

package/dist/headless/feedback-root.d.ts

@@ -0,0 +1,2 @@
+import { type RootProps } from "@slices.sh/core/part";
+export declare function FeedbackRoot({ children }: RootProps): import("react").JSX.Element | null;

package/dist/headless/feedback-root.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+import { useFeedback } from "../hooks/use-feedback.js";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext, MessageScope, FeedbackContext, FeedbackOptionsContext } from "./contexts.js";
+function FeedbackRoot({ children }) {
+  const chat = useRequired(ChatContext, "Chat.FeedbackRoot requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.FeedbackRoot requires Chat.Messages.");
+  const { onFeedback } = useContext(FeedbackOptionsContext);
+  return onFeedback && message.role === "assistant" ? /* @__PURE__ */ jsx(Session, { chatId: chat.id, messageId: message.id, onFeedback, children }, chat.id + ":" + message.id) : null;
+}
+function Session({
+  chatId,
+  messageId,
+  onFeedback,
+  children
+}) {
+  const feedback = useFeedback({ chatId, messageId }, onFeedback);
+  return /* @__PURE__ */ jsx(FeedbackContext, { value: feedback, children });
+}
+export {
+  FeedbackRoot
+};

package/dist/headless/feedback.d.ts

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

package/dist/headless/feedback.js

@@ -0,0 +1,18 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { FeedbackContext } from "./contexts.js";
+function Feedback({ rating, ...props }) {
+  const feedback = useRequired(FeedbackContext, "Chat.Feedback requires Chat.FeedbackRoot.");
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    locked: {
+      disabled: feedback.pending,
+      "aria-pressed": feedback.rating === rating,
+      "aria-busy": feedback.pending
+    },
+    behavior: { onClick: () => void feedback.submit(rating) }
+  });
+}
+export {
+  Feedback
+};

package/dist/headless/file-audio.d.ts

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

package/dist/headless/file-audio.js

@@ -0,0 +1,16 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { FileContext, FileLoadContext } from "./file-context.js";
+function FileAudio(props) {
+  const media = useRequired(FileContext, "Chat.FileAudio requires Chat.FileRoot.");
+  const load = useRequired(FileLoadContext, "File media requires Chat.FileRoot.");
+  const element = usePart("audio", props, {
+    behavior: { onError: load.fail },
+    locked: { src: media.url ?? void 0 },
+    defaults: { controls: true, preload: "none" }
+  });
+  return !load.failed && media.url && media.kind === "audio" ? element : null;
+}
+export {
+  FileAudio
+};

package/dist/headless/file-context.d.ts

@@ -0,0 +1,4 @@
+import type { ChatMedia } from "../services/types";
+export declare const FileContext: import("react").Context<ChatMedia | null>;
+import type { MediaLoad } from "../hooks/use-media-load";
+export declare const FileLoadContext: import("react").Context<MediaLoad | null>;

package/dist/headless/file-context.js

@@ -0,0 +1,7 @@
+import { createContext } from "react";
+const FileContext = createContext(null);
+const FileLoadContext = createContext(null);
+export {
+  FileContext,
+  FileLoadContext
+};

package/dist/headless/file-img.d.ts

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

package/dist/headless/file-img.js

@@ -0,0 +1,21 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { FileContext, FileLoadContext } from "./file-context.js";
+function FileImage(props) {
+  const media = useRequired(FileContext, "Chat.FileImage requires Chat.FileRoot.");
+  const load = useRequired(FileLoadContext, "File media requires Chat.FileRoot.");
+  const element = usePart("img", props, {
+    behavior: { onError: load.fail },
+    locked: { src: media.url ?? void 0 },
+    defaults: {
+      alt: media.file.filename ?? "",
+      loading: "lazy",
+      decoding: "async",
+      referrerPolicy: "no-referrer"
+    }
+  });
+  return !load.failed && media.url && media.kind === "image" ? element : null;
+}
+export {
+  FileImage
+};

package/dist/headless/file-kind-gate.d.ts

@@ -0,0 +1,5 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { ChatMediaKind } from "../services/types";
+export declare function FileKind({ kind, children }: GateProps & {
+    kind: ChatMediaKind;
+}): import("react").ReactNode;