@slices.sh/ai-chat 0.1.0

package/dist/fixture/provider.js

@@ -0,0 +1,14 @@
+import { definePlainProvider } from "@slices.sh/core";
+import { createAiChatFixture } from "./fixture.js";
+function fixture(options = {}) {
+  const { scenario = "ready" } = options;
+  return definePlainProvider({
+    provider: "fixture",
+    package: "@slices.sh/ai-chat/fixture",
+    capabilities: { reasoning: true, tools: true, toolApproval: true, toolChoices: true, models: true, sources: true, usage: true },
+    client: () => createAiChatFixture(scenario).client
+  });
+}
+export {
+  fixture
+};

package/dist/headless/always-allow.d.ts

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

package/dist/headless/always-allow.js

@@ -0,0 +1,24 @@
+"use client";
+import { getToolName, isToolUIPart } from "ai";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ApprovalContext, ApprovalMemoryContext, PartScope } from "./contexts.js";
+function AlwaysAllow(props) {
+  const write = useRequired(ApprovalContext, "Chat.AlwaysAllow requires Chat.PartApproval.");
+  const memory = useRequired(ApprovalMemoryContext, "Chat.AlwaysAllow requires Chat.Root.");
+  const part = useRequired(PartScope, "Chat.AlwaysAllow requires Chat.Parts.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: write.pending },
+    behavior: {
+      onClick: () => {
+        if (!memory.enabled || !isToolUIPart(part)) return;
+        memory.remember(getToolName(part));
+        void write.run({ approved: true });
+      }
+    }
+  });
+  return memory.enabled ? element : null;
+}
+export {
+  AlwaysAllow
+};

package/dist/headless/answer.d.ts

@@ -0,0 +1,6 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** One choice: a radio in a single question and a checkbox in a multiple one, so the kind is plain before anything is touched. */
+export declare function Answer({ name, value, ...props }: PartProps<"input"> & {
+    name: string;
+    value: string;
+}): import("react").ReactNode;

package/dist/headless/answer.js

@@ -0,0 +1,29 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionCheckContext, QuestionDraftContext, QuestionWriteContext } from "./contexts.js";
+import { useQuestion } from "./use-question.js";
+function Answer({ name, value, ...props }) {
+  const question = useQuestion(name, "Answer");
+  const draft = useRequired(QuestionDraftContext, "Chat.Answer requires Chat.PartQuestion.");
+  const check = useRequired(QuestionCheckContext, "Chat.Answer requires Chat.PartQuestion.");
+  const write = useRequired(QuestionWriteContext, "Chat.Answer requires Chat.PartQuestion.");
+  const multiple = Boolean(question?.multiple);
+  const position = question?.choices.findIndex((choice) => choice.value === value) ?? -1;
+  return usePart("input", props, {
+    behavior: { onChange: () => draft.change(name, { type: "choose", value }) },
+    locked: {
+      type: multiple ? "checkbox" : "radio",
+      name,
+      value,
+      checked: draft.picked(name, value),
+      disabled: write.pending,
+      // The number a key press picks it by; the question's own fieldset listens for it.
+      "aria-keyshortcuts": position >= 0 ? String(position + 1) : void 0,
+      // A radiogroup carries the invalid state itself, so only checkboxes do.
+      "aria-invalid": multiple && check.shown(name) ? true : void 0
+    }
+  });
+}
+export {
+  Answer
+};

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

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

package/dist/headless/approval-error.js

@@ -0,0 +1,16 @@
+"use client";
+import { useContext } from "react";
+import { isToolUIPart } from "ai";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ApprovalContext, ApprovalAutomationContext, PartScope } from "./contexts.js";
+function ApprovalError(props) {
+  const { error } = useRequired(ApprovalContext, "Chat.ApprovalError requires Chat.PartApproval.");
+  const automatic = useContext(ApprovalAutomationContext)?.failure;
+  const part = useRequired(PartScope, "Chat.ApprovalError requires Chat.Parts.");
+  const failed = error || isToolUIPart(part) && part.approval?.id === automatic?.id && automatic;
+  const element = usePart("p", props, { defaults: { role: "alert" } });
+  return failed ? element : null;
+}
+export {
+  ApprovalError
+};

package/dist/headless/approval-reason.d.ts

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

package/dist/headless/approval-reason.js

@@ -0,0 +1,13 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+function ApprovalReason(props) {
+  const part = useRequired(PartScope, "Chat.ApprovalReason requires Chat.Parts.");
+  const reason = isToolUIPart(part) ? part.approval?.requestReason : void 0;
+  const element = usePart("p", props, { defaults: { children: reason } });
+  return reason ? element : null;
+}
+export {
+  ApprovalReason
+};

package/dist/headless/approval-receipt.d.ts

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

package/dist/headless/approval-receipt.js

@@ -0,0 +1,13 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+function ApprovalReceipt(props) {
+  const part = useRequired(PartScope, "Chat.ApprovalReceipt requires Chat.Parts.");
+  const approved = isToolUIPart(part) ? part.approval?.approved : void 0;
+  const element = usePart("p", props, { state: { approved: approved === true } });
+  return typeof approved === "boolean" ? element : null;
+}
+export {
+  ApprovalReceipt
+};

package/dist/headless/approve.d.ts

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

package/dist/headless/approve.js

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

package/dist/headless/branch-navigation.d.ts

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

package/dist/headless/branch-navigation.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope } from "./contexts.js";
+function BranchNavigation({ children }) {
+  const branches = useRequired(BranchContext, "Chat.BranchNavigation requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.BranchNavigation requires Chat.Messages.");
+  return branches.page(message.id) ? children : null;
+}
+export {
+  BranchNavigation
+};

package/dist/headless/branch-next.d.ts

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

package/dist/headless/branch-next.js

@@ -0,0 +1,21 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope } from "./contexts.js";
+function BranchNext(props) {
+  const branches = useRequired(BranchContext, "Chat.BranchNext requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.BranchNext requires Chat.Messages.");
+  const page = branches.page(message.id);
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: branches.blocked || !page || page.index >= page.total },
+    behavior: {
+      onClick: () => {
+        if (page) branches.move(page.id, 1);
+      }
+    }
+  });
+  return page ? element : null;
+}
+export {
+  BranchNext
+};

package/dist/headless/branch-page.d.ts

@@ -0,0 +1,5 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function BranchPage(props: PartProps<"span", {
+    index: number;
+    total: number;
+}>): import("react").ReactNode;

package/dist/headless/branch-page.js

@@ -0,0 +1,13 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope } from "./contexts.js";
+function BranchPage(props) {
+  const branches = useRequired(BranchContext, "Chat.BranchPage requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.BranchPage requires Chat.Messages.");
+  const page = branches.page(message.id);
+  const element = usePart("span", props, { state: { index: page?.index ?? 0, total: page?.total ?? 0 } });
+  return page ? element : null;
+}
+export {
+  BranchPage
+};

package/dist/headless/branch-previous.d.ts

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

package/dist/headless/branch-previous.js

@@ -0,0 +1,21 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope } from "./contexts.js";
+function BranchPrevious(props) {
+  const branches = useRequired(BranchContext, "Chat.BranchPrevious requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.BranchPrevious requires Chat.Messages.");
+  const page = branches.page(message.id);
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: branches.blocked || !page || page.index <= 1 },
+    behavior: {
+      onClick: () => {
+        if (page) branches.move(page.id, -1);
+      }
+    }
+  });
+  return page ? element : null;
+}
+export {
+  BranchPrevious
+};

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

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

package/dist/headless/cancel-edit.js

@@ -0,0 +1,10 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { SentDraftContext } from "./contexts.js";
+function CancelEdit(props) {
+  const draft = useRequired(SentDraftContext, "Chat.CancelEdit requires Chat.MessageEditRoot.");
+  return usePart("button", props, { defaults: { type: "button" }, behavior: { onClick: draft.cancel } });
+}
+export {
+  CancelEdit
+};

package/dist/headless/cancel-queue-edit.d.ts

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

package/dist/headless/cancel-queue-edit.js

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

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

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

package/dist/headless/cancel-queued.js

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

package/dist/headless/chat-dictation/confirm.d.ts

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

package/dist/headless/chat-dictation/confirm.js

@@ -0,0 +1,14 @@
+"use client";
+import { DictationContext } from "@slices.sh/transcription/headless/contexts";
+import { usePart, useRequired } from "@slices.sh/core/part";
+function Confirm(props) {
+  const dictation = useRequired(DictationContext, "ChatDictation.Confirm requires ChatDictation.Root.");
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: dictation.state.state !== "listening" },
+    behavior: { onClick: dictation.control.stop }
+  });
+}
+export {
+  Confirm
+};

package/dist/headless/chat-dictation/index.d.ts

@@ -0,0 +1,12 @@
+import { Root } from "./root";
+import { Input } from "./input";
+import { Voice } from "./voice";
+import { Text } from "./text";
+import { Confirm } from "./confirm";
+export declare const ChatDictation: {
+    Root: typeof Root;
+    Input: typeof Input;
+    Voice: typeof Voice;
+    Text: typeof Text;
+    Confirm: typeof Confirm;
+};

package/dist/headless/chat-dictation/index.js

@@ -0,0 +1,9 @@
+import { Root } from "./root.js";
+import { Input } from "./input.js";
+import { Voice } from "./voice.js";
+import { Text } from "./text.js";
+import { Confirm } from "./confirm.js";
+const ChatDictation = { Root, Input, Voice, Text, Confirm };
+export {
+  ChatDictation
+};

package/dist/headless/chat-dictation/input.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Dictation.Field remains the sole owner of editing and caret restoration. */
+export declare function Input(props: PartProps<"textarea">): 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/chat-dictation/input.js

@@ -0,0 +1,42 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement, useRef, useLayoutEffect } from "react";
+import { Dictation } from "@slices.sh/transcription/headless";
+import { DictationContext, FieldContext } from "@slices.sh/transcription/headless/contexts";
+import { ComposerContext } from "../contexts.js";
+import { usePart, useRequired } from "@slices.sh/core/part";
+function Input(props) {
+  const composer = useRequired(ComposerContext, "ChatDictation.Input requires ChatDictation.Root.");
+  const dictation = useRequired(DictationContext, "ChatDictation.Input requires ChatDictation.Root.");
+  const field = useRequired(FieldContext, "ChatDictation.Input requires ChatDictation.Root.");
+  const node = useRef(null);
+  const before = useRef(null);
+  const wasActive = useRef(false);
+  const active = ["asking", "listening", "finalizing"].includes(dictation.state.state);
+  useLayoutEffect(() => {
+    if (wasActive.current && !active && node.current) {
+      node.current.focus();
+      const caret = field.at?.end ?? before.current ?? node.current.value.length;
+      node.current.setSelectionRange(caret, caret);
+    }
+    wasActive.current = active;
+  }, [active, field.at]);
+  const element = usePart(
+    "textarea",
+    { ...props, ref: node },
+    {
+      defaults: { autoComplete: "off", enterKeyHint: "send" },
+      behavior: {
+        onKeyDown: composer.keyDown,
+        onBlur(event) {
+          before.current = event.currentTarget.selectionStart;
+        }
+      },
+      locked: { disabled: composer.disabled }
+    }
+  );
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Dictation.Field, { render: element }) : element;
+}
+export {
+  Input
+};

package/dist/headless/chat-dictation/root.d.ts

@@ -0,0 +1,3 @@
+import { type RootProps } from "@slices.sh/core/part";
+/** The existing dictation engine writes into the same draft as the native chat composer. */
+export declare function Root({ children }: RootProps): import("react").JSX.Element;

package/dist/headless/chat-dictation/root.js

@@ -0,0 +1,42 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Dictation } from "@slices.sh/transcription/headless";
+import { DictationContext, FieldContext } from "@slices.sh/transcription/headless/contexts";
+import { ComposerContext } from "../contexts.js";
+import { Provide, useRequired } from "@slices.sh/core/part";
+function Root({ children }) {
+  const composer = useRequired(ComposerContext, "ChatDictation.Root requires Chat.Root.");
+  return /* @__PURE__ */ jsx(Dictation.Root, { value: composer.draft, onChange: composer.set, children: /* @__PURE__ */ jsx(Bridge, { children }) });
+}
+function Bridge({ children }) {
+  const base = useRequired(ComposerContext, "ChatDictation requires Chat.Root.");
+  const dictation = useRequired(DictationContext, "ChatDictation requires Dictation.Root.");
+  const field = useRequired(FieldContext, "ChatDictation requires Dictation.Root.");
+  const busy = ["asking", "listening", "finalizing"].includes(dictation.state.state);
+  const composer = useMemo(
+    () => ({
+      draft: base.draft,
+      set: field.change,
+      disabled: base.disabled || busy,
+      submit(text) {
+        if (!busy) base.submit(text);
+      },
+      keyDown(event) {
+        if (busy) {
+          if (event.key === "Escape") {
+            event.preventDefault();
+            dictation.control.abort();
+          }
+          return;
+        }
+        base.keyDown(event);
+      }
+    }),
+    [base, field.change, busy, dictation.control]
+  );
+  return /* @__PURE__ */ jsx(Provide, { values: [[ComposerContext, composer]], children });
+}
+export {
+  Root
+};

package/dist/headless/chat-dictation/text.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Keep the actual field mounted so its caret owner survives the voice surface. */
+export declare function Text(props: PartProps<"div">): import("react").ReactNode;

package/dist/headless/chat-dictation/text.js

@@ -0,0 +1,14 @@
+"use client";
+import { DictationContext } from "@slices.sh/transcription/headless/contexts";
+import { usePart, useRequired } from "@slices.sh/core/part";
+function Text(props) {
+  const dictation = useRequired(DictationContext, "ChatDictation.Text requires ChatDictation.Root.");
+  const active = ["asking", "listening", "finalizing"].includes(dictation.state.state);
+  return usePart("div", props, {
+    attributes: { active },
+    locked: { inert: active, "aria-hidden": active }
+  });
+}
+export {
+  Text
+};

package/dist/headless/chat-dictation/voice.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Keep AnimatePresence mounted across the recording-to-text transition. */
+export declare function Voice(props: PartProps<"div">): import("react").JSX.Element | null;

package/dist/headless/chat-dictation/voice.js

@@ -0,0 +1,35 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement, useRef, useLayoutEffect } from "react";
+import { DictationContext } from "@slices.sh/transcription/headless/contexts";
+import { Presence } from "@slices.sh/core/motion";
+import { usePart, useRequired } from "@slices.sh/core/part";
+function Voice(props) {
+  const dictation = useRequired(DictationContext, "ChatDictation.Voice requires ChatDictation.Root.");
+  const active = ["asking", "listening", "finalizing"].includes(dictation.state.state);
+  const node = useRef(null);
+  const phase = dictation.state.state;
+  useLayoutEffect(() => {
+    if (phase === "listening")
+      node.current?.querySelector("button:not(:disabled)")?.focus();
+  }, [phase]);
+  const element = usePart(
+    "div",
+    { ...props, ref: node },
+    {
+      locked: { inert: !active, "aria-hidden": !active },
+      behavior: {
+        onKeyDown(event) {
+          if (event.key === "Escape" && dictation.state.state !== "asking") {
+            event.preventDefault();
+            dictation.control.abort();
+          }
+        }
+      }
+    }
+  );
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Presence, { present: active, children: element }) : null;
+}
+export {
+  Voice
+};

package/dist/headless/citation-content.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** The skin's surface preserves the corresponding Motion primitive adapter. */
+export declare function CitationContent(props: PartProps<"div">): import("react").ReactNode;

package/dist/headless/citation-content.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { MotionPopover } from "./source-primitives.js";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { CitationDisclosureContext } from "./source-context.js";
+function CitationContent(props) {
+  const disclosure = useRequired(
+    CitationDisclosureContext,
+    "Chat.CitationContent requires Chat.CitationRoot."
+  );
+  return usePart(
+    "div",
+    { ...props, render: props.render ?? /* @__PURE__ */ jsx(MotionPopover, {}) },
+    { locked: { open: disclosure.open } }
+  );
+}
+export {
+  CitationContent
+};

package/dist/headless/citation-description.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function CitationDescription(props: PartProps<"p">): 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/citation-description.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Popover } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function CitationDescription(props) {
+  const element = usePart("p", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Popover.Description, { render: element }) : element;
+}
+export {
+  CitationDescription
+};

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

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

package/dist/headless/citation-root.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Popover } from "./source-primitives.js";
+import { useSourceDisclosure } from "../hooks/use-source-disclosure.js";
+import { Provide } from "@slices.sh/core/part";
+import { CitationDisclosureContext } from "./source-context.js";
+function CitationRoot({ children }) {
+  const disclosure = useSourceDisclosure();
+  return /* @__PURE__ */ jsx(Popover.Root, { open: disclosure.open, onOpenChange: disclosure.setOpen, children: /* @__PURE__ */ jsx(Provide, { values: [[CitationDisclosureContext, disclosure]], children }) });
+}
+export {
+  CitationRoot
+};

package/dist/headless/citation-title.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function CitationTitle(props: PartProps<"h2">): 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/citation-title.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Popover } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function CitationTitle(props) {
+  const element = usePart("h2", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Popover.Title, { render: element }) : element;
+}
+export {
+  CitationTitle
+};

package/dist/headless/citation-trigger.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function CitationTrigger(props: PartProps<"button">): 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/citation-trigger.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Popover } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function CitationTrigger(props) {
+  const element = usePart("button", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Popover.Trigger, { render: element }) : element;
+}
+export {
+  CitationTrigger
+};

package/dist/headless/clear-answer.d.ts

@@ -0,0 +1,5 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Takes a pick back, which a radio cannot do by itself. An optional question only: a required one is changed, not emptied. */
+export declare function ClearAnswer({ name, ...props }: PartProps<"button"> & {
+    name: string;
+}): import("react").ReactNode;