@djangocfg/ui-tools 2.1.385 → 2.1.389

package/dist/index.d.cts

@@ -1,7 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import react__default, { ReactNode, ComponentType, RefObject, ChangeEvent, KeyboardEvent, ClipboardEvent, CSSProperties, ButtonHTMLAttributes, MouseEvent } from 'react';
-import { Components } from 'react-markdown';
 import { ViewState } from 'react-map-gl/maplibre';
 import { Language } from 'prism-react-renderer';
 export { Language } from 'prism-react-renderer';
@@ -16,6 +15,7 @@ export { c as DEFAULT_TREE_APPEARANCE, D as DEFAULT_TREE_LABELS, F as FlatRow, R
 import * as zustand from 'zustand';
 import { AudioPrefsState } from '@djangocfg/ui-core/hooks';
 import { ConsolaInstance } from 'consola';
+import { Components } from 'react-markdown';
 import { MediaPlayerInstance } from '@vidstack/react';
 import * as monaco from 'monaco-editor';
 import { Editor as Editor$1 } from '@tiptap/react';
@@ -117,220 +117,6 @@ declare function createLazyComponent<P extends object>(loader: () => Promise<{
     default: ComponentType<P>;
 }>, options?: CreateLazyComponentOptions<P>): ComponentType<P>;
 
-/**
- * Declarative rule for handling a custom URL scheme inside markdown.
- *
- * Each rule owns one href shape (e.g. `cmdop://machine/<uuid>`,
- * `obsidian://open?path=…`) and decides:
- *
- *   1. Whether the URL scheme survives sanitize (`protocols`).
- *   2. How to massage the source markdown before render
- *      (`preprocess` — optional; useful for stripping decorative
- *      prefixes like the `@` in `@[label](href)` so the chip alone
- *      reads as the mention indicator).
- *   3. Which links it owns (`match`), and how to render them
- *      (`render`, returning JSX).
- *
- * Rules compose: pass an array, and the renderer iterates top-to-bottom
- * picking the first `match` hit per `<a>`. Anything no rule claims
- * falls through to the built-in chat-link styling (or to a custom
- * `customComponents.a` if both are provided).
- *
- * Prefer `linkRules` over `customComponents` + `extraHrefProtocols` —
- * it's the same pieces with the boilerplate removed.
- */
-interface LinkRule {
-    /** Pre-process the raw markdown source before any rendering happens.
-     *  Pure / synchronous; identity-return when no transform applies. */
-    preprocess?: (source: string) => string;
-    /** Predicate against the resolved href. */
-    match: (href: string) => boolean;
-    /** Render the link this rule owns. `children` is the link's label
-     *  (markdown-rendered React content). */
-    render: (props: {
-        href: string;
-        children: react__default.ReactNode;
-        isUser: boolean;
-    }) => react__default.ReactNode;
-    /** URL scheme(s) to whitelist on the sanitize side, e.g. `['cmdop']`.
-     *  Bare schemes only — no `://`. Optional; omit for `http(s)` rules. */
-    protocols?: readonly string[];
-    /** Diagnostic label, surfaced in dev warnings. Optional. */
-    name?: string;
-}
-interface MarkdownMessageProps {
-    /** Markdown content to render */
-    content: string;
-    /** Additional CSS classes */
-    className?: string;
-    /** Whether the message is from the user (affects styling) */
-    isUser?: boolean;
-    /** Use compact size (text-xs instead of text-sm) */
-    isCompact?: boolean;
-    /**
-     * Force the plain-text rendering path (single `<div>` with
-     * `white-space: pre-wrap`, no ReactMarkdown). Use this for
-     * user-authored content where markdown shouldn't be parsed.
-     *
-     * When `undefined` (default) we run a small heuristic
-     * (`looksLikePlainProse`): short single-paragraph text without
-     * markdown markers → plain; everything else → ReactMarkdown.
-     *
-     * Pass an explicit `true` / `false` to opt out of the heuristic
-     * entirely.
-     */
-    plainText?: boolean;
-    /**
-     * Per-tag overrides merged on top of the built-in renderers.
-     *
-     * Use this when you need custom rendering for a specific tag without
-     * losing the chat-tuned defaults (links, code blocks with copy, etc).
-     *
-     * For custom URL-scheme link handling, prefer `linkRules` — it's the
-     * same ergonomics with the per-consumer boilerplate removed.
-     */
-    customComponents?: Partial<Components>;
-    /**
-     * Extra URL protocols allowed in `<a href>` after sanitize.
-     *
-     * The default schema strips anything that isn't
-     * `http(s)/mailto/xmpp/irc(s)` — your custom renderer would receive
-     * `href={undefined}` for `cmdop://…` / `obsidian://…` etc. Listing
-     * the bare scheme here (e.g. `'cmdop'`, NOT `'cmdop://'`) opts it in.
-     *
-     * Use carefully: every protocol you add increases what the rendered
-     * HTML can do via clicks. Stick to schemes you control.
-     */
-    extraHrefProtocols?: readonly string[];
-    /**
-     * Declarative link rules — preferred over `customComponents` +
-     * `extraHrefProtocols` for chat-style apps that want pluggable
-     * URL-scheme handling without re-implementing the custom-`a`
-     * boilerplate per consumer.
-     *
-     * If you provide both `linkRules` and `extraHrefProtocols`, the
-     * effective protocol list is the union of the two.
-     */
-    linkRules?: readonly LinkRule[];
-    /**
-     * Enable collapsible "Read more..." functionality
-     * @default false
-     */
-    collapsible?: boolean;
-    /** Maximum character length before showing "Read more...". */
-    maxLength?: number;
-    /** Maximum number of lines before showing "Read more...". */
-    maxLines?: number;
-    /** Custom "Read more" button text. @default "Read more..." */
-    readMoreLabel?: string;
-    /** Custom "Show less" button text. @default "Show less" */
-    showLessLabel?: string;
-    /** Start expanded (only when `collapsible` is true). @default false */
-    defaultExpanded?: boolean;
-    /** Callback when collapsed state changes */
-    onCollapseChange?: (isCollapsed: boolean) => void;
-}
-
-/**
- * MarkdownMessage — chat-tuned markdown renderer.
- *
- * Features:
- * - GitHub Flavored Markdown (GFM) via remark-gfm
- * - Syntax-highlighted code blocks with Copy button
- * - Mermaid diagram rendering (` ```mermaid ` fence)
- * - Tables, lists, blockquotes scaled for chat density
- * - User vs assistant styling modes (`isUser`)
- * - Plain-text fast path: skips ReactMarkdown when content has no
- *   markdown syntax (cheaper render, preserves newlines via CSS)
- * - Optional collapsible "Read more..." for long messages
- *
- * Custom URL schemes (chat mentions, deep-links, custom file viewers)
- * are best handled with the declarative `linkRules` prop — see the
- * type definition in `./types.ts` and the storybook for examples.
- *
- * @example
- * ```tsx
- * <MarkdownMessage content="# Hello\n\nThis is **bold** text." />
- *
- * // User message styling
- * <MarkdownMessage content="Some content" isUser />
- *
- * // Custom URL scheme via linkRules
- * <MarkdownMessage
- *   content="Talk to [Vps-audi](cmdop://machine/abc-123)"
- *   linkRules={[machineMentionRule]}
- * />
- * ```
- *
- * Memoised: re-renders only when props change. `content` is the main
- * trigger — all other props (className, isUser, isCompact, etc.) are
- * compared by value/reference. `onCollapseChange` is compared by
- * reference — callers should stabilise it with useCallback.
- */
-declare function MarkdownMessageRaw({ content, className, isUser, isCompact, plainText, customComponents, extraHrefProtocols, linkRules, collapsible, maxLength, maxLines, readMoreLabel, showLessLabel, defaultExpanded, onCollapseChange, }: MarkdownMessageProps): react_jsx_runtime.JSX.Element;
-declare const MarkdownMessage: react__default.MemoExoticComponent<typeof MarkdownMessageRaw>;
-
-/** Recursively concatenate the text content of a React.ReactNode tree.
- *  Used by the markdown renderers (e.g. `<pre>` extracting code) and
- *  by consumers that need a plain-string label out of link children. */
-declare function extractTextFromChildren(children: react__default.ReactNode): string;
-
-interface UseCollapsibleContentOptions {
-    /**
-     * Maximum character length before collapsing
-     * If both maxLength and maxLines are set, the stricter limit applies
-     */
-    maxLength?: number;
-    /**
-     * Maximum number of lines before collapsing
-     * If both maxLength and maxLines are set, the stricter limit applies
-     */
-    maxLines?: number;
-    /**
-     * Start in expanded state (default: false - starts collapsed)
-     */
-    defaultExpanded?: boolean;
-}
-interface UseCollapsibleContentResult {
-    /** Whether content is currently collapsed */
-    isCollapsed: boolean;
-    /** Toggle between collapsed/expanded state */
-    toggleCollapsed: () => void;
-    /** Set collapsed state directly */
-    setCollapsed: (collapsed: boolean) => void;
-    /** Content to display (truncated if collapsed, full if expanded) */
-    displayContent: string;
-    /** Whether the content exceeds limits and should be collapsible */
-    shouldCollapse: boolean;
-    /** Original content length */
-    originalLength: number;
-    /** Original line count */
-    originalLineCount: number;
-}
-/**
- * Hook for managing collapsible content with "Read more..." functionality
- *
- * @example
- * ```tsx
- * const { isCollapsed, toggleCollapsed, displayContent, shouldCollapse } = useCollapsibleContent(
- *   longText,
- *   { maxLength: 300, maxLines: 5 }
- * );
- *
- * return (
- *   <div>
- *     <Markdown content={displayContent} />
- *     {shouldCollapse && (
- *       <button onClick={toggleCollapsed}>
- *         {isCollapsed ? 'Read more...' : 'Show less'}
- *       </button>
- *     )}
- *   </div>
- * );
- * ```
- */
-declare function useCollapsibleContent(content: string, options?: UseCollapsibleContentOptions): UseCollapsibleContentResult;
-
 interface MarkerData {
     id: string;
     longitude: number;
@@ -2249,267 +2035,6 @@ interface ChatRootProps {
 }
 declare function ChatRoot(props: ChatRootProps): react_jsx_runtime.JSX.Element;
 
-declare const LazyChat: react.ComponentType<ChatRootProps>;
-
-/**
- * Chat defaults and constants.
- */
-declare const STORAGE_KEYS: {
-    readonly mode: "djc-chat-mode";
-    readonly sidebarWidth: "djc-chat-sidebar-width";
-    readonly composerHistory: "djc-chat-composer-history";
-};
-declare const CSS_VARS: {
-    readonly reserve: "--djc-chat-reserve";
-};
-declare const DEFAULT_Z_INDEX = 9000;
-declare const LIMITS: {
-    /** Max characters per single message. */
-    readonly messageMaxLength: 8000;
-    /** Max attachments per message. */
-    readonly attachmentsMax: 10;
-    /** Composer history slots. */
-    readonly composerHistorySize: 50;
-    /** Coalesce stream tokens within this window before dispatching. */
-    readonly streamCoalesceMs: 16;
-    /** Default history page size. */
-    readonly pageSize: 50;
-    /** Virtualize list when >= this many messages (host-controlled threshold). */
-    readonly virtualizeThreshold: 50;
-    /** SSE idle timeout. */
-    readonly sseIdleMs: 45000;
-};
-declare const DEFAULT_SIDEBAR: {
-    readonly width: 420;
-    readonly min: 320;
-    readonly max: 720;
-};
-declare const HOTKEYS: {
-    readonly send: "mod+enter";
-    readonly cancel: "esc";
-    readonly newChat: "mod+shift+n";
-    readonly toggleOpen: "mod+/";
-    readonly focusComposer: "mod+l";
-};
-declare const CHAT_EVENT_NAME = "djc:chat:send";
-interface ChatEventDetail {
-    content: string;
-    sessionId?: string;
-    attachments?: unknown[];
-    metadata?: Record<string, unknown>;
-}
-
-/**
- * ID generation. Uses crypto.randomUUID when available with a fallback
- * for older environments (and SSR bundles that may not have crypto).
- */
-declare function createId(prefix?: string): string;
-
-/**
- * Token coalescer. Buffers stream tokens within a small time window before
- * dispatching a single aggregated chunk. Prevents 60+ re-renders per second
- * on fast streams.
- */
-interface TokenBuffer {
-    /** Append a delta. Returns immediately. */
-    push(delta: string): void;
-    /** Force flush and resolve any pending timer. */
-    flush(): void;
-    /** Stop accepting tokens; flush whatever is buffered. */
-    close(): void;
-}
-declare function createTokenBuffer(onFlush: (delta: string) => void, windowMs?: 16): TokenBuffer;
-
-declare function resolvePersona(message: Pick<ChatMessage, 'role' | 'sender'>, user?: ChatUserContext, assistant?: ChatAssistantContext): ChatPersona;
-/** Compute initials for an avatar fallback. */
-declare function deriveInitials(persona: ChatPersona, role?: string): string;
-
-/**
- * HTTP + SSE transport. Default implementation for web hosts.
- *
- * Backend contract (see @dev/@refactoring7-chat/06-integration.md):
- *   POST   /sessions                     → SessionInfo (JSON)
- *   GET    /sessions/:id/history?cursor= → HistoryPage (JSON)
- *   POST   /sessions/:id/messages        → SSE stream of ChatStreamEvent
- *   POST   /sessions/:id/messages/buffered → ChatMessage (JSON, fallback)
- *   DELETE /sessions/:id                 → 204
- */
-
-interface HttpTransportConfig {
-    /** Base URL without trailing slash, e.g. '/api/chat' or 'https://api.example.com/v1/chat'. */
-    baseUrl: string;
-    /** Optional slug appended/forwarded as project identifier. */
-    slug?: string;
-    /** Returns headers applied to every request — e.g. Authorization. */
-    getAuthHeader?: () => Record<string, string> | Promise<Record<string, string>>;
-    /** Default fetch timeout (per non-streaming request). */
-    timeoutMs?: number;
-    /** Override fetch implementation (useful for tests or custom retry layers). */
-    fetchImpl?: typeof fetch;
-}
-declare function createHttpTransport(config: HttpTransportConfig): ChatTransport;
-
-/**
- * In-memory chat transport for stories and tests. Replays scripted replies.
- */
-
-interface MockTransportOptions {
-    /** Each entry is the assistant's reply for one user turn. Strings are split
-     *  into chunks; arrays are taken as the exact event sequence (after a
-     *  prepended `message_start` and before a synthetic `message_end`). */
-    replies?: Array<string | ChatStreamEvent[]>;
-    latencyMs?: number;
-    /** Initial history returned by `createSession`. */
-    initialMessages?: ChatMessage[];
-    shouldFail?: (attempt: number) => boolean;
-}
-declare function createMockTransport(opts?: MockTransportOptions): ChatTransport;
-
-/**
- * Server-Sent Events parser as an AsyncGenerator.
- *
- * Yields parsed events from a `Response` body. Handles the split-read case
- * where `event:` and `data:` arrive in separate TCP packets. Skips malformed
- * JSON gracefully. Honors AbortSignal (caller passes one to fetch).
- */
-
-interface RawEvent {
-    event?: string;
-    data?: string;
-}
-interface ParseSSEOptions {
-    signal?: AbortSignal;
-    /** Map a raw SSE event to zero, one, or many `ChatStreamEvent`s.
-     *  Default: parse `data` as JSON and assume the JSON shape already
-     *  matches `ChatStreamEvent`. */
-    map?: (raw: RawEvent) => ChatStreamEvent | ChatStreamEvent[] | null;
-    idleTimeoutMs?: number;
-}
-declare function parseSSE(response: Response, options?: ParseSSEOptions): AsyncGenerator<ChatStreamEvent, void, void>;
-
-/**
- * Transport surface re-export. Lives in core so transport implementations
- * never need to reach into the public types module.
- */
-
-declare class TransportError extends Error {
-    code: string;
-    constructor(message: string, code?: string);
-}
-
-/**
- * Pydantic-AI SSE event mapper.
- *
- * Translates the event shape emitted by pydantic-AI–style Django backends
- * (text_delta / tool_call / tool_result / done / error / approval_required)
- * into the canonical `ChatStreamEvent` stream consumed by the Chat reducer.
- *
- * Backends that don't expose a stable `tool_call_id` are supported via a
- * per-stream FIFO queue keyed by tool name. The earlier "Map<name, toolId>"
- * approach lost the first toolId when a tool was invoked twice in one turn
- * (e.g. `list_tasks` for search and again for confirmation) — using a queue
- * keeps each call/result pair correctly matched.
- */
-
-interface PydanticAIEvent {
-    type: 'text_delta' | 'tool_call' | 'tool_result' | 'done' | 'error' | 'approval_required';
-    delta?: string;
-    tool?: string;
-    args?: unknown;
-    result?: unknown;
-    /**
-     * Structured frontend payload — present on `tool_result` when the tool has
-     * a `result_schema`. The LLM sees only `result` (compact text); the
-     * frontend uses `data` to render rich UI (e.g. vehicle cards).
-     */
-    data?: unknown;
-    total_tokens?: number;
-    error?: string;
-    tool_call_id?: string;
-    session_id?: string;
-}
-/** Per-stream FIFO queue keyed by tool name. Created via `createToolIdQueue`. */
-interface ToolIdQueue {
-    /** Allocate a new toolId for a `tool_call` event and enqueue it under `name`. */
-    push(name: string): string;
-    /** Pop the oldest toolId for `name` (or return an orphan marker if none). */
-    shift(name: string): string;
-    /** Reset all queues (e.g. on stream close). */
-    clear(): void;
-}
-declare function createToolIdQueue(): ToolIdQueue;
-/**
- * Translate a single pydantic-AI event into zero or more `ChatStreamEvent`s.
- * Pass a `ToolIdQueue` shared across the lifetime of one stream so that
- * `tool_call` / `tool_result` pairs match correctly.
- */
-declare function mapPydanticAIEvent(ev: PydanticAIEvent, toolIds: ToolIdQueue): Generator<ChatStreamEvent>;
-/**
- * Convenience factory: returns a `ParseSSEOptions['map']` callback that
- * decodes raw SSE frames as `PydanticAIEvent` JSON and yields zero or
- * more `ChatStreamEvent`s through `mapPydanticAIEvent`.
- *
- * Allocates an internal `ToolIdQueue` — call this once per stream.
- */
-declare function createPydanticAISSEMap(): NonNullable<ParseSSEOptions['map']>;
-
-/**
- * High-level transport factory for pydantic-AI–style backends.
- *
- * Composes:
- *   - `parseSSE` for spec-compliant SSE framing (multi-line `data:`, comments, idle timeout).
- *   - `createPydanticAISSEMap` for normalizing pydantic-AI events into `ChatStreamEvent`.
- *
- * Use when your backend speaks the canonical pydantic-AI stream shape
- * (`text_delta` / `tool_call` / `tool_result` / `done` / `error`).
- * URL building, auth headers, history loading, and optional session
- * bootstrapping are caller responsibilities — pass them in.
- */
-
-interface PydanticAIChatTransportOpts {
-    /**
-     * Build the SSE stream URL for a user message turn.
-     * @example (sessionId, message) => `${base}/stream?session_id=${sessionId}&message=${encodeURIComponent(message)}`
-     */
-    buildStreamUrl: (sessionId: string, message: string) => string | URL;
-    /** Optional history loader. If omitted, `loadHistory` returns an empty page. */
-    loadHistory?: (sessionId: string, cursor?: string | null) => Promise<HistoryPage>;
-    /**
-     * Optional session bootstrap. Called from `createSession`. Useful for
-     * backends that need a `POST /sessions` round-trip or want to pre-seed
-     * history.
-     */
-    bootstrapSession?: (opts?: CreateSessionOptions) => Promise<SessionInfo>;
-    /** Optional session teardown. */
-    closeSession?: (sessionId: string) => Promise<void>;
-    /**
-     * Optional non-streaming send (for hosts that need a buffered fallback,
-     * e.g. when the user disables streaming). Defaults to throwing — most
-     * hosts only use streaming.
-     */
-    send?: (sessionId: string, content: string, options?: SendOptions) => Promise<ChatMessage>;
-    /** Request headers (Authorization, content-type, etc.). */
-    buildHeaders?: () => HeadersInit | Promise<HeadersInit>;
-    /** Override fetch (tests, retry layers). */
-    fetchImpl?: typeof fetch;
-    /**
-     * HTTP method for the stream request. Defaults to `'POST'` with
-     * `{ content, attachments, metadata }` JSON body. Set to `'GET'` if
-     * your backend embeds the message in the URL via `buildStreamUrl`.
-     */
-    streamMethod?: 'GET' | 'POST';
-    /** Idle timeout for the SSE connection, in ms. Forwarded to `parseSSE`. */
-    idleTimeoutMs?: number;
-    /**
-     * Side-channel for events that don't translate to `ChatStreamEvent`
-     * (e.g. `approval_required` — surfaces interactive prompts outside the
-     * normal message stream). Called synchronously while parsing the SSE
-     * frame; mutate caller-owned state, don't `await` long work here.
-     */
-    onPydanticEvent?: (event: PydanticAIEvent) => void;
-}
-declare function createPydanticAIChatTransport(opts: PydanticAIChatTransportOpts): ChatTransport;
-
 type ChatFABPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
 type ChatFABVariant = 'simple' | 'animated' | 'glass';
 type ChatFABSize = 'sm' | 'md' | 'lg' | 'responsive';
@@ -3060,41 +2585,300 @@ type ChatPresencePhase = 'hidden' | 'entering' | 'visible' | 'leaving';
 declare function useChatPresence(open: boolean, exitDurationMs?: number): ChatPresencePhase;
 
 /**
- * @deprecated Plan64. As of ui-tools 2.1.369, `<MessageList>` is
- * virtualized via react-virtuoso and owns its own scroll viewport.
- * Sticky-bottom + auto-follow on streaming live inside the component;
- * use the new `MessageListProps.onAtBottomChange` prop and the
- * `MessageListHandle.scrollToBottom()` imperative method instead.
- *
- * This hook is kept for hosts that render messages outside
- * `<MessageList>` (e.g. headless story shells, custom non-virtualized
- * scroll containers). It still works against any HTMLElement scroll
- * container, but it does NOT integrate with Virtuoso — passing a
- * Virtuoso-managed element here will read garbage scroll metrics.
+ * Chat defaults and constants.
  */
-interface UseChatScrollOptions {
-    containerRef: RefObject<HTMLElement | null>;
-    bottomRef: RefObject<HTMLElement | null>;
-    isStreaming?: boolean;
-    /** Distance from bottom (px) considered "at bottom". */
-    bottomThresholdPx?: number;
-    /** Bump key — increment when a new message arrives so the hook re-evaluates auto-scroll. */
-    messagesCount?: number;
-}
-interface UseChatScrollReturn {
-    isAtBottom: boolean;
-    unreadCount: number;
-    scrollToBottom: (smooth?: boolean) => void;
-    resetUnread: () => void;
-}
-declare function useChatScroll(options: UseChatScrollOptions): UseChatScrollReturn;
-
-interface UseChatHistoryOptions {
-    enabled?: boolean;
-    containerRef: RefObject<HTMLElement | null>;
-    topSentinelRef: RefObject<HTMLElement | null>;
-    hasMore: boolean;
-    isLoadingMore: boolean;
+declare const STORAGE_KEYS: {
+    readonly mode: "djc-chat-mode";
+    readonly sidebarWidth: "djc-chat-sidebar-width";
+    readonly composerHistory: "djc-chat-composer-history";
+};
+declare const CSS_VARS: {
+    readonly reserve: "--djc-chat-reserve";
+};
+declare const DEFAULT_Z_INDEX = 9000;
+declare const LIMITS: {
+    /** Max characters per single message. */
+    readonly messageMaxLength: 8000;
+    /** Max attachments per message. */
+    readonly attachmentsMax: 10;
+    /** Composer history slots. */
+    readonly composerHistorySize: 50;
+    /** Coalesce stream tokens within this window before dispatching. */
+    readonly streamCoalesceMs: 16;
+    /** Default history page size. */
+    readonly pageSize: 50;
+    /** Virtualize list when >= this many messages (host-controlled threshold). */
+    readonly virtualizeThreshold: 50;
+    /** SSE idle timeout. */
+    readonly sseIdleMs: 45000;
+};
+declare const DEFAULT_SIDEBAR: {
+    readonly width: 420;
+    readonly min: 320;
+    readonly max: 720;
+};
+declare const HOTKEYS: {
+    readonly send: "mod+enter";
+    readonly cancel: "esc";
+    readonly newChat: "mod+shift+n";
+    readonly toggleOpen: "mod+/";
+    readonly focusComposer: "mod+l";
+};
+declare const CHAT_EVENT_NAME = "djc:chat:send";
+interface ChatEventDetail {
+    content: string;
+    sessionId?: string;
+    attachments?: unknown[];
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * ID generation. Uses crypto.randomUUID when available with a fallback
+ * for older environments (and SSR bundles that may not have crypto).
+ */
+declare function createId(prefix?: string): string;
+
+/**
+ * Token coalescer. Buffers stream tokens within a small time window before
+ * dispatching a single aggregated chunk. Prevents 60+ re-renders per second
+ * on fast streams.
+ */
+interface TokenBuffer {
+    /** Append a delta. Returns immediately. */
+    push(delta: string): void;
+    /** Force flush and resolve any pending timer. */
+    flush(): void;
+    /** Stop accepting tokens; flush whatever is buffered. */
+    close(): void;
+}
+declare function createTokenBuffer(onFlush: (delta: string) => void, windowMs?: 16): TokenBuffer;
+
+declare function resolvePersona(message: Pick<ChatMessage, 'role' | 'sender'>, user?: ChatUserContext, assistant?: ChatAssistantContext): ChatPersona;
+/** Compute initials for an avatar fallback. */
+declare function deriveInitials(persona: ChatPersona, role?: string): string;
+
+/**
+ * HTTP + SSE transport. Default implementation for web hosts.
+ *
+ * Backend contract (see @dev/@refactoring7-chat/06-integration.md):
+ *   POST   /sessions                     → SessionInfo (JSON)
+ *   GET    /sessions/:id/history?cursor= → HistoryPage (JSON)
+ *   POST   /sessions/:id/messages        → SSE stream of ChatStreamEvent
+ *   POST   /sessions/:id/messages/buffered → ChatMessage (JSON, fallback)
+ *   DELETE /sessions/:id                 → 204
+ */
+
+interface HttpTransportConfig {
+    /** Base URL without trailing slash, e.g. '/api/chat' or 'https://api.example.com/v1/chat'. */
+    baseUrl: string;
+    /** Optional slug appended/forwarded as project identifier. */
+    slug?: string;
+    /** Returns headers applied to every request — e.g. Authorization. */
+    getAuthHeader?: () => Record<string, string> | Promise<Record<string, string>>;
+    /** Default fetch timeout (per non-streaming request). */
+    timeoutMs?: number;
+    /** Override fetch implementation (useful for tests or custom retry layers). */
+    fetchImpl?: typeof fetch;
+}
+declare function createHttpTransport(config: HttpTransportConfig): ChatTransport;
+
+/**
+ * In-memory chat transport for stories and tests. Replays scripted replies.
+ */
+
+interface MockTransportOptions {
+    /** Each entry is the assistant's reply for one user turn. Strings are split
+     *  into chunks; arrays are taken as the exact event sequence (after a
+     *  prepended `message_start` and before a synthetic `message_end`). */
+    replies?: Array<string | ChatStreamEvent[]>;
+    latencyMs?: number;
+    /** Initial history returned by `createSession`. */
+    initialMessages?: ChatMessage[];
+    shouldFail?: (attempt: number) => boolean;
+}
+declare function createMockTransport(opts?: MockTransportOptions): ChatTransport;
+
+/**
+ * Server-Sent Events parser as an AsyncGenerator.
+ *
+ * Yields parsed events from a `Response` body. Handles the split-read case
+ * where `event:` and `data:` arrive in separate TCP packets. Skips malformed
+ * JSON gracefully. Honors AbortSignal (caller passes one to fetch).
+ */
+
+interface RawEvent {
+    event?: string;
+    data?: string;
+}
+interface ParseSSEOptions {
+    signal?: AbortSignal;
+    /** Map a raw SSE event to zero, one, or many `ChatStreamEvent`s.
+     *  Default: parse `data` as JSON and assume the JSON shape already
+     *  matches `ChatStreamEvent`. */
+    map?: (raw: RawEvent) => ChatStreamEvent | ChatStreamEvent[] | null;
+    idleTimeoutMs?: number;
+}
+declare function parseSSE(response: Response, options?: ParseSSEOptions): AsyncGenerator<ChatStreamEvent, void, void>;
+
+/**
+ * Transport surface re-export. Lives in core so transport implementations
+ * never need to reach into the public types module.
+ */
+
+declare class TransportError extends Error {
+    code: string;
+    constructor(message: string, code?: string);
+}
+
+/**
+ * Pydantic-AI SSE event mapper.
+ *
+ * Translates the event shape emitted by pydantic-AI–style Django backends
+ * (text_delta / tool_call / tool_result / done / error / approval_required)
+ * into the canonical `ChatStreamEvent` stream consumed by the Chat reducer.
+ *
+ * Backends that don't expose a stable `tool_call_id` are supported via a
+ * per-stream FIFO queue keyed by tool name. The earlier "Map<name, toolId>"
+ * approach lost the first toolId when a tool was invoked twice in one turn
+ * (e.g. `list_tasks` for search and again for confirmation) — using a queue
+ * keeps each call/result pair correctly matched.
+ */
+
+interface PydanticAIEvent {
+    type: 'text_delta' | 'tool_call' | 'tool_result' | 'done' | 'error' | 'approval_required';
+    delta?: string;
+    tool?: string;
+    args?: unknown;
+    result?: unknown;
+    /**
+     * Structured frontend payload — present on `tool_result` when the tool has
+     * a `result_schema`. The LLM sees only `result` (compact text); the
+     * frontend uses `data` to render rich UI (e.g. vehicle cards).
+     */
+    data?: unknown;
+    total_tokens?: number;
+    error?: string;
+    tool_call_id?: string;
+    session_id?: string;
+}
+/** Per-stream FIFO queue keyed by tool name. Created via `createToolIdQueue`. */
+interface ToolIdQueue {
+    /** Allocate a new toolId for a `tool_call` event and enqueue it under `name`. */
+    push(name: string): string;
+    /** Pop the oldest toolId for `name` (or return an orphan marker if none). */
+    shift(name: string): string;
+    /** Reset all queues (e.g. on stream close). */
+    clear(): void;
+}
+declare function createToolIdQueue(): ToolIdQueue;
+/**
+ * Translate a single pydantic-AI event into zero or more `ChatStreamEvent`s.
+ * Pass a `ToolIdQueue` shared across the lifetime of one stream so that
+ * `tool_call` / `tool_result` pairs match correctly.
+ */
+declare function mapPydanticAIEvent(ev: PydanticAIEvent, toolIds: ToolIdQueue): Generator<ChatStreamEvent>;
+/**
+ * Convenience factory: returns a `ParseSSEOptions['map']` callback that
+ * decodes raw SSE frames as `PydanticAIEvent` JSON and yields zero or
+ * more `ChatStreamEvent`s through `mapPydanticAIEvent`.
+ *
+ * Allocates an internal `ToolIdQueue` — call this once per stream.
+ */
+declare function createPydanticAISSEMap(): NonNullable<ParseSSEOptions['map']>;
+
+/**
+ * High-level transport factory for pydantic-AI–style backends.
+ *
+ * Composes:
+ *   - `parseSSE` for spec-compliant SSE framing (multi-line `data:`, comments, idle timeout).
+ *   - `createPydanticAISSEMap` for normalizing pydantic-AI events into `ChatStreamEvent`.
+ *
+ * Use when your backend speaks the canonical pydantic-AI stream shape
+ * (`text_delta` / `tool_call` / `tool_result` / `done` / `error`).
+ * URL building, auth headers, history loading, and optional session
+ * bootstrapping are caller responsibilities — pass them in.
+ */
+
+interface PydanticAIChatTransportOpts {
+    /**
+     * Build the SSE stream URL for a user message turn.
+     * @example (sessionId, message) => `${base}/stream?session_id=${sessionId}&message=${encodeURIComponent(message)}`
+     */
+    buildStreamUrl: (sessionId: string, message: string) => string | URL;
+    /** Optional history loader. If omitted, `loadHistory` returns an empty page. */
+    loadHistory?: (sessionId: string, cursor?: string | null) => Promise<HistoryPage>;
+    /**
+     * Optional session bootstrap. Called from `createSession`. Useful for
+     * backends that need a `POST /sessions` round-trip or want to pre-seed
+     * history.
+     */
+    bootstrapSession?: (opts?: CreateSessionOptions) => Promise<SessionInfo>;
+    /** Optional session teardown. */
+    closeSession?: (sessionId: string) => Promise<void>;
+    /**
+     * Optional non-streaming send (for hosts that need a buffered fallback,
+     * e.g. when the user disables streaming). Defaults to throwing — most
+     * hosts only use streaming.
+     */
+    send?: (sessionId: string, content: string, options?: SendOptions) => Promise<ChatMessage>;
+    /** Request headers (Authorization, content-type, etc.). */
+    buildHeaders?: () => HeadersInit | Promise<HeadersInit>;
+    /** Override fetch (tests, retry layers). */
+    fetchImpl?: typeof fetch;
+    /**
+     * HTTP method for the stream request. Defaults to `'POST'` with
+     * `{ content, attachments, metadata }` JSON body. Set to `'GET'` if
+     * your backend embeds the message in the URL via `buildStreamUrl`.
+     */
+    streamMethod?: 'GET' | 'POST';
+    /** Idle timeout for the SSE connection, in ms. Forwarded to `parseSSE`. */
+    idleTimeoutMs?: number;
+    /**
+     * Side-channel for events that don't translate to `ChatStreamEvent`
+     * (e.g. `approval_required` — surfaces interactive prompts outside the
+     * normal message stream). Called synchronously while parsing the SSE
+     * frame; mutate caller-owned state, don't `await` long work here.
+     */
+    onPydanticEvent?: (event: PydanticAIEvent) => void;
+}
+declare function createPydanticAIChatTransport(opts: PydanticAIChatTransportOpts): ChatTransport;
+
+/**
+ * @deprecated Plan64. As of ui-tools 2.1.369, `<MessageList>` is
+ * virtualized via react-virtuoso and owns its own scroll viewport.
+ * Sticky-bottom + auto-follow on streaming live inside the component;
+ * use the new `MessageListProps.onAtBottomChange` prop and the
+ * `MessageListHandle.scrollToBottom()` imperative method instead.
+ *
+ * This hook is kept for hosts that render messages outside
+ * `<MessageList>` (e.g. headless story shells, custom non-virtualized
+ * scroll containers). It still works against any HTMLElement scroll
+ * container, but it does NOT integrate with Virtuoso — passing a
+ * Virtuoso-managed element here will read garbage scroll metrics.
+ */
+interface UseChatScrollOptions {
+    containerRef: RefObject<HTMLElement | null>;
+    bottomRef: RefObject<HTMLElement | null>;
+    isStreaming?: boolean;
+    /** Distance from bottom (px) considered "at bottom". */
+    bottomThresholdPx?: number;
+    /** Bump key — increment when a new message arrives so the hook re-evaluates auto-scroll. */
+    messagesCount?: number;
+}
+interface UseChatScrollReturn {
+    isAtBottom: boolean;
+    unreadCount: number;
+    scrollToBottom: (smooth?: boolean) => void;
+    resetUnread: () => void;
+}
+declare function useChatScroll(options: UseChatScrollOptions): UseChatScrollReturn;
+
+interface UseChatHistoryOptions {
+    enabled?: boolean;
+    containerRef: RefObject<HTMLElement | null>;
+    topSentinelRef: RefObject<HTMLElement | null>;
+    hasMore: boolean;
+    isLoadingMore: boolean;
     loadMore: () => Promise<void>;
 }
 /** Triggers `loadMore` when the top sentinel enters the container's viewport.
@@ -3419,6 +3203,101 @@ declare function isGeoJSONFeatureCollection(v: unknown): v is {
 };
 declare function isStringValue(v: unknown): v is string;
 
+/**
+ * Chat dev logger.
+ *
+ * A thin namespaced wrapper over `consola` that no-ops in production unless
+ * the host app explicitly opts in via `<ChatRoot debug />`. The default
+ * detection uses `isDev` from `@djangocfg/ui-core/lib/env` (NODE_ENV).
+ *
+ * Why a dedicated module: chat is async and event-heavy (bootstrap, transport,
+ * SSE chunks, tool calls, regenerate, …). Inline `console.log`s rot fast and
+ * leak into prod. A single `getChatLogger()` call gives every layer the same
+ * namespaced sub-logger and keeps zero-cost gating in one place.
+ *
+ * Sub-loggers:
+ *   bootstrap  — initial session bootstrap (createSession / loadHistory)
+ *   transport  — outbound transport calls + responses
+ *   stream     — SSE chunk / tool / message_end events
+ *   lifecycle  — sendMessage, regenerate, newSession, edits
+ *   tools      — tool_call_start / _delta / _end specifics
+ *   error      — caught errors (always emitted as `error` level)
+ */
+
+type ChatLogScope = 'bootstrap' | 'transport' | 'stream' | 'lifecycle' | 'tools' | 'error';
+interface ChatLogger {
+    bootstrap: ConsolaInstance;
+    transport: ConsolaInstance;
+    stream: ConsolaInstance;
+    lifecycle: ConsolaInstance;
+    tools: ConsolaInstance;
+    error: ConsolaInstance;
+    /** True when this logger is actually emitting (host opted in or NODE_ENV=development). */
+    enabled: boolean;
+}
+/**
+ * Get the chat logger.
+ * @param debug Explicit override from the host. `undefined` falls back to `isDev`.
+ */
+declare function getChatLogger(debug?: boolean): ChatLogger;
+
+/**
+ * sanitizeDraft — minimal pre-submit cleanup for chat-composer drafts.
+ *
+ * Mirrors the conservative behaviour ChatGPT / Claude / Telegram
+ * actually ship: clean the obvious junk the user didn't intend to
+ * send, touch nothing that *could* be intentional.
+ *
+ * **What we DO touch:**
+ *
+ *   1. Trim leading/trailing whitespace (spaces, tabs, newlines,
+ *      NBSP). The user typing `\n\n   hello   \n` meant `hello`.
+ *   2. Normalise line endings — `\r\n` / `\r` → `\n`. Pasted Windows
+ *      / old-mac text gets the same internal shape, so the LLM
+ *      tokeniser and markdown renderer see one canonical form.
+ *   3. Strip zero-width / invisible characters that web-paste
+ *      smuggles in: ZWSP (U+200B), ZWNJ (U+200C), ZWJ (U+200D),
+ *      BOM / ZWNBSP (U+FEFF). They're invisible, break LLM
+ *      tokenisation, and the user never meant to type them.
+ *
+ * **What we DO NOT touch (and why):**
+ *
+ *   - **Internal whitespace runs** (3+ spaces, tabs, blank lines).
+ *     Code indentation depends on these. ChatGPT preserves them as
+ *     typed — "  if (x):\n    return" stays four-space-indented.
+ *     Collapsing them is the path to subtly broken code snippets.
+ *
+ *   - **Bidi override marks** (U+200E LRM, U+200F RLM, U+202A..U+202E).
+ *     Legitimately used in Arabic / Hebrew / mixed-direction text.
+ *     Stripping silently breaks RTL users. If a specific deployment
+ *     wants to block them as a security measure, do it at that layer
+ *     with explicit user-visible feedback.
+ *
+ *   - **Tabs vs spaces** beyond rule 1. Could be either code or
+ *     prose; without parsing markdown we can't tell.
+ *
+ *   - **Emoji, mentions, URLs, code spans** — passthrough text.
+ *
+ * The function is intentionally tiny — every rule earns its keep
+ * with a concrete "user pasted X from Y, got nonsense" story.
+ *
+ * **Idempotent**: `sanitizeDraft(sanitizeDraft(x)) === sanitizeDraft(x)`.
+ */
+declare function sanitizeDraft(input: string): string;
+/**
+ * Convenience predicate: true when the draft is non-empty AFTER
+ * sanitation. Use to gate Send buttons / Enter submits so an empty
+ * or whitespace-only draft never produces a real message.
+ *
+ * Cheaper than sanitizeDraft(input).length > 0 only marginally —
+ * we still allocate the cleaned string. Kept as a named helper for
+ * call-site clarity.
+ */
+declare function isSubmittableDraft(input: string): boolean;
+
+/** Walk the conversation and collect image attachments in chronological order. */
+declare function collectImageAttachments(messages: ChatMessage[]): ChatAttachment[];
+
 /**
  * Chat color tokens — single source of truth.
  *
@@ -3511,122 +3390,27 @@ interface ChatBubbleStyles {
  */
 declare function useChatBubbleStyles(role: 'user' | 'assistant' | 'system', isError: boolean): ChatBubbleStyles;
 interface ChatRoleStyles {
-    anchor: string;
-    toggle: string;
-}
-/**
- * Lightweight variant when only role matters (no error state, no surface).
- * Use in shared markdown renderers that don't know about bubble background.
- */
-declare function useChatRoleStyles(isUser: boolean): ChatRoleStyles;
-interface ChatDestructiveStyles {
-    banner: string;
-    hover: string;
-    hoverStrong: string;
-    text: string;
-    menuItem: string;
-    toolErrorText: string;
-}
-/**
- * Destructive (delete / error) class facade. Hook form keeps the API
- * symmetric with the others; under the hood it returns a frozen object.
- */
-declare function useChatDestructiveStyles(): ChatDestructiveStyles;
-
-/** Walk the conversation and collect image attachments in chronological order. */
-declare function collectImageAttachments(messages: ChatMessage[]): ChatAttachment[];
-
-/**
- * sanitizeDraft — minimal pre-submit cleanup for chat-composer drafts.
- *
- * Mirrors the conservative behaviour ChatGPT / Claude / Telegram
- * actually ship: clean the obvious junk the user didn't intend to
- * send, touch nothing that *could* be intentional.
- *
- * **What we DO touch:**
- *
- *   1. Trim leading/trailing whitespace (spaces, tabs, newlines,
- *      NBSP). The user typing `\n\n   hello   \n` meant `hello`.
- *   2. Normalise line endings — `\r\n` / `\r` → `\n`. Pasted Windows
- *      / old-mac text gets the same internal shape, so the LLM
- *      tokeniser and markdown renderer see one canonical form.
- *   3. Strip zero-width / invisible characters that web-paste
- *      smuggles in: ZWSP (U+200B), ZWNJ (U+200C), ZWJ (U+200D),
- *      BOM / ZWNBSP (U+FEFF). They're invisible, break LLM
- *      tokenisation, and the user never meant to type them.
- *
- * **What we DO NOT touch (and why):**
- *
- *   - **Internal whitespace runs** (3+ spaces, tabs, blank lines).
- *     Code indentation depends on these. ChatGPT preserves them as
- *     typed — "  if (x):\n    return" stays four-space-indented.
- *     Collapsing them is the path to subtly broken code snippets.
- *
- *   - **Bidi override marks** (U+200E LRM, U+200F RLM, U+202A..U+202E).
- *     Legitimately used in Arabic / Hebrew / mixed-direction text.
- *     Stripping silently breaks RTL users. If a specific deployment
- *     wants to block them as a security measure, do it at that layer
- *     with explicit user-visible feedback.
- *
- *   - **Tabs vs spaces** beyond rule 1. Could be either code or
- *     prose; without parsing markdown we can't tell.
- *
- *   - **Emoji, mentions, URLs, code spans** — passthrough text.
- *
- * The function is intentionally tiny — every rule earns its keep
- * with a concrete "user pasted X from Y, got nonsense" story.
- *
- * **Idempotent**: `sanitizeDraft(sanitizeDraft(x)) === sanitizeDraft(x)`.
- */
-declare function sanitizeDraft(input: string): string;
-/**
- * Convenience predicate: true when the draft is non-empty AFTER
- * sanitation. Use to gate Send buttons / Enter submits so an empty
- * or whitespace-only draft never produces a real message.
- *
- * Cheaper than sanitizeDraft(input).length > 0 only marginally —
- * we still allocate the cleaned string. Kept as a named helper for
- * call-site clarity.
- */
-declare function isSubmittableDraft(input: string): boolean;
-
-/**
- * Chat dev logger.
- *
- * A thin namespaced wrapper over `consola` that no-ops in production unless
- * the host app explicitly opts in via `<ChatRoot debug />`. The default
- * detection uses `isDev` from `@djangocfg/ui-core/lib/env` (NODE_ENV).
- *
- * Why a dedicated module: chat is async and event-heavy (bootstrap, transport,
- * SSE chunks, tool calls, regenerate, …). Inline `console.log`s rot fast and
- * leak into prod. A single `getChatLogger()` call gives every layer the same
- * namespaced sub-logger and keeps zero-cost gating in one place.
- *
- * Sub-loggers:
- *   bootstrap  — initial session bootstrap (createSession / loadHistory)
- *   transport  — outbound transport calls + responses
- *   stream     — SSE chunk / tool / message_end events
- *   lifecycle  — sendMessage, regenerate, newSession, edits
- *   tools      — tool_call_start / _delta / _end specifics
- *   error      — caught errors (always emitted as `error` level)
+    anchor: string;
+    toggle: string;
+}
+/**
+ * Lightweight variant when only role matters (no error state, no surface).
+ * Use in shared markdown renderers that don't know about bubble background.
  */
-
-type ChatLogScope = 'bootstrap' | 'transport' | 'stream' | 'lifecycle' | 'tools' | 'error';
-interface ChatLogger {
-    bootstrap: ConsolaInstance;
-    transport: ConsolaInstance;
-    stream: ConsolaInstance;
-    lifecycle: ConsolaInstance;
-    tools: ConsolaInstance;
-    error: ConsolaInstance;
-    /** True when this logger is actually emitting (host opted in or NODE_ENV=development). */
-    enabled: boolean;
+declare function useChatRoleStyles(isUser: boolean): ChatRoleStyles;
+interface ChatDestructiveStyles {
+    banner: string;
+    hover: string;
+    hoverStrong: string;
+    text: string;
+    menuItem: string;
+    toolErrorText: string;
 }
 /**
- * Get the chat logger.
- * @param debug Explicit override from the host. `undefined` falls back to `isDev`.
+ * Destructive (delete / error) class facade. Hook form keeps the API
+ * symmetric with the others; under the hood it returns a frozen object.
  */
-declare function getChatLogger(debug?: boolean): ChatLogger;
+declare function useChatDestructiveStyles(): ChatDestructiveStyles;
 
 interface MessageListProps {
     messages?: ChatMessage[];
@@ -3836,6 +3620,203 @@ interface AudioToggleProps {
 }
 declare function AudioToggle({ size, variant, alwaysShow, className, }: AudioToggleProps): react_jsx_runtime.JSX.Element;
 
+declare const LazyChat: react.ComponentType<ChatRootProps>;
+
+/**
+ * Declarative rule for handling a custom URL scheme inside markdown.
+ *
+ * Each rule owns one href shape (e.g. `cmdop://machine/<uuid>`,
+ * `obsidian://open?path=…`) and decides:
+ *
+ *   1. Whether the URL scheme survives sanitize (`protocols`).
+ *   2. How to massage the source markdown before render
+ *      (`preprocess` — optional; useful for stripping decorative
+ *      prefixes like the `@` in `@[label](href)` so the chip alone
+ *      reads as the mention indicator).
+ *   3. Which links it owns (`match`), and how to render them
+ *      (`render`, returning JSX).
+ *
+ * Rules compose: pass an array, and the renderer iterates top-to-bottom
+ * picking the first `match` hit per `<a>`. Anything no rule claims
+ * falls through to the built-in chat-link styling (or to a custom
+ * `customComponents.a` if both are provided).
+ *
+ * Prefer `linkRules` over `customComponents` + `extraHrefProtocols` —
+ * it's the same pieces with the boilerplate removed.
+ */
+interface LinkRule {
+    /** Pre-process the raw markdown source before any rendering happens.
+     *  Pure / synchronous; identity-return when no transform applies. */
+    preprocess?: (source: string) => string;
+    /** Predicate against the resolved href. */
+    match: (href: string) => boolean;
+    /** Render the link this rule owns. `children` is the link's label
+     *  (markdown-rendered React content). */
+    render: (props: {
+        href: string;
+        children: react__default.ReactNode;
+        isUser: boolean;
+    }) => react__default.ReactNode;
+    /** URL scheme(s) to whitelist on the sanitize side, e.g. `['cmdop']`.
+     *  Bare schemes only — no `://`. Optional; omit for `http(s)` rules. */
+    protocols?: readonly string[];
+    /** Diagnostic label, surfaced in dev warnings. Optional. */
+    name?: string;
+}
+interface MarkdownMessageProps {
+    /** Markdown content to render */
+    content: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Whether the message is from the user (affects styling) */
+    isUser?: boolean;
+    /** Use compact size (text-xs instead of text-sm) */
+    isCompact?: boolean;
+    /**
+     * Force the plain-text rendering path (single `<div>` with
+     * `white-space: pre-wrap`, no ReactMarkdown). Use this for
+     * user-authored content where markdown shouldn't be parsed.
+     *
+     * When `undefined` (default) we run a small heuristic
+     * (`looksLikePlainProse`): short single-paragraph text without
+     * markdown markers → plain; everything else → ReactMarkdown.
+     *
+     * Pass an explicit `true` / `false` to opt out of the heuristic
+     * entirely.
+     */
+    plainText?: boolean;
+    /**
+     * Per-tag overrides merged on top of the built-in renderers.
+     *
+     * Use this when you need custom rendering for a specific tag without
+     * losing the chat-tuned defaults (links, code blocks with copy, etc).
+     *
+     * For custom URL-scheme link handling, prefer `linkRules` — it's the
+     * same ergonomics with the per-consumer boilerplate removed.
+     */
+    customComponents?: Partial<Components>;
+    /**
+     * Extra URL protocols allowed in `<a href>` after sanitize.
+     *
+     * The default schema strips anything that isn't
+     * `http(s)/mailto/xmpp/irc(s)` — your custom renderer would receive
+     * `href={undefined}` for `cmdop://…` / `obsidian://…` etc. Listing
+     * the bare scheme here (e.g. `'cmdop'`, NOT `'cmdop://'`) opts it in.
+     *
+     * Use carefully: every protocol you add increases what the rendered
+     * HTML can do via clicks. Stick to schemes you control.
+     */
+    extraHrefProtocols?: readonly string[];
+    /**
+     * Declarative link rules — preferred over `customComponents` +
+     * `extraHrefProtocols` for chat-style apps that want pluggable
+     * URL-scheme handling without re-implementing the custom-`a`
+     * boilerplate per consumer.
+     *
+     * If you provide both `linkRules` and `extraHrefProtocols`, the
+     * effective protocol list is the union of the two.
+     */
+    linkRules?: readonly LinkRule[];
+    /**
+     * Enable collapsible "Read more..." functionality
+     * @default false
+     */
+    collapsible?: boolean;
+    /** Maximum character length before showing "Read more...". */
+    maxLength?: number;
+    /** Maximum number of lines before showing "Read more...". */
+    maxLines?: number;
+    /** Custom "Read more" button text. @default "Read more..." */
+    readMoreLabel?: string;
+    /** Custom "Show less" button text. @default "Show less" */
+    showLessLabel?: string;
+    /** Start expanded (only when `collapsible` is true). @default false */
+    defaultExpanded?: boolean;
+    /** Callback when collapsed state changes */
+    onCollapseChange?: (isCollapsed: boolean) => void;
+}
+
+/**
+ * MarkdownMessage — chat-tuned markdown renderer.
+ *
+ * Features:
+ * - GitHub Flavored Markdown (GFM) via remark-gfm
+ * - Syntax-highlighted code blocks with Copy button
+ * - Mermaid diagram rendering (` ```mermaid ` fence)
+ * - Tables, lists, blockquotes scaled for chat density
+ * - User vs assistant styling modes (`isUser`)
+ * - Plain-text fast path: skips ReactMarkdown when content has no
+ *   markdown syntax (cheaper render, preserves newlines via CSS)
+ * - Optional collapsible "Read more..." for long messages
+ *
+ * Custom URL schemes (chat mentions, deep-links, custom file viewers)
+ * are best handled with the declarative `linkRules` prop — see the
+ * type definition in `./types.ts` and the storybook for examples.
+ *
+ * @example
+ * ```tsx
+ * <MarkdownMessage content="# Hello\n\nThis is **bold** text." />
+ *
+ * // User message styling
+ * <MarkdownMessage content="Some content" isUser />
+ *
+ * // Custom URL scheme via linkRules
+ * <MarkdownMessage
+ *   content="Talk to [Vps-audi](cmdop://machine/abc-123)"
+ *   linkRules={[machineMentionRule]}
+ * />
+ * ```
+ *
+ * Memoised: re-renders only when props change. `content` is the main
+ * trigger — all other props (className, isUser, isCompact, etc.) are
+ * compared by value/reference. `onCollapseChange` is compared by
+ * reference — callers should stabilise it with useCallback.
+ */
+declare function MarkdownMessageRaw({ content, className, isUser, isCompact, plainText, customComponents, extraHrefProtocols, linkRules, collapsible, maxLength, maxLines, readMoreLabel, showLessLabel, defaultExpanded, onCollapseChange, }: MarkdownMessageProps): react_jsx_runtime.JSX.Element;
+declare const MarkdownMessage: react__default.MemoExoticComponent<typeof MarkdownMessageRaw>;
+
+/** Recursively concatenate the text content of a React.ReactNode tree.
+ *  Used by the markdown renderers (e.g. `<pre>` extracting code) and
+ *  by consumers that need a plain-string label out of link children. */
+declare function extractTextFromChildren(children: react__default.ReactNode): string;
+
+interface ActionRowProps {
+    /** Raw text to copy — pass the same source string used for render. */
+    value: string;
+    /** Bubble side. Just controls flex alignment; nothing is mirrored. */
+    isUser: boolean;
+    /**
+     * Whether the row is currently shown. Owner-controlled (typically
+     * `<ChatMessageRow>` toggles this on hover with a small close delay).
+     * The component is intentionally dumb about visibility — owners
+     * have full control over reveal logic (hover, focus, always-on,
+     * touch behaviour, etc.).
+     */
+    visible: boolean;
+}
+declare function ActionRowRaw({ value, isUser, visible }: ActionRowProps): react_jsx_runtime.JSX.Element;
+declare const ActionRow: react__default.MemoExoticComponent<typeof ActionRowRaw>;
+
+interface ChatMessageRowProps {
+    /** Side of the conversation — drives flex alignment and `isUser`
+     *  passed to `actions`. */
+    isUser: boolean;
+    /** The bubble (your own JSX). Anything goes — `<MarkdownMessage>`,
+     *  custom card, multi-element composition. */
+    children: react__default.ReactNode;
+    /** Render-prop for the action row. Receives `visible` so the row
+     *  knows when to fade in/out. Render `null` to opt out. */
+    actions?: (visible: boolean, isUser: boolean) => react__default.ReactNode;
+    /** Close delay in ms after the cursor leaves the row. Long enough
+     *  to bridge cursor travel from bubble → action button without
+     *  flicker. Default 250ms (Radix Tooltip-ish). */
+    closeDelayMs?: number;
+    /** Optional class on the column container. */
+    className?: string;
+}
+declare function ChatMessageRowRaw({ isUser, children, actions, closeDelayMs, className, }: ChatMessageRowProps): react_jsx_runtime.JSX.Element;
+declare const ChatMessageRow: react__default.MemoExoticComponent<typeof ChatMessageRowRaw>;
+
 /**
  * PrettyCode Component - Dynamic Import Wrapper
  *
@@ -4889,4 +4870,60 @@ declare function useBlobUrlCleanup(key: string | null): void;
  */
 declare function generateContentKey(content: ArrayBuffer): string;
 
-export { ANCHOR, type ApiKey, ArrayFieldItemTemplate, ArrayFieldTemplate, type AspectRatioValue, type AttachmentRenderer, type AttachmentRendererArgs, type AttachmentRendererMap, Attachments, AttachmentsGrid, type AttachmentsGridProps, AttachmentsList, type AttachmentsListProps, type AttachmentsProps, Player as AudioPlayer, type PlayerProps as AudioPlayerProps, AudioToggle, type AudioToggleProps, BUBBLE_SURFACE, BaseInputTemplate, type BlobSource, CHAT_EVENT_NAME, CSS_VARS, CardLoadingFallback, type ChatAction, type ChatAssistantContext, type ChatAttachment, type ChatAudioConfig, type ChatAudioEvent, type ChatAudioSounds, type ChatBubbleStyles, type ChatBubbleSurface, type ChatConfig, type ChatContextValue, type ChatDestructiveStyles, type ChatDisplayMode, ChatDock, type ChatDockMode, type ChatDockPrefs, type ChatDockProps, type ChatDockSide, type ChatEventDetail, ChatFAB, type ChatFABPosition, type ChatFABProps, type ChatFABSize, type ChatFABVariant, ChatGreeting, type ChatGreetingProps, ChatHeader, ChatHeaderActionButton, type ChatHeaderActionButtonProps, ChatHeaderAudioToggle, type ChatHeaderAudioToggleProps, ChatHeaderLanguageButton, type ChatHeaderLanguageButtonProps, ChatHeaderModeToggle, type ChatHeaderModeToggleProps, type ChatHeaderProps, ChatHeaderResetButton, type ChatHeaderResetButtonProps, type ChatLabels, ChatLauncher, type ChatLauncherGreeting, type ChatLauncherHotkey, type ChatLauncherProps, type ChatLightboxState, type ChatLogScope, type ChatLogger, type ChatMessage, type ChatPersona, type ChatPrefs, type ChatPresencePhase, ChatProvider, type ChatProviderProps, type ChatRole, type ChatRoleStyles, ChatRoot, type ChatRootProps, type ChatSource, type ChatState, type ChatStreamEvent, type ChatToolCall, type ChatTransport, ChatUnreadPreview, type ChatUnreadPreviewProps, type ChatUserContext, CheckboxWidget, ColorWidget, Composer, type ComposerProps, type CreateLazyComponentOptions, type CreateSessionOptions, type CreateVideoErrorFallbackOptions, CronScheduler, type CronSchedulerContextValue, type CronSchedulerProps, CronSchedulerProvider, type CronSchedulerState, CustomInput, type DASHSource, DEFAULT_CHAT_SOUNDS, DEFAULT_DOCK_PREFS, DEFAULT_LABELS, DEFAULT_SIDEBAR, DEFAULT_Z_INDEX, DESTRUCTIVE_SURFACE, type DataUrlSource, DayChips, DiffEditor, type DiffEditorProps, type DisabledWhenRule, Editor, type EditorContextValue, type EditorFile, type EditorOptions, type EditorProps, EditorProvider, type EditorRef, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ErrorFallbackProps, ErrorListTemplate, FieldTemplate, type Focusable, type HLSSource, HOTKEYS, type HistoryPage, type HttpTransportConfig, type ImageFile, ImageViewer, type ImageViewerProps, type JsonFormContext, type JsonFormDensity, JsonSchemaForm, type JsonSchemaFormProps, JsonTreeComponent as JsonTree, type JsonTreeConfig, type JsonTreeProps, JumpToLatest, type JumpToLatestProps, LIMITS, LazyPlayer as LazyAudioPlayer, LazyChat, type ChatRootProps as LazyChatProps, LazyCronScheduler, LazyImageViewer, LazyJsonSchemaForm, LazyJsonTree, LazyLottiePlayer, LazyMapContainer, LazyMapView, LazyMermaid, LazyOpenapiViewer, LazyPrettyCode, LazyTree, TreeRootProps as LazyTreeProps, LazyVideoPlayer, LazyWrapper, type LazyWrapperProps, type LinkRule, LoadingFallback, type LoadingFallbackProps, type LottieDirection, LottiePlayer, type LottiePlayerProps, type LottieSize, type LottieSpeed, type MapContainerProps, MapLoadingFallback, type MapStyleKey, type MapViewport, MarkdownEditor, type MarkdownEditorProps, MarkdownMessage, type MarkdownMessageProps, type MarkerData, type MentionAttrs, type MentionConfig, type MentionItem, type MentionMarkdownRenderer, Mermaid, type MermaidProps, MessageActions, type MessageActionsProps, MessageBubble, type MessageBubbleProps, MessageList, type MessageListHandle, type MessageListProps, type MockTransportOptions, type MonthDay, MonthDayGrid, NativeProvider, NumberWidget, ObjectFieldTemplate, Playground as OpenapiViewer, type ParseSSEOptions, type PlayerMode, type PlaygroundConfig, type PlaygroundProps$1 as PlaygroundProps, PrettyCode, type PrettyCodeProps$1 as PrettyCodeProps, type PydanticAIChatTransportOpts, type PydanticAIEvent, type ResolveFileSourceOptions, STORAGE_KEYS, SchedulePreview, type ScheduleType, ScheduleTypeSelector, type SchemaSource, SelectWidget, type SendOptions, type SessionInfo, type SimpleStreamSource, SliderWidget, Sources, type SourcesProps, Spinner, type StreamOptions, StreamProvider, type StreamSource, StreamingIndicator, type StreamingIndicatorProps, SwitchWidget, TOGGLE, TOOL_CALL, TextWidget, TimeSelector, type TokenBuffer, ToolCalls, type ToolCallsProps, type ToolIdQueue, type ToolPayloadFallback, type ToolPayloadKind, type ToolPayloadMatcher, TransportError, TreeRootProps, type UiGroup, type UrlSource, type UseAutoFocusOnStreamEndOptions, type UseChatAudioReturn, type UseChatComposerOptions, type UseChatComposerReturn, type UseChatConfig, type UseChatDockPrefsOptions, type UseChatDockPrefsReturn, type UseChatHistoryOptions, type UseChatLayoutConfig, type UseChatLayoutReturn, type UseChatLightboxReturn, type UseChatResetOptions, type UseChatResetReturn, type UseChatReturn, type UseChatScrollOptions, type UseChatScrollReturn, type UseChatUnreadOptions, type UseChatUnreadReturn, type UseCollapsibleContentOptions, type UseCollapsibleContentResult, type UseEditorReturn, type UseFocusOnEmptyClickOptions, type UseLottieOptions, type UseLottieReturn, type UseMonacoReturn, type UseVisitorFingerprintOptions, VideoControls, VideoErrorFallback, type VideoErrorFallbackProps, VideoPlayer, type VideoPlayerContextValue, type VideoPlayerProps, VideoPlayerProvider, type VideoPlayerProviderProps, type VideoPlayerRef, type VideoSourceUnion, VidstackProvider, type VimeoSource, type WeekDay, type YouTubeSource, buildCron, collectImageAttachments, createHttpTransport, createId, createLazyComponent, createMockTransport, createPydanticAIChatTransport, createPydanticAISSEMap, createTokenBuffer, createToolIdQueue, createVideoErrorFallback, deriveInitials, dispatchToolPayload, evaluateDisabledWhen, extractTextFromChildren, generateContentKey, getChatLogger, getRequiredFields, hasRequiredFields, humanizeCron, initialState, isGeoJSONFeatureCollection, isLatLng, isPlainObject, isSimpleStreamSource, isStringValue, isSubmittableDraft, isValidCron, mapPydanticAIEvent, mentionPresets, mergeDefaults, normalizeFormData, parseCron, parseSSE, reducer, resolveFileSource, resolvePersona, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, sanitizeDraft, useAudioCache, useAutoFocusOnStreamEnd, useBlobUrlCleanup, useChat, useChatAudio, useChatAudioPrefs, useChatBubbleStyles, useChatComposer, useChatContext, useChatContextOptional, useChatDestructiveStyles, useChatDockPrefs, useChatHistory, useChatLayout, useChatLightbox, useChatPresence, useChatReset, useChatRoleStyles, useChatScroll, useChatUnread, useCollapsibleContent, useCronCustom, useCronMonthDays, useCronPreview, useCronScheduler, useCronSchedulerContext, useCronTime, useCronType, useCronWeekDays, useEditor, useEditorContext, useFocusOnEmptyClick, useImageCache, useLanguage, useLottie, useMediaCacheStore, useMonaco, useRegisterComposer, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, useVisitorFingerprint, validateRequiredFields, validateSchema };
+interface UseCollapsibleContentOptions {
+    /**
+     * Maximum character length before collapsing
+     * If both maxLength and maxLines are set, the stricter limit applies
+     */
+    maxLength?: number;
+    /**
+     * Maximum number of lines before collapsing
+     * If both maxLength and maxLines are set, the stricter limit applies
+     */
+    maxLines?: number;
+    /**
+     * Start in expanded state (default: false - starts collapsed)
+     */
+    defaultExpanded?: boolean;
+}
+interface UseCollapsibleContentResult {
+    /** Whether content is currently collapsed */
+    isCollapsed: boolean;
+    /** Toggle between collapsed/expanded state */
+    toggleCollapsed: () => void;
+    /** Set collapsed state directly */
+    setCollapsed: (collapsed: boolean) => void;
+    /** Content to display (truncated if collapsed, full if expanded) */
+    displayContent: string;
+    /** Whether the content exceeds limits and should be collapsible */
+    shouldCollapse: boolean;
+    /** Original content length */
+    originalLength: number;
+    /** Original line count */
+    originalLineCount: number;
+}
+/**
+ * Hook for managing collapsible content with "Read more..." functionality
+ *
+ * @example
+ * ```tsx
+ * const { isCollapsed, toggleCollapsed, displayContent, shouldCollapse } = useCollapsibleContent(
+ *   longText,
+ *   { maxLength: 300, maxLines: 5 }
+ * );
+ *
+ * return (
+ *   <div>
+ *     <Markdown content={displayContent} />
+ *     {shouldCollapse && (
+ *       <button onClick={toggleCollapsed}>
+ *         {isCollapsed ? 'Read more...' : 'Show less'}
+ *       </button>
+ *     )}
+ *   </div>
+ * );
+ * ```
+ */
+declare function useCollapsibleContent(content: string, options?: UseCollapsibleContentOptions): UseCollapsibleContentResult;
+
+export { ANCHOR, ActionRow, type ApiKey, ArrayFieldItemTemplate, ArrayFieldTemplate, type AspectRatioValue, type AttachmentRenderer, type AttachmentRendererArgs, type AttachmentRendererMap, Attachments, AttachmentsGrid, type AttachmentsGridProps, AttachmentsList, type AttachmentsListProps, type AttachmentsProps, Player as AudioPlayer, type PlayerProps as AudioPlayerProps, AudioToggle, type AudioToggleProps, BUBBLE_SURFACE, BaseInputTemplate, type BlobSource, CHAT_EVENT_NAME, CSS_VARS, CardLoadingFallback, type ChatAction, type ChatAssistantContext, type ChatAttachment, type ChatAudioConfig, type ChatAudioEvent, type ChatAudioSounds, type ChatBubbleStyles, type ChatBubbleSurface, type ChatConfig, type ChatContextValue, type ChatDestructiveStyles, type ChatDisplayMode, ChatDock, type ChatDockMode, type ChatDockPrefs, type ChatDockProps, type ChatDockSide, type ChatEventDetail, ChatFAB, type ChatFABPosition, type ChatFABProps, type ChatFABSize, type ChatFABVariant, ChatGreeting, type ChatGreetingProps, ChatHeader, ChatHeaderActionButton, type ChatHeaderActionButtonProps, ChatHeaderAudioToggle, type ChatHeaderAudioToggleProps, ChatHeaderLanguageButton, type ChatHeaderLanguageButtonProps, ChatHeaderModeToggle, type ChatHeaderModeToggleProps, type ChatHeaderProps, ChatHeaderResetButton, type ChatHeaderResetButtonProps, type ChatLabels, ChatLauncher, type ChatLauncherGreeting, type ChatLauncherHotkey, type ChatLauncherProps, type ChatLightboxState, type ChatLogScope, type ChatLogger, type ChatMessage, ChatMessageRow, type ChatPersona, type ChatPrefs, type ChatPresencePhase, ChatProvider, type ChatProviderProps, type ChatRole, type ChatRoleStyles, ChatRoot, type ChatRootProps, type ChatSource, type ChatState, type ChatStreamEvent, type ChatToolCall, type ChatTransport, ChatUnreadPreview, type ChatUnreadPreviewProps, type ChatUserContext, CheckboxWidget, ColorWidget, Composer, type ComposerProps, type CreateLazyComponentOptions, type CreateSessionOptions, type CreateVideoErrorFallbackOptions, CronScheduler, type CronSchedulerContextValue, type CronSchedulerProps, CronSchedulerProvider, type CronSchedulerState, CustomInput, type DASHSource, DEFAULT_CHAT_SOUNDS, DEFAULT_DOCK_PREFS, DEFAULT_LABELS, DEFAULT_SIDEBAR, DEFAULT_Z_INDEX, DESTRUCTIVE_SURFACE, type DataUrlSource, DayChips, DiffEditor, type DiffEditorProps, type DisabledWhenRule, Editor, type EditorContextValue, type EditorFile, type EditorOptions, type EditorProps, EditorProvider, type EditorRef, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ErrorFallbackProps, ErrorListTemplate, FieldTemplate, type Focusable, type HLSSource, HOTKEYS, type HistoryPage, type HttpTransportConfig, type ImageFile, ImageViewer, type ImageViewerProps, type JsonFormContext, type JsonFormDensity, JsonSchemaForm, type JsonSchemaFormProps, JsonTreeComponent as JsonTree, type JsonTreeConfig, type JsonTreeProps, JumpToLatest, type JumpToLatestProps, LIMITS, LazyPlayer as LazyAudioPlayer, LazyChat, type ChatRootProps as LazyChatProps, LazyCronScheduler, LazyImageViewer, LazyJsonSchemaForm, LazyJsonTree, LazyLottiePlayer, LazyMapContainer, LazyMapView, LazyMermaid, LazyOpenapiViewer, LazyPrettyCode, LazyTree, TreeRootProps as LazyTreeProps, LazyVideoPlayer, LazyWrapper, type LazyWrapperProps, type LinkRule, LoadingFallback, type LoadingFallbackProps, type LottieDirection, LottiePlayer, type LottiePlayerProps, type LottieSize, type LottieSpeed, type MapContainerProps, MapLoadingFallback, type MapStyleKey, type MapViewport, MarkdownEditor, type MarkdownEditorProps, MarkdownMessage, MarkdownMessage as MarkdownMessageDefault, type MarkdownMessageProps, type MarkerData, type MentionAttrs, type MentionConfig, type MentionItem, type MentionMarkdownRenderer, Mermaid, type MermaidProps, MessageActions, type MessageActionsProps, MessageBubble, type MessageBubbleProps, MessageList, type MessageListHandle, type MessageListProps, type MockTransportOptions, type MonthDay, MonthDayGrid, NativeProvider, NumberWidget, ObjectFieldTemplate, Playground as OpenapiViewer, type ParseSSEOptions, type PlayerMode, type PlaygroundConfig, type PlaygroundProps$1 as PlaygroundProps, PrettyCode, type PrettyCodeProps$1 as PrettyCodeProps, type PydanticAIChatTransportOpts, type PydanticAIEvent, type ResolveFileSourceOptions, STORAGE_KEYS, SchedulePreview, type ScheduleType, ScheduleTypeSelector, type SchemaSource, SelectWidget, type SendOptions, type SessionInfo, type SimpleStreamSource, SliderWidget, Sources, type SourcesProps, Spinner, type StreamOptions, StreamProvider, type StreamSource, StreamingIndicator, type StreamingIndicatorProps, SwitchWidget, TOGGLE, TOOL_CALL, TextWidget, TimeSelector, type TokenBuffer, ToolCalls, type ToolCallsProps, type ToolIdQueue, type ToolPayloadFallback, type ToolPayloadKind, type ToolPayloadMatcher, TransportError, TreeRootProps, type UiGroup, type UrlSource, type UseAutoFocusOnStreamEndOptions, type UseChatAudioReturn, type UseChatComposerOptions, type UseChatComposerReturn, type UseChatConfig, type UseChatDockPrefsOptions, type UseChatDockPrefsReturn, type UseChatHistoryOptions, type UseChatLayoutConfig, type UseChatLayoutReturn, type UseChatLightboxReturn, type UseChatResetOptions, type UseChatResetReturn, type UseChatReturn, type UseChatScrollOptions, type UseChatScrollReturn, type UseChatUnreadOptions, type UseChatUnreadReturn, type UseCollapsibleContentOptions, type UseCollapsibleContentResult, type UseEditorReturn, type UseFocusOnEmptyClickOptions, type UseLottieOptions, type UseLottieReturn, type UseMonacoReturn, type UseVisitorFingerprintOptions, VideoControls, VideoErrorFallback, type VideoErrorFallbackProps, VideoPlayer, type VideoPlayerContextValue, type VideoPlayerProps, VideoPlayerProvider, type VideoPlayerProviderProps, type VideoPlayerRef, type VideoSourceUnion, VidstackProvider, type VimeoSource, type WeekDay, type YouTubeSource, buildCron, collectImageAttachments, createHttpTransport, createId, createLazyComponent, createMockTransport, createPydanticAIChatTransport, createPydanticAISSEMap, createTokenBuffer, createToolIdQueue, createVideoErrorFallback, deriveInitials, dispatchToolPayload, evaluateDisabledWhen, extractTextFromChildren, generateContentKey, getChatLogger, getRequiredFields, hasRequiredFields, humanizeCron, initialState, isGeoJSONFeatureCollection, isLatLng, isPlainObject, isSimpleStreamSource, isStringValue, isSubmittableDraft, isValidCron, mapPydanticAIEvent, mentionPresets, mergeDefaults, normalizeFormData, parseCron, parseSSE, reducer, resolveFileSource, resolvePersona, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, sanitizeDraft, useAudioCache, useAutoFocusOnStreamEnd, useBlobUrlCleanup, useChat, useChatAudio, useChatAudioPrefs, useChatBubbleStyles, useChatComposer, useChatContext, useChatContextOptional, useChatDestructiveStyles, useChatDockPrefs, useChatHistory, useChatLayout, useChatLightbox, useChatPresence, useChatReset, useChatRoleStyles, useChatScroll, useChatUnread, useCollapsibleContent, useCronCustom, useCronMonthDays, useCronPreview, useCronScheduler, useCronSchedulerContext, useCronTime, useCronType, useCronWeekDays, useEditor, useEditorContext, useFocusOnEmptyClick, useImageCache, useLanguage, useLottie, useMediaCacheStore, useMonaco, useRegisterComposer, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, useVisitorFingerprint, validateRequiredFields, validateSchema };