@intentface/chat 0.1.0

package/dist/internal/render/useRenderElement.js

@@ -0,0 +1,157 @@
+import { createElement as _createElement } from "react";
+// Vendored from @base-ui/react v1.6.0 (MIT) — packages/react/src/internals/useRenderElement.tsx
+// https://github.com/mui/base-ui — import specifiers rewired; one local departure:
+// the `props` config accepts bespoke data-* part attributes (WithDataAttributes).
+import * as React from 'react';
+import { useMergedRefs, useMergedRefsN } from './useMergedRefs';
+import { getReactElementRef } from './getReactElementRef';
+import { mergeObjects } from './mergeObjects';
+import { warn } from './warn';
+import { EMPTY_OBJECT } from './empty';
+import { getStateAttributesProps } from './getStateAttributesProps';
+import { resolveClassName } from './resolveClassName';
+import { resolveStyle } from './resolveStyle';
+import { mergeProps, mergePropsN, mergeClassNames } from './mergeProps';
+/**
+ * Renders a Base UI element.
+ *
+ * @param element The default HTML element to render. Can be overridden by the `render` prop.
+ * @param componentProps An object containing the `render` and `className` props to be used for element customization. Other props are ignored.
+ * @param params Additional parameters for rendering the element.
+ */
+export function useRenderElement(element, componentProps, params = {}) {
+    const renderProp = componentProps.render;
+    const outProps = useRenderElementProps(componentProps, params);
+    if (params.enabled === false) {
+        return null;
+    }
+    const state = params.state ?? EMPTY_OBJECT;
+    return evaluateRenderProp(element, renderProp, outProps, state);
+}
+/**
+ * Computes render element final props.
+ */
+function useRenderElementProps(componentProps, params = {}) {
+    const { className: classNameProp, style: styleProp, render: renderProp } = componentProps;
+    const { state = EMPTY_OBJECT, ref, props, stateAttributesMapping, enabled = true, } = params;
+    const className = enabled ? resolveClassName(classNameProp, state) : undefined;
+    const style = enabled ? resolveStyle(styleProp, state) : undefined;
+    const stateProps = enabled
+        ? getStateAttributesProps(state, stateAttributesMapping)
+        : EMPTY_OBJECT;
+    const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : undefined;
+    // Ensure outProps is always a new mutable object when enabled, never EMPTY_OBJECT.
+    // This prevents potential TypeError when setting ref, className, or style properties,
+    // since EMPTY_OBJECT is frozen and mutations would fail in strict mode.
+    const outProps = enabled
+        ? (mergeObjects(stateProps, resolvedProps) ?? {})
+        : EMPTY_OBJECT;
+    // SAFETY: The `useMergedRefs` functions use a single hook to store the same value,
+    // switching between them at runtime is safe. If this assertion fails, React will
+    // throw at runtime anyway.
+    // This also skips the `useMergedRefs` call on the server, which is fine because
+    // refs are not used on the server side.
+    /* eslint-disable react-hooks/rules-of-hooks */
+    if (typeof document !== 'undefined') {
+        if (!enabled) {
+            useMergedRefs(null, null);
+        }
+        else if (Array.isArray(ref)) {
+            outProps.ref = useMergedRefsN([outProps.ref, getReactElementRef(renderProp), ...ref]);
+        }
+        else {
+            outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
+        }
+    }
+    if (!enabled) {
+        return EMPTY_OBJECT;
+    }
+    if (className !== undefined) {
+        outProps.className = mergeClassNames(outProps.className, className);
+    }
+    if (style !== undefined) {
+        outProps.style = mergeObjects(outProps.style, style);
+    }
+    return outProps;
+}
+function resolveRenderFunctionProps(props) {
+    if (Array.isArray(props)) {
+        return mergePropsN(props);
+    }
+    return mergeProps(undefined, props);
+}
+// The symbol React uses internally for lazy components
+// https://github.com/facebook/react/blob/a0566250b210499b4c5677f5ac2eedbd71d51a1b/packages/shared/ReactSymbols.js#L31
+//
+// TODO delete once https://github.com/facebook/react/issues/32392 is fixed
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/;
+const LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
+function evaluateRenderProp(element, render, props, state) {
+    if (render) {
+        if (typeof render === 'function') {
+            if (process.env.NODE_ENV !== 'production') {
+                warnIfRenderPropLooksLikeComponent(render);
+            }
+            return render(props, state);
+        }
+        const mergedProps = mergeProps(props, render.props);
+        mergedProps.ref = props.ref;
+        let newElement = render;
+        // Workaround for https://github.com/facebook/react/issues/32392
+        // This works because the toArray() logic unwrap lazy element type in
+        // https://github.com/facebook/react/blob/a0566250b210499b4c5677f5ac2eedbd71d51a1b/packages/react/src/ReactChildren.js#L186
+        if (newElement?.$$typeof === REACT_LAZY_TYPE) {
+            const children = React.Children.toArray(render);
+            newElement = children[0];
+        }
+        // There is a high number of indirections, the error message thrown by React.cloneElement() is
+        // hard to use for developers, this logic provides a better context.
+        //
+        // Our general guideline is to never change the control flow depending on the environment.
+        // However, React.cloneElement() throws if React.isValidElement() is false,
+        // so we can throw before with custom message.
+        if (process.env.NODE_ENV !== 'production') {
+            if (!React.isValidElement(newElement)) {
+                // TODO: fix mui/no-guarded-throw
+                // eslint-disable-next-line mui/no-guarded-throw
+                throw new Error([
+                    'Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.',
+                    'A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.',
+                    'https://base-ui.com/r/invalid-render-prop',
+                ].join('\n'));
+            }
+        }
+        return React.cloneElement(newElement, mergedProps);
+    }
+    if (element) {
+        if (typeof element === 'string') {
+            return renderTag(element, props);
+        }
+    }
+    // Unreachable, but the typings on `useRenderElement` need to be reworked
+    // to annotate it correctly.
+    throw new Error('Base UI: Render element or function are not defined.');
+}
+function warnIfRenderPropLooksLikeComponent(renderFn) {
+    const functionName = renderFn.name;
+    if (functionName.length === 0) {
+        return;
+    }
+    if (!COMPONENT_IDENTIFIER_PATTERN.test(functionName)) {
+        return;
+    }
+    if (!LOWERCASE_CHARACTER_PATTERN.test(functionName)) {
+        return;
+    }
+    warn(`The \`render\` prop received a function named \`${functionName}\` that starts with an uppercase letter.`, 'This usually means a React component was passed directly as `render={Component}`.', 'Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.', 'If this is an intentional render callback, rename it to start with a lowercase letter.', 'Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.', 'https://base-ui.com/r/invalid-render-prop');
+}
+function renderTag(Tag, props) {
+    if (Tag === 'button') {
+        return _createElement("button", { type: "button", ...props, key: props.key });
+    }
+    if (Tag === 'img') {
+        return _createElement("img", { alt: "", ...props, key: props.key });
+    }
+    return React.createElement(Tag, props);
+}

package/dist/internal/render/warn.d.ts

@@ -0,0 +1 @@
+export declare function warn(...messages: string[]): void;

package/dist/internal/render/warn.js

@@ -0,0 +1,15 @@
+// Vendored from @base-ui/utils v1.6.0 (MIT) — packages/utils/src/warn.ts
+// https://github.com/mui/base-ui — exact copy.
+let set;
+if (process.env.NODE_ENV !== 'production') {
+    set = new Set();
+}
+export function warn(...messages) {
+    if (process.env.NODE_ENV !== 'production') {
+        const messageKey = messages.join(' ');
+        if (!set.has(messageKey)) {
+            set.add(messageKey);
+            console.warn(`Base UI: ${messageKey}`);
+        }
+    }
+}

package/dist/internal/state-mappings.d.ts

@@ -0,0 +1,8 @@
+import type { StateAttributesMapping } from "./render/getStateAttributesProps.js";
+import type { TransitionStatus } from "./render/transition.js";
+export declare const openStateMapping: StateAttributesMapping<{
+    open: boolean;
+}>;
+export declare const transitionStatusMapping: StateAttributesMapping<{
+    transitionStatus: TransitionStatus;
+}>;

package/dist/internal/state-mappings.js

@@ -0,0 +1,17 @@
+// Shared state → data-attribute mappings for useRenderElement. Base UI
+// convention: `open` produces a data-open / data-closed presence pair so both
+// directions are styleable (exit transitions target data-closed).
+export const openStateMapping = {
+    open: (value) => (value ? { "data-open": "" } : { "data-closed": "" }),
+};
+// Base UI convention: the transitional frames of an open/close animation surface as
+// data-starting-style (entering) / data-ending-style (exiting); settled states emit nothing.
+export const transitionStatusMapping = {
+    transitionStatus: (value) => {
+        if (value === "starting")
+            return { "data-starting-style": "" };
+        if (value === "ending")
+            return { "data-ending-style": "" };
+        return null;
+    },
+};

package/dist/message/index.d.ts

@@ -0,0 +1,3 @@
+export * as Message from "./index.parts.js";
+export type { MessageChipSegment, MessageRootProps, MessageSelection, MessageState, MessageTextProps, MessageTurnProps, } from "./message.js";
+export { readMessageSelection, useMessageSelection, useMessageSelectionScope, } from "./message.js";

package/dist/message/index.js

@@ -0,0 +1,3 @@
+// Public surface of @intentface/chat/message. No directive — see index.parts.ts.
+export * as Message from "./index.parts.js";
+export { readMessageSelection, useMessageSelection, useMessageSelectionScope, } from "./message.js";

package/dist/message/index.parts.d.ts

@@ -0,0 +1 @@
+export { MessageRoot as Root, MessageText as Text, MessageTurn as Turn, } from "./message.js";

package/dist/message/index.parts.js

@@ -0,0 +1,5 @@
+// Part names for the `Message` namespace. Deliberately carries no
+// "use client" directive: this module and index.ts must stay server-resolvable
+// so a React Server Component can reach Message.Root and its siblings
+// through them. The directive lives one level down, on message.tsx.
+export { MessageRoot as Root, MessageText as Text, MessageTurn as Turn, } from "./message.js";

package/dist/message/message.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from "react";
+import { type ChipSegment } from "../chip-markdown.js";
+import type { PrimitiveProps } from "../internal/primitive-props.js";
+export type MessageState = {
+    /** Opaque role string; the consumer owns the concrete set. Surfaced as data-role. */
+    role: string;
+    /** Present as data-error when true. */
+    error: boolean;
+    /** Present as data-last when true. */
+    last: boolean;
+};
+export type MessageRootProps = Omit<PrimitiveProps<"div", MessageState>, "role"> & {
+    role: string;
+    isLast?: boolean;
+    isError?: boolean;
+};
+export declare const MessageRoot: ({ role, isLast, isError, className, render, style, ...elementProps }: MessageRootProps) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export type MessageTurnProps = PrimitiveProps<"div">;
+export declare const MessageTurn: ({ className, render, style, ...elementProps }: MessageTurnProps) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export type MessageChipSegment = Extract<ChipSegment, {
+    type: "chip";
+}>;
+export type MessageTextProps = Omit<PrimitiveProps<"span">, "children"> & {
+    children: string;
+    renderText?: (text: string, index: number) => ReactNode;
+    renderChip?: (chip: MessageChipSegment, index: number) => ReactNode;
+};
+export declare const MessageText: ({ children, className, render, style, renderText, renderChip, ...elementProps }: MessageTextProps) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export type MessageSelection = {
+    text: string;
+    range: Range;
+};
+export declare const readMessageSelection: (scope: HTMLElement) => MessageSelection | null;
+export declare const useMessageSelection: (scope: HTMLElement | null) => MessageSelection | null;
+/**
+ * Resolves the owning message's content element from an invisible anchor node
+ * rendered anywhere inside the message. Scoping to message-content keeps the
+ * toolbar off markers, sources, and actions elsewhere in the message.
+ */
+export declare const useMessageSelectionScope: () => {
+    anchorRef: (node: HTMLElement | null) => void;
+    contentElement: HTMLElement | null;
+};

package/dist/message/message.js

@@ -0,0 +1,78 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// Headless message parts. Owns the role/error/last data-attribute contract,
+// chip-segment text parsing (with render inversion for markdown/styled chips),
+// timestamp formatting, and the text-selection subsystem. Entrance animation,
+// popovers, tooltips, icons, and thumbnails belong to the styled layer.
+//
+// Every part supports the Base UI render prop: pass a ReactElement to swap the
+// underlying element (props are merged onto it), or a function `(props, state)`
+// for full control. The root's data attributes (data-role, data-error,
+// data-last) are generated from its state object, so the render callback and
+// CSS consumers see the same state.
+import { Fragment, useCallback, useEffect, useMemo, useState } from "react";
+import { parseChipSegments } from "../chip-markdown.js";
+import { useRenderElement } from "../internal/render/useRenderElement.js";
+export const MessageRoot = ({ role, isLast = false, isError = false, className, render, style, ...elementProps }) => {
+    const state = useMemo(() => ({ role, error: isError, last: isLast }), [role, isError, isLast]);
+    return useRenderElement("div", { className, render, style }, { state, props: [{ "data-message": "" }, elementProps] });
+};
+export const MessageTurn = ({ className, render, style, ...elementProps }) => useRenderElement("div", { className, render, style }, { props: [{ "data-message-turn": "" }, elementProps] });
+export const MessageText = ({ children, className, render, style, renderText, renderChip, ...elementProps }) => {
+    const segments = parseChipSegments(children);
+    const segmentNodes = segments.map((segment, index) => segment.type === "text" ? (_jsx(Fragment, { children: renderText ? renderText(segment.text, index) : segment.text }, index)) : (_jsx(Fragment, { children: renderChip ? (renderChip(segment, index)) : (_jsx("span", { "data-message-chip": "", children: segment.label })) }, index)));
+    return useRenderElement("span", { className, render, style }, { props: [{ "data-message-text": "", children: segmentNodes }, elementProps] });
+};
+export const readMessageSelection = (scope) => {
+    const selection = window.getSelection();
+    if (!selection || selection.isCollapsed || selection.rangeCount === 0)
+        return null;
+    const text = selection.toString();
+    if (text.trim().length === 0)
+        return null;
+    // Both endpoints must sit inside this message — a cross-message selection
+    // has its common ancestor outside the scope and resolves to null.
+    const range = selection.getRangeAt(0);
+    if (!scope.contains(range.commonAncestorContainer))
+        return null;
+    // Clone so later mutations of the live selection don't move our anchor.
+    return { text, range: range.cloneRange() };
+};
+// Subscribe to the document selection, scoped to `scope`. Samples when the
+// gesture settles (mouseup / keyup) instead of on every selectionchange drag
+// tick; selectionchange only clears the value once the selection collapses.
+export const useMessageSelection = (scope) => {
+    const [selection, setSelection] = useState(null);
+    useEffect(() => {
+        if (!scope)
+            return;
+        const readSelection = () => setSelection(readMessageSelection(scope));
+        const hideWhenCollapsed = () => {
+            const current = window.getSelection();
+            if (!current || current.isCollapsed)
+                setSelection(null);
+        };
+        document.addEventListener("mouseup", readSelection);
+        document.addEventListener("keyup", readSelection);
+        document.addEventListener("selectionchange", hideWhenCollapsed);
+        return () => {
+            document.removeEventListener("mouseup", readSelection);
+            document.removeEventListener("keyup", readSelection);
+            document.removeEventListener("selectionchange", hideWhenCollapsed);
+        };
+    }, [scope]);
+    return selection;
+};
+/**
+ * Resolves the owning message's content element from an invisible anchor node
+ * rendered anywhere inside the message. Scoping to message-content keeps the
+ * toolbar off markers, sources, and actions elsewhere in the message.
+ */
+export const useMessageSelectionScope = () => {
+    const [contentElement, setContentElement] = useState(null);
+    const anchorRef = useCallback((node) => {
+        const messageRoot = node?.closest("[data-message]");
+        setContentElement(messageRoot?.querySelector("[data-message-content]") ?? null);
+    }, []);
+    return { anchorRef, contentElement };
+};

package/dist/message-utils.d.ts

@@ -0,0 +1,55 @@
+import { type ChatMessage, type FilePart, type ReasoningPart, type TextPart, type ToolPart, type UnknownPart } from "./types.js";
+/** Classifies message parts into coarse groups for chronological rendering. */
+export type SegmentType = "reasoning" | "tool" | "text" | "file";
+/**
+ * A contiguous run of same-typed message parts. Used by message renderers to
+ * group reasoning blocks, tool calls, text chunks, etc.
+ */
+export type MessageSegment = {
+    type: "reasoning";
+    parts: ReasoningPart[];
+} | {
+    type: "tool";
+    parts: ToolPart[];
+} | {
+    type: "text";
+    parts: TextPart[];
+} | {
+    type: "file";
+    parts: FilePart[];
+};
+/**
+ * Maps a single message part to its segment type.
+ * Returns `null` for parts that are not rendered chronologically.
+ */
+export declare const partSegmentType: (part: UnknownPart) => SegmentType | null;
+/**
+ * Groups an array of message parts into contiguous segments of the same type.
+ * Adjacent parts with the same type are merged into a single segment. This
+ * preserves chronological order for interleaved rendering (e.g. reasoning
+ * interspersed with tool calls).
+ */
+export declare const getSegmentedParts: (parts: readonly UnknownPart[]) => MessageSegment[];
+/** A conversational turn: a user message plus its trailing assistant/tool replies. */
+export type Turn<Message extends ChatMessage<unknown, UnknownPart> = ChatMessage> = {
+    key: string;
+    messages: Message[];
+};
+/**
+ * Groups messages into turns. A new turn starts at every user message;
+ * non-user messages attach to the current turn. A conversation that opens with
+ * a non-user message still gets a leading turn so nothing is dropped. The turn
+ * key is the first message's id — stable while the trailing assistant message
+ * streams, so React keys and entrance animations stay put.
+ */
+export declare const groupTurns: <Message extends ChatMessage<unknown, UnknownPart>>(messages: readonly Message[], turnStartRole?: string) => Turn<Message>[];
+/** Aggregated text content from all text segments in a message. */
+export type TextInfo = {
+    parts: TextPart[];
+    /** Concatenated text content of all text parts. */
+    text: string;
+};
+/** Extracts all text parts from a message and concatenates their content. */
+export declare const getTextInfo: (segments: readonly MessageSegment[]) => TextInfo;
+/** Extracts all file attachment parts from segments. */
+export declare const getFileParts: (segments: readonly MessageSegment[]) => FilePart[];

package/dist/message-utils.js

@@ -0,0 +1,79 @@
+// Derivation helpers over the structural message contract in types.ts.
+// Pure functions — no React, no styling. Renderers and panel-state hooks share
+// these so they stay decoupled from concrete part shapes.
+import { isFilePart, isReasoningPart, isTextPart, isToolPart, } from "./types.js";
+/**
+ * Maps a single message part to its segment type.
+ * Returns `null` for parts that are not rendered chronologically.
+ */
+export const partSegmentType = (part) => {
+    if (isReasoningPart(part))
+        return "reasoning";
+    if (isTextPart(part))
+        return "text";
+    if (isFilePart(part))
+        return "file";
+    if (isToolPart(part))
+        return "tool";
+    return null;
+};
+/**
+ * Groups an array of message parts into contiguous segments of the same type.
+ * Adjacent parts with the same type are merged into a single segment. This
+ * preserves chronological order for interleaved rendering (e.g. reasoning
+ * interspersed with tool calls).
+ */
+export const getSegmentedParts = (parts) => {
+    const segments = [];
+    for (const part of parts) {
+        const segType = partSegmentType(part);
+        if (!segType)
+            continue;
+        const last = segments.at(-1);
+        if (last && last.type === segType) {
+            last.parts.push(part);
+        }
+        else {
+            segments.push({ type: segType, parts: [part] });
+        }
+    }
+    return segments;
+};
+/**
+ * Groups messages into turns. A new turn starts at every user message;
+ * non-user messages attach to the current turn. A conversation that opens with
+ * a non-user message still gets a leading turn so nothing is dropped. The turn
+ * key is the first message's id — stable while the trailing assistant message
+ * streams, so React keys and entrance animations stay put.
+ */
+export const groupTurns = (messages, 
+// The role that starts a new turn — opaque, so consumers with a different
+// role set can group correctly.
+turnStartRole = "user") => {
+    const turns = [];
+    for (const message of messages) {
+        const currentTurn = turns.at(-1);
+        if (message.role === turnStartRole || !currentTurn) {
+            turns.push({ key: message.id, messages: [message] });
+        }
+        else {
+            currentTurn.messages.push(message);
+        }
+    }
+    return turns;
+};
+/** Extracts all text parts from a message and concatenates their content. */
+export const getTextInfo = (segments) => {
+    const parts = segments
+        .filter((s) => s.type === "text")
+        .flatMap((s) => s.parts);
+    const text = parts.map((p) => p.text).join("");
+    return { parts, text };
+};
+/** Extracts all file attachment parts from segments. */
+export const getFileParts = (segments) => segments
+    .filter((s) => s.type === "file")
+    .flatMap((s) => s.parts);
+// Chain/reasoning/source extraction (and ask-user extraction) is the consuming
+// app's concern — grouping conventions, header formats, and dedup rules are
+// product policy. This package ships only the generic segmentation above.

package/dist/reasoning/index.d.ts

@@ -0,0 +1,3 @@
+export * as Reasoning from "./index.parts.js";
+export type { ReasoningContentProps, ReasoningRootProps, ReasoningTriggerProps, } from "./reasoning.js";
+export { useReasoning } from "./reasoning.js";

package/dist/reasoning/index.js

@@ -0,0 +1,3 @@
+// Public surface of @intentface/chat/reasoning. No directive — see index.parts.ts.
+export * as Reasoning from "./index.parts.js";
+export { useReasoning } from "./reasoning.js";

package/dist/reasoning/index.parts.d.ts

@@ -0,0 +1 @@
+export { ReasoningContent as Content, ReasoningRoot as Root, ReasoningTrigger as Trigger, } from "./reasoning.js";

package/dist/reasoning/index.parts.js

@@ -0,0 +1,5 @@
+// Part names for the `Reasoning` namespace. Deliberately carries no
+// "use client" directive: this module and index.ts must stay server-resolvable
+// so a React Server Component can reach Reasoning.Root and its siblings
+// through them. The directive lives one level down, on reasoning.tsx.
+export { ReasoningContent as Content, ReasoningRoot as Root, ReasoningTrigger as Trigger, } from "./reasoning.js";

package/dist/reasoning/reasoning.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentProps } from "react";
+import { Collapsible } from "../internal/collapsible.js";
+type ReasoningContextValue = {
+    isStreaming: boolean;
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    duration: number | undefined;
+};
+export declare const useReasoning: () => ReasoningContextValue;
+export type ReasoningRootProps = Omit<ComponentProps<typeof Collapsible>, "onOpenChange"> & {
+    isStreaming?: boolean;
+    duration?: number;
+    onOpenChange?: (open: boolean) => void;
+};
+export declare const ReasoningRoot: import("react").MemoExoticComponent<({ isStreaming, open: controlledOpen, defaultOpen, onOpenChange, duration: durationProp, children, ...props }: ReasoningRootProps) => import("react").JSX.Element>;
+export type ReasoningTriggerProps = ComponentProps<typeof Collapsible.Trigger>;
+export declare const ReasoningTrigger: (props: ReasoningTriggerProps) => import("react").JSX.Element;
+export type ReasoningContentProps = ComponentProps<typeof Collapsible.Panel>;
+export declare const ReasoningContent: (props: ReasoningContentProps) => import("react").JSX.Element;
+export {};

package/dist/reasoning/reasoning.js

@@ -0,0 +1,49 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// Headless reasoning disclosure. Owns the open state and the streaming
+// duration tracking; exposes them via useReasoning() so the styled layer can
+// render its own trigger label (shimmer, crossfade) and markdown content.
+import { createContext, memo, use, useCallback, useEffect, useMemo, useRef, useState, } from "react";
+import { Collapsible } from "../internal/collapsible.js";
+const MS_IN_S = 1000;
+const ReasoningContext = createContext(null);
+export const useReasoning = () => {
+    const context = use(ReasoningContext);
+    if (!context) {
+        throw new Error("Reasoning components must be used within Reasoning");
+    }
+    return context;
+};
+export const ReasoningRoot = memo(({ isStreaming = false, open: controlledOpen, defaultOpen, onOpenChange, duration: durationProp, children, ...props }) => {
+    const resolvedDefaultOpen = defaultOpen ?? false;
+    const [internalOpen, setInternalOpen] = useState(resolvedDefaultOpen);
+    const isControlled = controlledOpen !== undefined;
+    const isOpen = isControlled ? controlledOpen : internalOpen;
+    const [duration, setDuration] = useState(durationProp);
+    const hasEverStreamedRef = useRef(isStreaming);
+    const startTimeRef = useRef(null);
+    const setIsOpen = useCallback((value) => {
+        if (!isControlled) {
+            setInternalOpen(value);
+        }
+        onOpenChange?.(value);
+    }, [isControlled, onOpenChange]);
+    // Track when streaming starts and compute duration
+    useEffect(() => {
+        if (isStreaming) {
+            hasEverStreamedRef.current = true;
+            if (startTimeRef.current === null) {
+                startTimeRef.current = Date.now();
+            }
+        }
+        else if (startTimeRef.current !== null) {
+            setDuration(Math.ceil((Date.now() - startTimeRef.current) / MS_IN_S));
+            startTimeRef.current = null;
+        }
+    }, [isStreaming]);
+    const contextValue = useMemo(() => ({ duration, isOpen, isStreaming, setIsOpen }), [duration, isOpen, isStreaming, setIsOpen]);
+    return (_jsx(ReasoningContext, { value: contextValue, children: _jsx(Collapsible, { open: isOpen, onOpenChange: (open) => setIsOpen(open), "aria-busy": isStreaming || undefined, "data-reasoning": "", "data-streaming": isStreaming ? "" : undefined, ...props, children: children }) }));
+});
+ReasoningRoot.displayName = "Reasoning";
+export const ReasoningTrigger = (props) => (_jsx(Collapsible.Trigger, { "data-reasoning-trigger": "", ...props }));
+export const ReasoningContent = (props) => (_jsx(Collapsible.Panel, { "data-reasoning-content": "", ...props }));

package/dist/steps/index.d.ts

@@ -0,0 +1,2 @@
+export * as Steps from "./index.parts.js";
+export type { StepStatus, StepsIconProps, StepsItemProps, StepsLabelProps, StepsPanelProps, StepsRootProps, StepsStatusProps, StepsTriggerProps, } from "./steps.js";

package/dist/steps/index.js

@@ -0,0 +1,2 @@
+// Public surface of @intentface/chat/steps. No directive — see index.parts.ts.
+export * as Steps from "./index.parts.js";

package/dist/steps/index.parts.d.ts

@@ -0,0 +1 @@
+export { StepsIcon as Icon, StepsItem as Item, StepsLabel as Label, StepsPanel as Panel, StepsRoot as Root, StepsStatus as Status, StepsTrigger as Trigger, } from "./steps.js";

package/dist/steps/index.parts.js

@@ -0,0 +1,5 @@
+// Part names for the `Steps` namespace. Deliberately carries no
+// "use client" directive: this module and index.ts must stay server-resolvable
+// so a React Server Component can reach Steps.Root and its siblings
+// through them. The directive lives one level down, on steps.tsx.
+export { StepsIcon as Icon, StepsItem as Item, StepsLabel as Label, StepsPanel as Panel, StepsRoot as Root, StepsStatus as Status, StepsTrigger as Trigger, } from "./steps.js";

package/dist/steps/steps.d.ts

@@ -0,0 +1,53 @@
+import { type ComponentProps } from "react";
+import { Collapsible } from "../internal/collapsible.js";
+import type { PrimitiveProps } from "../internal/primitive-props.js";
+export type StepsRootProps = PrimitiveProps<"div">;
+export declare const StepsRoot: {
+    ({ className, render, style, ...elementProps }: StepsRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+    displayName: string;
+};
+export type StepStatus = string;
+export type StepsItemProps = ComponentProps<typeof Collapsible> & {
+    status?: StepStatus;
+};
+export declare const StepsItem: {
+    ({ status, defaultOpen, ...props }: StepsItemProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type StepsTriggerProps = ComponentProps<typeof Collapsible.Trigger>;
+export declare const StepsTrigger: {
+    (props: StepsTriggerProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type StepsPanelProps = ComponentProps<typeof Collapsible.Panel>;
+export declare const StepsPanel: {
+    (props: StepsPanelProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type StepsIconProps = PrimitiveProps<"span", {
+    status: StepStatus;
+}> & {
+    status?: StepStatus;
+};
+export declare const StepsIcon: {
+    ({ status, className, render, style, ...elementProps }: StepsIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+    displayName: string;
+};
+export type StepsLabelProps = PrimitiveProps<"span", {
+    status: StepStatus;
+}> & {
+    status?: StepStatus;
+};
+export declare const StepsLabel: {
+    ({ status, className, render, style, ...elementProps }: StepsLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+    displayName: string;
+};
+export type StepsStatusProps = PrimitiveProps<"span", {
+    status: StepStatus;
+}> & {
+    status?: StepStatus;
+};
+export declare const StepsStatus: {
+    ({ status, children, className, render, style, ...elementProps }: StepsStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+    displayName: string;
+};