@godxjp/chat 32.0.0 → 32.0.1

package/dist/attachments.d.ts

@@ -0,0 +1,24 @@
+import { A as AttachmentsOverflowProp, a as AttachmentsSemanticProp, c as ClassNameProp } from './data-entry.prop-D4jLTqUk.js';
+import * as _godxjp_ui_data_entry from '@godxjp/ui/data-entry';
+import * as React from 'react';
+import { AttachmentsItemProp, AttachmentsPlaceholderProp, AttachmentsRefProp } from '@godxjp/ui/props/components';
+export { AttachmentsItemProp, AttachmentsOverflowProp, AttachmentsPlaceholderProp, AttachmentsProp, AttachmentsProp as AttachmentsProps, AttachmentsRefProp } from '@godxjp/ui/props/components';
+
+declare const Attachments: React.ForwardRefExoticComponent<Omit<_godxjp_ui_data_entry.UploadProps, "value" | "defaultValue" | "onValueChange" | "variant" | "showUploadList" | "children" | "onRemove"> & {
+    items?: readonly AttachmentsItemProp[];
+    onChange?: (info: {
+        file: AttachmentsItemProp;
+        fileList: AttachmentsItemProp[];
+    }) => void;
+    onRemove?: (item: AttachmentsItemProp) => boolean | void | Promise<boolean | void>;
+    overflow?: AttachmentsOverflowProp;
+    placeholder?: AttachmentsPlaceholderProp | ((type: "inline" | "drop") => AttachmentsPlaceholderProp);
+    getDropContainer?: (() => HTMLElement | null | undefined) | null;
+    classNames?: Partial<Record<AttachmentsSemanticProp, string>>;
+    styles?: Partial<Record<AttachmentsSemanticProp, React.CSSProperties>>;
+    rootClassName?: ClassNameProp;
+    children?: React.ReactElement;
+    imageProps?: Record<string, unknown>;
+} & React.RefAttributes<AttachmentsRefProp>>;
+
+export { Attachments };

package/dist/attachments.js

@@ -0,0 +1,8 @@
+"use client";
+"use client";
+import {
+  Attachments
+} from "./chunk-PGCRFJHC.js";
+export {
+  Attachments
+};

package/dist/chat-bubble.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { ChatBubbleProp, ChatBubbleListProp } from '@godxjp/ui/props/components';
+export { ChatBubbleListProp, ChatBubblePlacementProp, ChatBubbleProp, ChatBubbleToneProp, ChatBubbleTypingProp, ChatBubbleVariantProp, ChatMessageProp } from '@godxjp/ui/props/components';
+
+type ChatBubbleProps = ChatBubbleProp & Omit<React.HTMLAttributes<HTMLElement>, keyof ChatBubbleProp>;
+/**
+ * ChatBubble — ONE message in a conversation: an optional author mark, a header naming the turn,
+ * the message body, and a footer for timestamps or per-message actions.
+ *
+ * It is an `<article>` inside the feed's `role="log"`, and it deliberately owns NO live region of
+ * its own: one live region per bubble floods a screen reader on every token of a stream. The feed
+ * (`ChatBubbleList`) owns the single `aria-live="polite"` region; a bubble only ever says "I am
+ * still being produced" through `aria-busy`.
+ */
+declare const ChatBubble: React.ForwardRefExoticComponent<ChatBubbleProp & Omit<React.HTMLAttributes<HTMLElement>, keyof ChatBubbleProp> & React.RefAttributes<HTMLElement>>;
+type ChatBubbleListProps = ChatBubbleListProp & Omit<React.HTMLAttributes<HTMLDivElement>, keyof ChatBubbleListProp>;
+/**
+ * ChatBubbleList — the message feed.
+ *
+ * The behaviour that earns this a component rather than a `ScrollArea` + `map` is STICK-TO-BOTTOM:
+ * new messages keep the viewport pinned only while the reader is ALREADY at the bottom. The moment
+ * they scroll up to re-read something the pin is revoked and stays revoked until they ask for it
+ * back — silently yanking a reader to the newest message mid-sentence is a change of context they
+ * did not request (WCAG 3.2.5), and it is the classic chat-UI defect. The way back is a real,
+ * focusable button that also says how many messages arrived while they were away.
+ *
+ * GIVE IT A DEFINITE HEIGHT — `className="h-96"`, or a flex/grid parent that hands it a track.
+ * The feed scrolls INSIDE itself; with no height it simply grows to its content, nothing ever
+ * overflows, and every behaviour above has nothing to act on.
+ */
+declare const ChatBubbleList: React.ForwardRefExoticComponent<ChatBubbleListProp & Omit<React.HTMLAttributes<HTMLDivElement>, keyof ChatBubbleListProp> & React.RefAttributes<HTMLDivElement>>;
+
+export { ChatBubble, ChatBubbleList, type ChatBubbleListProps, type ChatBubbleProps };

package/dist/chat-bubble.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  ChatBubble,
+  ChatBubbleList
+} from "./chunk-XCTRKZCF.js";
+export {
+  ChatBubble,
+  ChatBubbleList
+};

package/dist/chat-composer.d.ts

@@ -0,0 +1,71 @@
+import { V as ValueProp, D as DefaultValueProp, O as OnValueChangeProp, P as PendingProp, b as ChatComposerSubmitTypeProp, f as PlaceholderProp, e as DisabledProp, C as ChatComposerFooterProp, S as SizeProp, d as ControlStatusProp, N as NameProp, I as IdProp, c as ClassNameProp } from './data-entry.prop-D4jLTqUk.js';
+import * as React from 'react';
+export { ChatComposerActionComponents, ChatComposerFooterProp, ChatComposerProp, ChatComposerProp as ChatComposerProps, ChatComposerSubmitTypeProp } from '@godxjp/ui/props/components';
+
+/**
+ * The accessible-name / description / validation contract that {@link FormField} injects onto its
+ * single control child (via `cloneElement`). EVERY form-capable `@godxjp/ui` component accepts
+ * these props and forwards them to its **semantic focus target** — the real `<input>` / combobox /
+ * trigger the user tabs to, never a presentational wrapper `<div>`.
+ */
+interface FieldA11yProps {
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-errormessage"?: string;
+    "aria-invalid"?: React.AriaAttributes["aria-invalid"];
+    "aria-required"?: React.AriaAttributes["aria-required"];
+    "data-field"?: string;
+}
+
+/**
+ * ChatComposer — the message input of a conversation (Ant Design X `Sender`).
+ *
+ * ## Why a component and not a composition
+ *
+ * Three behaviours live here and nowhere else, and every app that hand-rolls a composer gets at
+ * least one of them wrong:
+ *
+ * 1. **An IME conversion is not a message.** Between `compositionstart` and `compositionend` the
+ *    text in the box is a CANDIDATE being converted, and the `Enter` that accepts it belongs to
+ *    the IME. A composer that reads that `Enter` as "send" makes Japanese and Vietnamese input
+ *    impossible — the first kanji conversion sends a half-written line. The guard is a ref, not
+ *    state, because it has to be readable inside the keydown that fires between the two events.
+ * 2. **One trailing action at a time.** While a response streams the send button IS the cancel
+ *    button — the same discipline as the picker trailing-action rule. Rendering both is how a
+ *    user cancels by aiming for send.
+ * 3. **The draft box is the focus target.** `ref`, `id`, `name` and the whole `FormField`
+ *    label/helper/error contract land on the `<textarea>`, not on the frame, so a composer inside
+ *    a `FormField` is labelled and described exactly like an `Input`.
+ *
+ * Everything visible is a real primitive: the draft box is `Textarea` (`variant="borderless"`, so
+ * the frame is the only boundary) and every action is a `Button`.
+ */
+declare const ChatComposer: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "prefix" | "onChange" | "onSubmit" | "onKeyDown"> & FieldA11yProps & {
+    value?: ValueProp<string>;
+    defaultValue?: DefaultValueProp<string>;
+    onValueChange?: OnValueChangeProp<string>;
+    onSubmit?: (value: string) => void;
+    onCancel?: () => void;
+    loading?: PendingProp;
+    submitType?: ChatComposerSubmitTypeProp;
+    allowEmptySubmit?: boolean;
+    placeholder?: PlaceholderProp;
+    disabled?: DisabledProp;
+    readOnly?: boolean;
+    header?: React.ReactNode;
+    prefix?: React.ReactNode;
+    footer?: ChatComposerFooterProp;
+    actions?: React.ReactNode | false;
+    size?: SizeProp;
+    maxLength?: number;
+    status?: ControlStatusProp;
+    submitLabel?: string;
+    cancelLabel?: string;
+    onKeyDown?: React.KeyboardEventHandler<HTMLTextAreaElement>;
+    name?: NameProp;
+    id?: IdProp;
+    className?: ClassNameProp;
+} & React.RefAttributes<HTMLTextAreaElement>>;
+
+export { ChatComposer };

package/dist/chat-composer.js

@@ -0,0 +1,7 @@
+"use client";
+import {
+  ChatComposer
+} from "./chunk-4K5JWTV5.js";
+export {
+  ChatComposer
+};

package/dist/chat-suggestion.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { ChatSuggestionProp } from '@godxjp/ui/props/components';
+export { ChatSuggestionItemProp, ChatSuggestionProp, ChatSuggestionProp as ChatSuggestionProps, ChatSuggestionRenderProp } from '@godxjp/ui/props/components';
+
+/**
+ * ChatSuggestion — trigger-character autocomplete over a `ChatComposer` (Ant Design X
+ * `Suggestion`).
+ *
+ * ## What it owns, and what it deliberately does not
+ *
+ * The list is the existing `Command` (cmdk) inside a `Popover`: the listbox/option roles, the
+ * active-row bookkeeping and the scroll-into-view all come from a primitive that already ships
+ * them, so there is no hand-rolled listbox here. What this component owns is the part `Command`
+ * cannot know about — a `<textarea>` it does not render:
+ *
+ * - **Detecting the trigger at the CARET**, not merely anywhere in the text, so a `/` in the
+ *   middle of a URL opens nothing and a caret moved out of a token closes the list.
+ * - **Driving the list from a box that keeps focus.** Focus never leaves the textarea (the popover
+ *   is opened with `onOpenAutoFocus` prevented), so arrows/Enter are forwarded through the render
+ *   prop and the active row is announced through `aria-activedescendant` — the APG combobox
+ *   pattern, rather than moving focus into the panel and stranding the draft.
+ * - **`Escape` costs nothing.** It closes the list, returns focus to the textarea and leaves the
+ *   typed text exactly as it was; a suggestion list that eats the draft on dismiss is the defect
+ *   this guards.
+ */
+declare function ChatSuggestion({ items, onValueChange, triggerCharacter, open, defaultOpen, onOpenChange, children, emptyMessage, listLabel: listLabelProp, id, className, allowSpaces, terminator, shouldFilter, onQueryChange, }: ChatSuggestionProp): React.JSX.Element;
+declare namespace ChatSuggestion {
+    var displayName: string;
+}
+
+export { ChatSuggestion };

package/dist/chat-suggestion.js

@@ -0,0 +1,7 @@
+"use client";
+import {
+  ChatSuggestion
+} from "./chunk-DEYHFJBA.js";
+export {
+  ChatSuggestion
+};

package/dist/chunk-4K5JWTV5.js

@@ -0,0 +1,203 @@
+"use client";
+
+// src/chat-composer.tsx
+import * as React from "react";
+import { SendHorizontal, Square } from "lucide-react";
+import { useTranslation } from "@godxjp/ui/i18n";
+import { cn } from "@godxjp/ui/lib/utils";
+import { isApplePlatform } from "@godxjp/ui/lib/utils";
+import { omitFieldA11y, pickFieldA11y, useFieldIdentity } from "@godxjp/ui/data-entry";
+import { Button } from "@godxjp/ui/general";
+import { Textarea } from "@godxjp/ui/data-entry";
+import { controlSurfaceAttrs, resolveAriaInvalid } from "@godxjp/ui/data-entry";
+import { isImeComposing } from "@godxjp/ui/data-entry";
+import { jsx, jsxs } from "react/jsx-runtime";
+function isSendable(text) {
+  return text.trim().length > 0;
+}
+var ChatComposer = React.forwardRef(
+  ({
+    className,
+    id,
+    name,
+    value,
+    defaultValue,
+    onValueChange,
+    onSubmit,
+    onCancel,
+    loading = false,
+    submitType = "enter",
+    allowEmptySubmit = false,
+    placeholder,
+    disabled = false,
+    readOnly = false,
+    header,
+    prefix,
+    footer,
+    actions,
+    size,
+    maxLength,
+    status,
+    submitLabel,
+    cancelLabel,
+    onKeyDown,
+    ...props
+  }, ref) => {
+    const { t } = useTranslation();
+    const innerRef = React.useRef(null);
+    const setRefs = React.useCallback(
+      (node) => {
+        innerRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      [ref]
+    );
+    const [draft, setDraft] = React.useState(() => String(value ?? defaultValue ?? ""));
+    React.useEffect(() => {
+      if (value !== void 0) setDraft(String(value));
+    }, [value]);
+    const composing = React.useRef(false);
+    const fieldA11y = pickFieldA11y(props);
+    const rest = omitFieldA11y(props);
+    const identity = useFieldIdentity({ id, name, "data-field": props["data-field"] });
+    const surface = controlSurfaceAttrs({ status, size });
+    const canSubmit = (allowEmptySubmit || isSendable(draft)) && !disabled && !readOnly && !loading;
+    const submit = React.useCallback(() => {
+      if (disabled || readOnly || loading) return;
+      const text = innerRef.current?.value ?? draft;
+      if (isSendable(text)) onSubmit?.(text);
+      else if (allowEmptySubmit) onSubmit?.("");
+    }, [draft, disabled, readOnly, loading, allowEmptySubmit, onSubmit]);
+    const handleKeyDown = (event) => {
+      onKeyDown?.(event);
+      if (event.defaultPrevented) return;
+      if (event.key !== "Enter") return;
+      if (composing.current || isImeComposing(event)) return;
+      const wantsSend = submitType === "modEnter" ? (
+        // ⌘ on Apple platforms, Ctrl everywhere else — the other one is left alone, because
+        // Ctrl+Enter on a Mac is not the convention a Mac user reaches for.
+        isApplePlatform() ? event.metaKey : event.ctrlKey
+      ) : submitType === "enter" ? !event.shiftKey : event.shiftKey;
+      if (!wantsSend) return;
+      event.preventDefault();
+      submit();
+    };
+    const sendName = submitLabel ?? t("dataEntry.chatComposer.send");
+    const cancelName = cancelLabel ?? t("dataEntry.chatComposer.cancel");
+    const actionSize = size === "xs" ? "icon-xs" : size === "sm" ? "icon-sm" : size === "lg" ? "icon-lg" : "icon";
+    const liveRef = React.useRef({
+      actionSize,
+      sendName,
+      cancelName,
+      submit,
+      onCancel,
+      canSubmit,
+      disabled
+    });
+    liveRef.current = { actionSize, sendName, cancelName, submit, onCancel, canSubmit, disabled };
+    const SubmitButton = React.useMemo(
+      () => function SubmitButton2(buttonProps) {
+        const live = liveRef.current;
+        return /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: live.actionSize,
+            "aria-label": live.sendName,
+            onClick: live.submit,
+            disabled: !live.canSubmit,
+            ...buttonProps,
+            children: buttonProps.children ?? /* @__PURE__ */ jsx(SendHorizontal, { "aria-hidden": "true" })
+          }
+        );
+      },
+      []
+    );
+    const CancelButton = React.useMemo(
+      () => function CancelButton2(buttonProps) {
+        const live = liveRef.current;
+        return /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: live.actionSize,
+            variant: "secondary",
+            "aria-label": live.cancelName,
+            onClick: live.onCancel,
+            disabled: live.disabled,
+            ...buttonProps,
+            children: buttonProps.children ?? /* @__PURE__ */ jsx(Square, { "aria-hidden": "true" })
+          }
+        );
+      },
+      []
+    );
+    const actionComponents = React.useMemo(
+      () => ({ SubmitButton, CancelButton }),
+      [SubmitButton, CancelButton]
+    );
+    const footerContent = typeof footer === "function" ? footer({ components: actionComponents }) : footer;
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        "data-slot": "chat-composer",
+        "data-disabled": disabled ? "" : void 0,
+        "data-loading": loading ? "" : void 0,
+        "data-submit-type": submitType,
+        "aria-busy": loading || void 0,
+        className: cn("ui-chat-composer ui-control-surface", className),
+        ...rest,
+        ...surface,
+        children: [
+          header ? /* @__PURE__ */ jsx("div", { "data-slot": "chat-composer-header", className: "ui-chat-composer-header", children: header }) : null,
+          /* @__PURE__ */ jsxs("div", { "data-slot": "chat-composer-row", className: "ui-chat-composer-row", children: [
+            prefix ? /* @__PURE__ */ jsx("div", { "data-slot": "chat-composer-prefix", className: "ui-chat-composer-prefix", children: prefix }) : null,
+            /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                ref: setRefs,
+                id,
+                name,
+                variant: "borderless",
+                autoGrow: true,
+                className: "ui-chat-composer-field",
+                value,
+                defaultValue,
+                placeholder: placeholder ?? t("dataEntry.chatComposer.placeholder"),
+                disabled,
+                readOnly,
+                maxLength,
+                status,
+                "aria-invalid": resolveAriaInvalid(fieldA11y["aria-invalid"], status),
+                onValueChange: (next) => {
+                  if (value === void 0) setDraft(next);
+                  onValueChange?.(next);
+                },
+                onKeyDown: handleKeyDown,
+                onCompositionStart: () => {
+                  composing.current = true;
+                },
+                onCompositionEnd: () => {
+                  composing.current = false;
+                },
+                ...fieldA11y,
+                ...identity
+              }
+            ),
+            actions === false ? null : /* @__PURE__ */ jsxs("div", { "data-slot": "chat-composer-actions", className: "ui-chat-composer-actions", children: [
+              actions,
+              loading ? /* @__PURE__ */ jsx(CancelButton, {}) : /* @__PURE__ */ jsx(SubmitButton, {})
+            ] })
+          ] }),
+          footerContent ? /* @__PURE__ */ jsx("div", { "data-slot": "chat-composer-footer", className: "ui-chat-composer-footer", children: footerContent }) : null
+        ]
+      }
+    );
+  }
+);
+ChatComposer.displayName = "ChatComposer";
+
+export {
+  ChatComposer
+};

package/dist/chunk-52TWSF6W.js

@@ -0,0 +1,180 @@
+"use client";
+
+// src/thought-chain.tsx
+import * as React from "react";
+import { ChevronRight, CircleCheck, CircleMinus, CircleX, Loader2 } from "lucide-react";
+import { useTranslation } from "@godxjp/ui/i18n";
+import { cn } from "@godxjp/ui/lib/utils";
+import { VisuallyHidden } from "@godxjp/ui/general";
+import { Text } from "@godxjp/ui/general";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var STATUS_GLYPH = {
+  loading: /* @__PURE__ */ jsx(Loader2, { "aria-hidden": "true", className: "ui-thought-chain-spinner" }),
+  success: /* @__PURE__ */ jsx(CircleCheck, { "aria-hidden": "true" }),
+  error: /* @__PURE__ */ jsx(CircleX, { "aria-hidden": "true" }),
+  abort: /* @__PURE__ */ jsx(CircleMinus, { "aria-hidden": "true" })
+};
+function StatusMark({
+  status,
+  fallback
+}) {
+  const { t } = useTranslation();
+  if (!status) return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    STATUS_GLYPH[status],
+    /* @__PURE__ */ jsx(VisuallyHidden, { children: t(`dataDisplay.thoughtChain.status.${status}`) })
+  ] });
+}
+var ThoughtChain = React.forwardRef(
+  ({
+    items = [],
+    defaultExpandedKeys,
+    expandedKeys,
+    onExpand,
+    line = true,
+    label,
+    id,
+    className,
+    ...rest
+  }, ref) => {
+    const { t } = useTranslation();
+    const reactId = React.useId();
+    const [uncontrolled, setUncontrolled] = React.useState(() => [
+      ...defaultExpandedKeys ?? []
+    ]);
+    const open = expandedKeys ? [...expandedKeys] : uncontrolled;
+    const toggle = (key) => {
+      const next = open.includes(key) ? open.filter((k) => k !== key) : [...open, key];
+      if (!expandedKeys) setUncontrolled(next);
+      onExpand?.(next);
+    };
+    return /* @__PURE__ */ jsx(
+      "ol",
+      {
+        ref,
+        id,
+        "aria-label": label ?? t("dataDisplay.thoughtChain.label"),
+        "data-slot": "thought-chain",
+        "data-line": line === false ? "none" : line === true ? "solid" : line,
+        className: cn("ui-thought-chain", className),
+        ...rest,
+        children: items.map((item, index) => {
+          const key = item.key ?? `${reactId}-${index}`;
+          const bodyId = `${reactId}-body-${index}`;
+          const collapsible = Boolean(item.collapsible && item.content);
+          const expanded = collapsible ? open.includes(key) : true;
+          const glyph = item.icon === false ? null : item.icon ?? index + 1;
+          return /* @__PURE__ */ jsxs(
+            "li",
+            {
+              "data-slot": "thought-chain-node",
+              "data-status": item.status,
+              className: "ui-thought-chain-node",
+              children: [
+                glyph === null ? null : /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    "data-slot": "thought-chain-icon",
+                    "data-status": item.status,
+                    className: "ui-thought-chain-icon",
+                    children: /* @__PURE__ */ jsx(StatusMark, { status: item.status, fallback: glyph })
+                  }
+                ),
+                /* @__PURE__ */ jsxs("div", { className: "ui-thought-chain-body", children: [
+                  /* @__PURE__ */ jsxs("div", { className: "ui-thought-chain-header", children: [
+                    collapsible ? /* @__PURE__ */ jsxs(
+                      "button",
+                      {
+                        type: "button",
+                        "aria-expanded": expanded,
+                        "aria-controls": bodyId,
+                        "data-blink": item.blink ? "" : void 0,
+                        className: "ui-thought-chain-trigger",
+                        onClick: () => toggle(key),
+                        children: [
+                          /* @__PURE__ */ jsx(
+                            ChevronRight,
+                            {
+                              "aria-hidden": "true",
+                              "data-expanded": expanded ? "true" : void 0,
+                              className: "ui-thought-chain-chevron"
+                            }
+                          ),
+                          /* @__PURE__ */ jsx(Text, { weight: "medium", children: item.title })
+                        ]
+                      }
+                    ) : /* @__PURE__ */ jsx(Text, { weight: "medium", "data-blink": item.blink ? "" : void 0, children: item.title }),
+                    item.description ? /* @__PURE__ */ jsx(Text, { size: "xs", tone: "muted", children: item.description }) : null
+                  ] }),
+                  item.content && (expanded || item.destroyOnHidden === false) ? /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      id: bodyId,
+                      hidden: !expanded,
+                      "data-blink": item.blink ? "" : void 0,
+                      className: "ui-thought-chain-content",
+                      children: item.content
+                    }
+                  ) : null,
+                  item.footer ? /* @__PURE__ */ jsx("div", { className: "ui-thought-chain-footer", children: item.footer }) : null
+                ] })
+              ]
+            },
+            key
+          );
+        })
+      }
+    );
+  }
+);
+ThoughtChain.displayName = "ThoughtChain";
+var ThoughtChainItem = React.forwardRef(
+  ({
+    title,
+    description,
+    icon,
+    status,
+    variant = "solid",
+    blink,
+    disabled,
+    onClick,
+    id,
+    className
+  }, ref) => {
+    const shared = {
+      id,
+      "data-slot": "thought-chain-item",
+      "data-variant": variant,
+      "data-status": status,
+      "data-blink": blink ? "" : void 0,
+      className: cn("ui-thought-chain-item", className)
+    };
+    const inner = /* @__PURE__ */ jsxs(Fragment, { children: [
+      status || icon ? /* @__PURE__ */ jsx("span", { "data-status": status, className: "ui-thought-chain-icon", children: /* @__PURE__ */ jsx(StatusMark, { status, fallback: icon }) }) : null,
+      /* @__PURE__ */ jsxs("span", { className: "ui-thought-chain-item-text", children: [
+        title ? /* @__PURE__ */ jsx(Text, { weight: "medium", children: title }) : null,
+        description ? /* @__PURE__ */ jsx(Text, { size: "xs", tone: "muted", children: description }) : null
+      ] })
+    ] });
+    if (!onClick) {
+      return /* @__PURE__ */ jsx("div", { ref, ...shared, children: inner });
+    }
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref,
+        type: "button",
+        disabled,
+        onClick,
+        ...shared,
+        children: inner
+      }
+    );
+  }
+);
+ThoughtChainItem.displayName = "ThoughtChainItem";
+
+export {
+  ThoughtChain,
+  ThoughtChainItem
+};