@lostgradient/cinder 0.1.0

package/dist/components/chat/container/use-chat-keyboard-nav.svelte.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Runes helper for chat keyboard navigation.
+ *
+ * Extracts keyboard event handling for:
+ * - Home/End to jump to first/last message
+ * - PageUp/PageDown for viewport scrolling
+ * - Arrow keys for message-to-message navigation
+ */
+/** Options for the keyboard navigation helper */
+export interface UseChatKeyboardNavOptions {
+    /** Callback when jump-to-latest is triggered (End key) */
+    onJumpToLatest: () => void;
+    /** Function that returns the appropriate scroll behavior based on user preference */
+    getScrollBehavior: () => ScrollBehavior;
+}
+/** Return type for the keyboard navigation helper */
+export interface UseChatKeyboardNavReturn {
+    /**
+     * Handle keydown events for the chat container.
+     * Should be attached to the container's onkeydown event.
+     */
+    handleKeyDown(event: KeyboardEvent, viewport: HTMLElement | null): void;
+}
+/**
+ * Creates keyboard navigation handlers for the chat container.
+ *
+ * Supports:
+ * - `End`: Jump to latest message
+ * - `Home`: Scroll to top and focus first message
+ * - `PageDown`/`PageUp`: Scroll by 90% of viewport
+ * - `ArrowDown`/`ArrowUp`: Navigate between messages when focused on a message
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useChatKeyboardNav } from './use-chat-keyboard-nav.svelte';
+ *
+ *   const keyboardNav = useChatKeyboardNav({
+ *     onJumpToLatest: handleJumpToLatest,
+ *     getScrollBehavior: () => prefersReducedMotion() ? 'auto' : 'smooth',
+ *   });
+ * </script>
+ *
+ * <div onkeydown={(e) => keyboardNav.handleKeyDown(e, viewport)}>
+ *   <!-- chat content -->
+ * </div>
+ * ```
+ */
+export declare function useChatKeyboardNav(options: UseChatKeyboardNavOptions): UseChatKeyboardNavReturn;

package/dist/components/chat/container/use-chat-message-groups.svelte.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Runes helper for chat message grouping and tool call pairing.
+ *
+ * Extracts derived values for:
+ * - Messages grouped with date separators
+ * - Tool call pairs indexed by call ID for O(1) lookup
+ */
+import type { Message, ToolCallPair } from '../conversation-model.ts';
+/** Date separator item in the message list */
+export type DateItem = {
+    type: 'date';
+    date: Date;
+};
+/** Message item in the message list */
+export type MessageItem = {
+    type: 'message';
+    message: Message;
+};
+/** Union type for items in the messages-with-dates list */
+export type MessageWithDateItem = DateItem | MessageItem;
+export type { ToolCallPair } from '../conversation-model.ts';
+/** Options for the message groups helper */
+export interface UseChatMessageGroupsOptions {
+    /** Function that returns the current messages array */
+    getMessages: () => Message[];
+}
+/** Return type for the message groups helper */
+export interface UseChatMessageGroupsReturn {
+    /** Messages interleaved with date separators */
+    readonly messagesWithDates: MessageWithDateItem[];
+    /** Map of tool call ID to tool call pairs for O(1) lookup */
+    readonly toolCallPairsByCallId: Map<string, ToolCallPair[]>;
+    /** Tool result message IDs already represented inside a paired tool call group */
+    readonly pairedToolResultIds: Set<string>;
+}
+/** Find result message IDs that are already represented by paired tool-call messages. */
+export declare function findPairedToolResultIds(messages: readonly Message[]): Set<string>;
+/** Build visible messages with date separators, skipping paired tool-result messages. */
+export declare function buildMessagesWithDateSeparators(messages: readonly Message[], pairedToolResultIds: ReadonlySet<string>): MessageWithDateItem[];
+/**
+ * Creates reactive derived values for message grouping and tool call pairing.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useChatMessageGroups } from './use-chat-message-groups.svelte';
+ *
+ *   const messageGroups = useChatMessageGroups({
+ *     getMessages: () => messages,
+ *   });
+ *
+ *   // Access derived values
+ *   const items = messageGroups.messagesWithDates;
+ *   const pairs = messageGroups.toolCallPairsByCallId.get(callId);
+ * </script>
+ * ```
+ */
+export declare function useChatMessageGroups(options: UseChatMessageGroupsOptions): UseChatMessageGroupsReturn;

package/dist/components/chat/container/use-chat-scroll-state.svelte.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Runes helper for chat scroll state management.
+ *
+ * Manages:
+ * - isAtBottom state for auto-scroll decisions
+ * - showJumpButton state for jump-to-latest visibility
+ * - Scroll event listener attachment
+ * - IntersectionObserver for bottom sentinel
+ * - Imperative scroll methods
+ */
+import type { Attachment } from 'svelte/attachments';
+import type { ChatScrollStateChangeEvent } from './chat-events.ts';
+export type { ChatScrollStateChangeEvent as ScrollStateChangeEvent } from './chat-events.ts';
+/** Options for the scroll state helper */
+export interface UseChatScrollStateOptions {
+    /** Pixels from bottom to consider "at bottom" (default: 150) */
+    bottomThreshold?: number;
+    /** Getter for bottom threshold to avoid stale local references */
+    getBottomThreshold?: () => number;
+    /** Pixels scrolled before showing jump button (default: 200) */
+    jumpThreshold?: number;
+    /** Getter for jump threshold to avoid stale local references */
+    getJumpThreshold?: () => number;
+    /**
+     * Callback when scroll state changes.
+     *
+     * **Important:** Always read values from the event argument, not from bindings.
+     * The callback fires before bindable props are synchronized, so bindings may
+     * contain stale values during the callback.
+     */
+    onScrollStateChange?: (event: ChatScrollStateChangeEvent) => void;
+    /** Callback when scroll reaches bottom (for clearing unread state) */
+    onReachBottom?: () => void;
+}
+/** Return type for the scroll state helper */
+export interface UseChatScrollStateReturn {
+    /** Whether the viewport is at or near the bottom */
+    readonly isAtBottom: boolean;
+    /** Whether the jump-to-latest button should be visible */
+    readonly showJumpButton: boolean;
+    /** Whether user is in a smooth scroll animation (used by parent for auto-scroll logic) */
+    readonly isUserScrolling: boolean;
+    /** Set isAtBottom state directly */
+    setIsAtBottom(value: boolean): void;
+    /** Create a scroll event listener attachment for the viewport */
+    createScrollAttachment(): Attachment<HTMLElement>;
+    /**
+     * Create an IntersectionObserver for the bottom sentinel.
+     * Returns a cleanup function, or undefined if elements are missing.
+     */
+    createSentinelObserver(viewport: HTMLElement | null, sentinel: HTMLElement | null): (() => void) | undefined;
+    /**
+     * IntersectionObserver callback for the bottom sentinel element.
+     * Use with useIntersection for attachment-based wiring:
+     * `{@attach useIntersection(scrollState.handleSentinelEntry, { root: viewport, ... })}`.
+     */
+    handleSentinelEntry(entry: IntersectionObserverEntry): void;
+    /** Scroll to the bottom of the viewport */
+    scrollToBottom(viewport: HTMLElement | null): void;
+    /** Scroll to the top of the viewport */
+    scrollToTop(viewport: HTMLElement | null): void;
+    /**
+     * Jump to the latest message with animation.
+     * Handles smooth scroll and focuses the last message after animation.
+     */
+    jumpToLatest(viewport: HTMLElement | null, onComplete?: () => void): void;
+    /** Get the appropriate scroll behavior based on user preference */
+    getScrollBehavior(): ScrollBehavior;
+    /** Cleanup resources */
+    destroy(): void;
+}
+/**
+ * Creates reactive state and methods for managing chat scroll behavior.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useChatScrollState } from './use-chat-scroll-state.svelte';
+ *
+ *   const scrollState = useChatScrollState({
+ *     bottomThreshold: 150,
+ *     jumpThreshold: 200,
+ *     onScrollStateChange: (event) => console.log('Scroll:', event),
+ *     onReachBottom: () => unreadState.markAllAsRead(),
+ *   });
+ *
+ *   const scrollAttachment = scrollState.createScrollAttachment();
+ *
+ *   // Wire the bottom sentinel with useIntersection via {@attach}. Wrap in $derived so
+ *   // the observer is stable across re-renders (recreated only when root/threshold change).
+ *   const sentinelAttach = $derived(
+ *     useIntersection(scrollState.handleSentinelEntry, {
+ *       root: viewport,
+ *       rootMargin: `0px 0px 150px 0px`,
+ *     }),
+ *   );
+ * </script>
+ *
+ * <div bind:this={viewport} {@attach scrollAttachment}>
+ *   <!-- content -->
+ *   <div {@attach sentinelAttach}></div>
+ * </div>
+ *
+ * {#if scrollState.showJumpButton}
+ *   <button onclick={() => scrollState.jumpToLatest(viewport)}>
+ *     Jump to latest
+ *   </button>
+ * {/if}
+ * ```
+ */
+export declare function useChatScrollState(options?: UseChatScrollStateOptions): UseChatScrollStateReturn;

package/dist/components/chat/container/use-chat-search.svelte.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Runes helper for in-conversation message search.
+ *
+ * Manages:
+ * - Search query state
+ * - Open/closed state for the search bar
+ * - Derived list of matching messages (with their indices)
+ * - Current match index for navigation
+ */
+import type { Message } from '../conversation-model.ts';
+/** A single search result: message and its position in the messages array */
+export interface ChatSearchMatch {
+    /** The matching message */
+    message: Message;
+    /** Index of the message in the full messages array */
+    messageIndex: number;
+}
+/** Options for the search helper */
+export interface UseChatSearchOptions {
+    /** Getter for the current list of messages */
+    getMessages: () => Message[];
+}
+/** Return type for the search helper */
+export interface UseChatSearchReturn {
+    /** Current search query string */
+    readonly query: string;
+    /** Whether the search bar is open */
+    readonly isOpen: boolean;
+    /** All messages that match the current query */
+    readonly matches: ChatSearchMatch[];
+    /** Total number of matches */
+    readonly matchCount: number;
+    /** The currently highlighted match, or null if no matches */
+    readonly currentMatch: ChatSearchMatch | null;
+    /** Zero-based index of the current match within matches */
+    readonly currentMatchIndex: number;
+    /** Open the search bar */
+    open(): void;
+    /** Close the search bar and reset state */
+    close(): void;
+    /** Navigate to the next match (wraps around) */
+    nextMatch(): void;
+    /** Navigate to the previous match (wraps around) */
+    previousMatch(): void;
+    /** Update the search query and reset the current match to 0 */
+    setQuery(value: string): void;
+}
+/**
+ * Creates reactive state and methods for in-conversation search.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useChatSearch } from './use-chat-search.svelte';
+ *
+ *   const searchState = useChatSearch({
+ *     getMessages: () => messages,
+ *   });
+ *
+ *   // Open with Ctrl/Cmd+F
+ *   function handleKeyDown(event: KeyboardEvent) {
+ *     if ((event.ctrlKey || event.metaKey) && event.key === 'f') {
+ *       event.preventDefault();
+ *       searchState.open();
+ *     }
+ *   }
+ * </script>
+ *
+ * {#if searchState.isOpen}
+ *   <ChatSearchBar
+ *     query={searchState.query}
+ *     matchCount={searchState.matchCount}
+ *     currentMatchIndex={searchState.currentMatchIndex}
+ *     onquerychange={searchState.setQuery}
+ *     onnext={searchState.nextMatch}
+ *     onprevious={searchState.previousMatch}
+ *     onclose={searchState.close}
+ *   />
+ * {/if}
+ * ```
+ */
+export declare function useChatSearch(options: UseChatSearchOptions): UseChatSearchReturn;

package/dist/components/chat/container/use-chat-unread-state.svelte.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Runes helper for chat unread state tracking.
+ *
+ * Manages:
+ * - Unread message count
+ * - New message indicator visibility
+ * - First unread message ID for divider placement
+ * - Screen reader announcements
+ */
+import type { Message } from '../conversation-model.ts';
+import type { ChatUnreadIndicatorChangeEvent } from './chat-events.ts';
+export type { ChatUnreadIndicatorChangeEvent as UnreadIndicatorChangeEvent } from './chat-events.ts';
+/** Options for the unread state helper */
+export interface UseChatUnreadStateOptions {
+    /** Debounce delay for screen reader announcements (default: 300ms) */
+    announcerDebounceMs?: number;
+    /**
+     * Callback when unread indicator state changes.
+     *
+     * **Important:** Always read values from the event argument, not from bindings.
+     * The callback fires before bindable props are synchronized, so bindings may
+     * contain stale values during the callback.
+     */
+    onUnreadIndicatorChange?: (event: ChatUnreadIndicatorChangeEvent) => void;
+}
+/** Return type for the unread state helper */
+export interface UseChatUnreadStateReturn {
+    /** Current count of unread messages */
+    readonly unreadCount: number;
+    /** Whether the new message indicator should be visible */
+    readonly hasNewMessageIndicator: boolean;
+    /** ID of the first unread message (for divider placement) */
+    readonly firstUnreadId: string | null;
+    /** Formatted unread count for display (caps at "99+") */
+    readonly displayUnreadCount: string;
+    /** Whether the count exceeds 99 (for compact badge styling) */
+    readonly hasLargeCount: boolean;
+    /** Current screen reader announcement message */
+    readonly announcerMessage: string;
+    /** Mark all messages as read (resets unread state) */
+    markAllAsRead(): void;
+    /**
+     * Process messages to detect new arrivals and update unread state.
+     * Should be called in an $effect when messages change.
+     *
+     * @param getIsAtBottom - Getter function to read isAtBottom without creating a dependency.
+     *                        This allows the effect to only re-run when messages change, not on scroll.
+     */
+    processMessages(messages: Message[], conversationId: string, getIsAtBottom: () => boolean): void;
+    /** Cleanup resources */
+    destroy(): void;
+}
+/**
+ * Creates reactive state and methods for tracking unread messages.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useChatUnreadState } from './use-chat-unread-state.svelte';
+ *
+ *   const unreadState = useChatUnreadState({
+ *     onUnreadIndicatorChange: (event) => console.log('Unread changed:', event),
+ *   });
+ *
+ *   // Call in an $effect to process message changes
+ *   // Pass a getter function for isAtBottom to avoid creating a scroll dependency
+ *   $effect(() => {
+ *     unreadState.processMessages(messages, conversation.id, () => scrollState.isAtBottom);
+ *   });
+ *
+ *   // Mark as read when user scrolls to bottom
+ *   if (atBottom) unreadState.markAllAsRead();
+ * </script>
+ *
+ * <div aria-live="polite" class="sr-only">
+ *   {unreadState.announcerMessage}
+ * </div>
+ * ```
+ */
+export declare function useChatUnreadState(options?: UseChatUnreadStateOptions): UseChatUnreadStateReturn;

package/dist/components/chat/conversation-model.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Vendored conversation data model for the Chat component.
+ *
+ * Chat renders conversation transcripts but does not manage conversation state,
+ * so it depends only on the *shape* of the data it displays — not on any runtime
+ * library. This module is a faithful structural mirror of the message/content/tool
+ * shapes produced by the `conversationalist` library (and the shared
+ * `interoperability` tool types it builds on), so a `conversationalist` `Message`
+ * or an `armorer` tool call/result satisfies these types with zero adaptation.
+ *
+ * This file is the single authority for the contract. Provenance: agent-bureau
+ * commit `4ca94f7af6b06e0310b81c1706aebc092804879a`
+ * (`packages/conversationalist/src/{types,multi-modal}.ts`,
+ * `packages/interoperability/src/types.ts`). If provenance ever drifts from this
+ * file, this file wins and the discrepancy is raised separately.
+ *
+ * @module
+ */
+/** A JSON-serializable primitive. */
+export type JSONPrimitive = string | number | boolean | null;
+/** Any JSON-serializable value. */
+export type JSONValue = JSONPrimitive | ReadonlyArray<JSONValue> | {
+    [key: string]: JSONValue;
+};
+/** A text segment of message content. */
+export type TextContent = {
+    type: 'text';
+    text: string;
+};
+/** An image segment of message content. */
+export type ImageContent = {
+    type: 'image';
+    url: string;
+    mimeType?: string;
+    text?: string;
+};
+/** A single segment of multi-modal message content. */
+export type MultiModalContent = TextContent | ImageContent;
+/** Classification of a tool execution failure. */
+export type ToolErrorCategory = 'validation' | 'permission' | 'not_found' | 'conflict' | 'transient' | 'timeout' | 'cancelled' | 'internal';
+/** Structured error metadata attached to a failed tool result. */
+export type ToolError = {
+    code: string;
+    category: ToolErrorCategory;
+    retryable: boolean;
+    message: string;
+    details?: JSONValue | undefined;
+};
+/** A follow-up action a tool result can request before it can complete. */
+export type ToolAction = {
+    type: 'approval' | 'input';
+    message?: string | undefined;
+    schema?: JSONValue | undefined;
+};
+/** A request to invoke a tool. */
+export type ToolCall = {
+    id: string;
+    name: string;
+    arguments: JSONValue;
+};
+/** The outcome of executing a tool call. */
+export type ToolResult = {
+    callId: string;
+    outcome: 'success' | 'error' | 'action_required';
+    content: JSONValue;
+    error?: ToolError | undefined;
+    action?: ToolAction | undefined;
+};
+/** A tool call paired with its result, if one exists yet. */
+export type ToolCallPair = {
+    call: ToolCall;
+    result?: ToolResult | undefined;
+};
+/** The role a message plays in a conversation. */
+export type MessageRole = 'user' | 'assistant' | 'system' | 'developer' | 'tool-call' | 'tool-result' | 'snapshot';
+/** Token accounting for a single message. */
+export type TokenUsage = {
+    prompt: number;
+    completion: number;
+    total: number;
+};
+/** The mutable input shape used to create a message. */
+export type MessageInput = {
+    role: MessageRole;
+    content: string | MultiModalContent[];
+    metadata?: Record<string, JSONValue> | undefined;
+    hidden?: boolean | undefined;
+    toolCall?: ToolCall | undefined;
+    toolResult?: ToolResult | undefined;
+    tokenUsage?: TokenUsage | undefined;
+};
+/** An immutable message in a conversation transcript. */
+export type Message = {
+    id: string;
+    role: MessageRole;
+    content: string | ReadonlyArray<MultiModalContent>;
+    position: number;
+    createdAt: string;
+    metadata: Readonly<Record<string, JSONValue>>;
+    hidden: boolean;
+    toolCall?: Readonly<ToolCall> | undefined;
+    toolResult?: Readonly<ToolResult> | undefined;
+    tokenUsage?: Readonly<TokenUsage> | undefined;
+};
+/** Lifecycle status of a conversation. */
+export type ConversationStatus = 'active' | 'archived' | 'deleted';
+/**
+ * An immutable conversation transcript snapshot.
+ *
+ * `ids` is the canonical message ordering; `messages` is a record keyed by id
+ * (NOT an array). Resolve a message by walking `ids` and looking each up in
+ * `messages` — see {@link getMessages} in `./utilities/conversation.ts`.
+ */
+export type ConversationHistory = {
+    schemaVersion: number;
+    id: string;
+    title?: string | undefined;
+    status: ConversationStatus;
+    metadata: Readonly<Record<string, JSONValue>>;
+    ids: ReadonlyArray<string>;
+    messages: Readonly<Record<string, Message>>;
+    createdAt: string;
+    updatedAt: string;
+};
+/** Base options shared by all transcript export operations. */
+export type ExportOptions = {
+    /** When true, strips transient metadata (keys starting with '_'). @default false */
+    stripTransient?: boolean;
+    /** When false, hidden messages are omitted from export output. @default true */
+    includeHidden?: boolean;
+    /** When true, hidden message content is replaced with a redacted placeholder. @default false */
+    redactHiddenContent?: boolean;
+    /** Placeholder used when redacting tool or hidden content. @default "[REDACTED]" */
+    redactedPlaceholder?: string;
+    /** When true, redacts tool call arguments with '[REDACTED]'. @default false */
+    redactToolArguments?: boolean;
+    /** When true, redacts tool result content with '[REDACTED]'. @default false */
+    redactToolResults?: boolean;
+};
+/** Options for exporting a transcript to markdown. */
+export type ToMarkdownOptions = ExportOptions & {
+    /** When true, includes YAML frontmatter with full metadata for lossless round-trip. @default false */
+    includeMetadata?: boolean;
+};

package/dist/components/chat/export/conversation-export-actions.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { ConversationHistory } from '../conversation-model.ts';
+export type ExportFormat = 'markdown' | 'json';
+export interface ConversationExportActionsProps {
+    /** Required unique ID for SSR stability and accessibility */
+    id: string;
+    /** The conversation to export */
+    conversation: ConversationHistory;
+    /** Called when export succeeds */
+    onexported?: (format: ExportFormat) => void;
+    /** Called when export fails (clipboard error) */
+    onexportfailed?: (format: ExportFormat, error: string) => void;
+    /** Additional CSS classes */
+    class?: string;
+}
+declare const ConversationExportActions: import("svelte").Component<ConversationExportActionsProps, {}, "">;
+type ConversationExportActions = ReturnType<typeof ConversationExportActions>;
+export default ConversationExportActions;

package/dist/components/chat/export/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Chat export components.
+ *
+ * DEP-55: Copy/export actions for chat messages and conversations.
+ *
+ * @module
+ */
+export { default as ConversationExportActions } from './conversation-export-actions.svelte';

package/dist/components/chat/index.css

@@ -0,0 +1,61 @@
+/* src/components/markdown-editor/prosemirror.css */
+@layer cinder.components {
+  .ProseMirror {
+    position: relative;
+  }
+
+  .ProseMirror {
+    word-wrap: break-word;
+    white-space: pre-wrap;
+    white-space: break-spaces;
+    -webkit-font-variant-ligatures: none;
+    font-variant-ligatures: none;
+    font-feature-settings: "liga" 0;
+  }
+
+  .ProseMirror pre {
+    white-space: pre-wrap;
+  }
+
+  .ProseMirror li {
+    position: relative;
+  }
+
+  .ProseMirror-hideselection *::selection {
+    background: none;
+  }
+
+  .ProseMirror-hideselection *::-moz-selection {
+    background: none;
+  }
+
+  .ProseMirror-hideselection {
+    caret-color: transparent;
+  }
+
+  .ProseMirror [draggable][contenteditable="false"] {
+    user-select: text;
+  }
+
+  .ProseMirror-selectednode {
+    outline: 2px solid #8cf;
+  }
+
+  li.ProseMirror-selectednode {
+    outline: none;
+  }
+
+  li.ProseMirror-selectednode:after {
+    content: "";
+    position: absolute;
+    pointer-events: none;
+    border: 2px solid #8cf;
+    inset: -2px -2px -2px -32px;
+  }
+
+  img.ProseMirror-separator {
+    display: inline !important;
+    border: none !important;
+    margin: 0 !important;
+  }
+}

package/dist/components/chat/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Chat feature components.
+ *
+ * Re-exports from all chat subdirectories for convenient access.
+ *
+ * @module
+ */
+import Chat from './chat.svelte';
+export default Chat;
+export type { ChatProps } from './chat.types.ts';
+export { Chat };
+export { appendAssistantMessage, appendMessages, appendUserMessage, createConversation, } from './builders.ts';
+export type { ConversationHistory, ConversationStatus, ExportOptions, ImageContent, JSONValue, Message, MessageInput, MessageRole, MultiModalContent, TextContent, ToMarkdownOptions, TokenUsage, ToolAction, ToolCall, ToolCallPair, ToolError, ToolErrorCategory, ToolResult, } from './conversation-model.ts';
+export { formatMessageAsMarkdown, getMessageRoleLabel, getMessageText, messagesToMarkdown, type ChatExportOptions, type DeliveryStatus, } from './utilities';
+export { ChatAttachmentPreview, ChatInput, deriveAttachmentKind } from './input';
+export type { AttachmentKind } from './input';
+export { ChatDateSeparator, ChatMessage, MessageAttachments, MessageContent, ToolCallGroup, } from './message';
+export { DEFAULT_SCROLL_CONFIGURATION, calculateScrollToBottom, calculateUnreadCount, extractTimestamp, findUnreadBoundaryIndex, isAtBottom, shouldShowJumpToLatest, } from './container';
+export type { ChatScrollStateChangeEvent, ChatStopGeneratingEvent, ChatSubmitEvent, ChatUnreadIndicatorChangeEvent, ScrollConfiguration, ScrollState, } from './container';
+export { ConversationExportActions } from './export';
+export { ArtifactPanel, ArtifactViewer, ChatArtifactLayout } from './artifact';