@schlenkr/quassel 0.0.0-stage → 0.5.0

package/ChatActionDock.d.ts

@@ -0,0 +1,2 @@
+/** Target of open actions: undefined = in the transcript, null = the dock above the input is not mounted yet. */
+export declare const ChatActionDock: import("react").Context<HTMLElement | null | undefined>;

package/ChatInputToolbar.d.ts

@@ -0,0 +1,61 @@
+import { ReactNode, Ref } from "react";
+import { ChatTexts } from "./texts";
+import type { ChatAttachmentInput } from "./events";
+import type { SendShortcut } from "./options";
+/** A toolbar button, declarative: icon, text or both - plus click handler. */
+export interface ToolbarAction {
+    icon?: ReactNode;
+    label?: string;
+    title?: string;
+    disabled?: boolean;
+    active?: boolean;
+    onClick: () => void;
+}
+/** Hosts control the draft from outside, e.g. to insert a template for editing. */
+export interface ChatInputHandle {
+    /** Replaces the draft, focuses the input and puts the caret at the end. */
+    insert: (text: string) => void;
+    focus: () => void;
+    reset: () => void;
+    submit: (onSubmit?: (text: string, attachments?: ChatAttachmentInput[]) => void | Promise<void>, options?: {
+        allowEmpty?: boolean;
+    }) => Promise<void>;
+}
+/**
+ * The input card: borderless textarea on top, toolbar below a hairline. Custom buttons come
+ * declaratively through `actions` or freely through the left/right slots; while work is running
+ * the stop button stays visible, and typing shows the send button next to it, which then
+ * interjects. `rows` sets the initial height; with `maxRows` the textarea grows with its content
+ * up to that number of rows and scrolls after that. `inline` starts with one row and grows the same way.
+ */
+export declare function ChatInputToolbar({ onSend, onStop, running, disabled, sendDisabled, layout, detailsContainer, onErrorChange, inputAriaControls, rows, maxRows, actions, toolbarLeft, toolbarRight, texts, handleRef, attachments: attachmentsEnabled, attachmentCapabilities, attachmentCapabilitiesError, onAttachmentsChange, initialValue, onDraftChange, sendShortcut, autoFocus, onAutoFocusSettled, }: {
+    onSend: (text: string, attachments?: ChatAttachmentInput[]) => void | Promise<void>;
+    onStop?: () => void;
+    running?: boolean;
+    disabled?: boolean;
+    sendDisabled?: boolean;
+    layout?: "card" | "toolbar" | "inline";
+    detailsContainer?: HTMLElement | null;
+    onErrorChange?: (error: string | undefined) => void;
+    inputAriaControls?: string;
+    rows?: number;
+    maxRows?: number;
+    actions?: ToolbarAction[];
+    toolbarLeft?: ReactNode;
+    toolbarRight?: ReactNode;
+    texts?: Partial<ChatTexts>;
+    handleRef?: Ref<ChatInputHandle>;
+    /** false = no attaching: neither button nor dropping or pasting files. */
+    attachments?: boolean;
+    attachmentCapabilities?: {
+        input: readonly string[];
+        model: string;
+    };
+    attachmentCapabilitiesError?: string;
+    onAttachmentsChange?: (hasAttachments: boolean) => void;
+    initialValue?: string;
+    onDraftChange?: (text: string) => void;
+    sendShortcut?: SendShortcut;
+    autoFocus?: boolean;
+    onAutoFocusSettled?: () => void;
+}): import("react").JSX.Element;

package/ChatMessages.d.ts

@@ -0,0 +1,51 @@
+import { type CSSProperties, ReactNode } from "react";
+import { ChatAnnouncement, DetailMode, Message, PendingAction, ToolInfo, TranscriptMode } from "./types";
+import { ChatTexts } from "./texts";
+import { type LinkClickHandler } from "./Markdown";
+import { type ChatAppearance, type TimestampOptions, type CodeBlockOptions, type BubbleOptions, type MessageActionsOptions } from "./options";
+/**
+ * The transcript: its own scroll container with autoscroll while you are at the bottom, and a
+ * jump-to-end button as soon as you are reading. Usable read-only without a composer.
+ */
+export declare function ChatMessages({ messages, owner, detailMode, transcriptMode, running, working, stepsExpandable, groupsExpandable, texts, toolArgumentsText, renderTool, renderAction, onDismissAction, onLinkClick, emptyState, className, scrollerClassName, showTimestamps, announce, scrollerRef, maxWidth, horizontalPadding, jumpToEndThreshold, appearance, timestampOptions, codeBlockOptions, bubbleOptions, messageActions, toolElapsedThreshold, }: {
+    messages: Message[];
+    /** Contributions with this Message.sender appear without a speech bubble; null keeps the message defaults. */
+    owner?: string | null;
+    detailMode?: DetailMode;
+    transcriptMode?: TranscriptMode;
+    running?: boolean;
+    working?: ReactNode;
+    /** false = thinking and tool steps cannot be expanded (no popover). */
+    stepsExpandable?: boolean;
+    /** false = step groups in grouped mode stay collapsed (header without toggle). */
+    groupsExpandable?: boolean;
+    texts?: Partial<ChatTexts>;
+    toolArgumentsText?: (tool: ToolInfo) => string;
+    /** Custom rendering for single tools; undefined = default rendering. */
+    renderTool?: (tool: ToolInfo) => ReactNode | undefined;
+    /** Rendering of a pending action by its owner; undefined = generic card. */
+    renderAction?: (action: PendingAction, text: string) => ReactNode | undefined;
+    onDismissAction?: (actionId: string) => void;
+    /** Intercepts clicks on Markdown links; true = handled, the browser does not follow. */
+    onLinkClick?: LinkClickHandler;
+    emptyState?: ReactNode;
+    className?: string;
+    /** Host classes for the scroll container (data-quassel-transcript). */
+    scrollerClassName?: string;
+    /** true = subtle HH:MM column to the left of each block (Message.at). */
+    showTimestamps?: boolean;
+    /** Screen reader announcement of finished answers and new actions; false = the host announces itself. */
+    announce?: false | ((announcement: ChatAnnouncement) => string | undefined);
+    /** Exposes the scroll container so hosts can scroll without querying the DOM. */
+    scrollerRef?: (element: HTMLDivElement | null) => void;
+    maxWidth?: CSSProperties["maxWidth"];
+    horizontalPadding?: CSSProperties["paddingInline"];
+    jumpToEndThreshold?: number;
+    appearance?: ChatAppearance;
+    timestampOptions?: TimestampOptions;
+    codeBlockOptions?: CodeBlockOptions;
+    bubbleOptions?: BubbleOptions;
+    messageActions?: MessageActionsOptions;
+    /** Milliseconds before a running tool call shows its elapsed time (from Message.at) while running; false = never. */
+    toolElapsedThreshold?: number | false;
+}): import("react").JSX.Element;

package/ChatPanel.d.ts

@@ -0,0 +1,17 @@
+import { type CSSProperties, type ReactNode, type Ref } from "react";
+import { type ChatAppearance } from "./options";
+/**
+ * Transcript with an overlaid composer. The frame measures the composer itself and gives the
+ * transcript the footer space it needs, so no host has to set inner dimensions.
+ */
+export declare function ChatPanel({ children, composer, className, nodeRef, maxWidth, horizontalPadding, appearance, scrollOnSend, }: {
+    children: ReactNode;
+    /** The composer; it lies over the transcript, not below it. */
+    composer?: ReactNode;
+    className?: string;
+    nodeRef?: Ref<HTMLDivElement>;
+    maxWidth?: CSSProperties["maxWidth"];
+    horizontalPadding?: CSSProperties["paddingInline"];
+    appearance?: ChatAppearance;
+    scrollOnSend?: boolean;
+}): import("react").JSX.Element;

package/ChatSendContext.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from "react";
+export interface ChatSendScope {
+    notify: () => void;
+    subscribe: (listener: () => void) => () => void;
+}
+export declare const ChatSendContext: import("react").Context<ChatSendScope | undefined>;
+export declare function createChatSendScope(enabled: RefObject<boolean>): ChatSendScope;

package/DetailModeSwitch.d.ts

@@ -0,0 +1,16 @@
+import { DetailMode } from "./types";
+import { ChatTexts } from "./texts";
+export declare const DETAIL_MODES: readonly DetailMode[];
+export declare const detailModeLabel: (mode: DetailMode, texts?: Partial<ChatTexts>) => string;
+/**
+ * An icon button that cycles the detail level of the thinking and tool steps. The order comes
+ * from `modes`, the current value shows in the icon and in the tooltip.
+ */
+export declare function DetailModeSwitch({ mode, onChange, modes, texts, className, }: {
+    mode: DetailMode;
+    onChange: (mode: DetailMode) => void;
+    /** Selection and order of cycling; the default is all modes. */
+    modes?: readonly DetailMode[];
+    texts?: Partial<ChatTexts>;
+    className?: string;
+}): import("react").JSX.Element;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ronald Schlenker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Markdown.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from "react";
+import type { CodeBlockOptions } from "./options";
+import { type ChatTexts } from "./texts";
+export type LinkClickHandler = (href: string, label: string) => boolean;
+export declare function MarkdownCodeBlocks({ children, options, texts }: {
+    children: ReactNode;
+    options?: CodeBlockOptions;
+    texts: ChatTexts;
+}): import("react").JSX.Element;
+export declare function MarkdownLinks({ children, onLinkClick }: {
+    children: ReactNode;
+    onLinkClick?: LinkClickHandler;
+}): import("react").JSX.Element;
+export declare function Markdown({ text, streaming }: {
+    text: string;
+    streaming?: boolean;
+}): import("react").JSX.Element;
+/** The same syntax as the renderer, as plain text without markup, e.g. for screen reader announcements. */
+export declare function markdownPlainText(text: string): string;

package/MessageActions.d.ts

@@ -0,0 +1,8 @@
+import type { MessageActionsOptions } from "./options";
+import type { ChatTexts } from "./texts";
+import type { Message } from "./types";
+export declare function MessageActions({ message, options, texts }: {
+    message: Message;
+    options?: MessageActionsOptions;
+    texts: ChatTexts;
+}): import("react").JSX.Element;

package/PendingActionCard.d.ts

@@ -0,0 +1,13 @@
+import type { PendingAction } from "./types";
+/**
+ * The rendering of a pending action without a contribution from its owner: title, the hint
+ * that input is expected, and dismissing. Only the plugin knows the form.
+ */
+export declare function PendingActionCard({ text, action, waitingLabel, dismissLabel, dismissedLabel, onDismiss, }: {
+    text: string;
+    action: PendingAction;
+    waitingLabel: string;
+    dismissLabel: string;
+    dismissedLabel: string;
+    onDismiss?: () => void;
+}): import("react").JSX.Element;

package/QuasselProvider.d.ts

@@ -0,0 +1,89 @@
+import { type ComponentType, type CSSProperties, type ReactNode, type RefObject } from "react";
+export type QuasselButtonVariant = "default" | "outline" | "secondary" | "ghost" | "destructive" | "link";
+export type QuasselButtonSize = "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg";
+export interface QuasselButtonProps {
+    variant?: QuasselButtonVariant;
+    size?: QuasselButtonSize;
+    className?: string;
+    disabled?: boolean;
+    title?: string;
+    "aria-label"?: string;
+    "aria-pressed"?: boolean;
+    onClick?: () => void;
+    children?: ReactNode;
+}
+export interface QuasselToggleProps {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+    className?: string;
+    disabled?: boolean;
+    title?: string;
+    pressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    children?: ReactNode;
+}
+export interface QuasselCardProps {
+    size?: "default" | "sm";
+    className?: string;
+    children?: ReactNode;
+}
+export interface QuasselStopButtonProps {
+    label: string;
+    busy?: boolean;
+    size?: QuasselButtonSize;
+    className?: string;
+    disabled?: boolean;
+    title?: string;
+    onClick?: () => void;
+}
+export interface QuasselPopoverProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+export interface QuasselPopoverAnchor {
+    getBoundingClientRect: () => DOMRect;
+    contextElement?: Element;
+}
+/** Where popovers mount: an element, a ref or a getter; resolved when the popover opens. */
+export type QuasselPortalTarget = HTMLElement | ShadowRoot;
+export type QuasselPortalContainer = QuasselPortalTarget | RefObject<QuasselPortalTarget | null> | (() => QuasselPortalTarget | null | undefined);
+export interface QuasselPopoverContentProps {
+    anchor?: QuasselPopoverAnchor;
+    align?: "start" | "center" | "end";
+    side?: "top" | "bottom" | "left" | "right" | "inline-start" | "inline-end";
+    sideOffset?: number;
+    collisionPadding?: number;
+    className?: string;
+    /** Carries --qsl-base, the text size of the chat that opened the popover; pass it on to the popup. */
+    style?: CSSProperties;
+    "aria-label"?: string;
+    /** The resolved portalContainer of QuasselProvider; undefined = document.body. */
+    portalContainer?: QuasselPortalTarget;
+    children?: ReactNode;
+}
+/** The primitives quassel renders; a host replaces any of them through QuasselProvider. */
+export interface QuasselComponents {
+    Button: ComponentType<QuasselButtonProps>;
+    Toggle: ComponentType<QuasselToggleProps>;
+    Card: ComponentType<QuasselCardProps>;
+    StopButton: ComponentType<QuasselStopButtonProps>;
+    Popover: ComponentType<QuasselPopoverProps>;
+    PopoverContent: ComponentType<QuasselPopoverContentProps>;
+}
+export declare const defaultComponents: QuasselComponents;
+export declare function QuasselProvider({ components, allowUrl, resolveUrl, portalContainer, children }: {
+    /** Replaces single primitives; the rest stay the built-in ones or those of an outer provider. */
+    components?: Partial<QuasselComponents>;
+    /** Keeps Markdown link and image URLs that the default policy (http, https, mailto, tel, ftp, irc, xmpp, relative) would drop. */
+    allowUrl?: (url: string) => boolean;
+    /** Maps every Markdown link and image URL before the link policy applies, e.g. relative paths onto the host's file route. */
+    resolveUrl?: (url: string) => string;
+    /** Mounts quassel's popovers inside this element instead of document.body, e.g. within the host's theme wrapper. */
+    portalContainer?: QuasselPortalContainer;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare const useQuasselComponents: () => QuasselComponents;
+export declare const useAllowUrl: () => ((url: string) => boolean) | undefined;
+export declare const useResolveUrl: () => ((url: string) => string) | undefined;
+export declare function useQuasselPortalContainer(): QuasselPortalTarget | undefined;

package/README.md

@@ -1,3 +1,128 @@
-# Temporary Holding Version
+# quassel
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Chat building blocks for React: a streaming transcript with thinking and tool steps, pending
+actions, an input card with attachments and steering, and a small event contract that works
+on the server as well. quassel is the chat of [RAgents](https://github.com/SchlenkR/RAgents),
+published as a library. It ships a compiled stylesheet, so hosts need no Tailwind, and every
+color, radius, font and font size is a `--qsl-*` variable, and the text size follows the host by default.
+
+![An agent chat with grouped steps, timestamps, Markdown and the input card](https://raw.githubusercontent.com/SchlenkR/quassel/main/docs/images/agent.png)
+
+## What you can build
+
+**Agent chats that show their work.** Thinking and tool calls appear as steps. Pick how much
+of them the user sees - only the current step, icons, chips, a collapsible group, single lines
+or everything - and let them switch at runtime. A tool call that runs longer than a few seconds
+shows how long it has been running, on its row and on the collapsed group header, so a slow step
+does not look like a hung one.
+
+![The same steps as icons, chips and single lines](https://raw.githubusercontent.com/SchlenkR/quassel/main/docs/images/details.png)
+
+**Pending actions.** The agent waits for input: a generic card with dismiss, or the host's own
+rendering per action owner. Open actions sit right above the input, like a question in a terminal
+agent; resolved actions stay in the transcript as a record.
+
+**Multi-party conversations.** Colored bubbles with labels for agents that talk to each other.
+
+<p>
+  <img src="docs/images/questions.png" alt="Pending actions: a host-rendered choice and the generic card" width="49%">
+  <img src="docs/images/party.png" alt="Planner and reviewer as labeled bubbles" width="49%">
+</p>
+
+**Your look, not a fork.** Override `--qsl-*` variables on any wrapper, switch light and dark
+with `data-theme`, or hand quassel your own Button, Toggle, Card and Popover components. With
+`portalContainer` on `QuasselProvider`, popovers render inside your wrapper and pick up its
+variables too.
+
+![Default, sunset and emerald themes](https://raw.githubusercontent.com/SchlenkR/quassel/main/docs/images/themes.png)
+
+![The agent chat in dark mode](https://raw.githubusercontent.com/SchlenkR/quassel/main/docs/images/agent-dark.png)
+
+## Highlights
+
+- Streaming-safe Markdown (tables, code with copy button, lists) via Streamdown.
+- Steering: typing while a turn runs sends into it; stop, retry and failed-send recovery built in.
+- Attachments by button, drag and drop or paste, with previews and size limits.
+- Condensed conversation: all user inputs and the latest answer between them, independently of tool/thinking detail.
+- Timestamps, day separators, message actions, configurable bubbles and appearance.
+- Screen reader friendly: the transcript is not a live region; finished replies and new
+  actions are announced once, with the host in control of the wording.
+- Complete English and German UI labels through `englishTexts` / `germanTexts`; `texts` can override any label (English by default).
+- Grouped steps show their error count even while collapsed.
+- Text size follows the host: no overrides needed to fit in (see below).
+
+## Install
+
+```sh
+npm install @schlenkr/quassel
+```
+
+Up to 0.4.9 the package was published without scope as `quassel`; from 0.5.0 on it is `@schlenkr/quassel` with the same API.
+
+| Import | Contents |
+|---|---|
+| `@schlenkr/quassel` | React components, `QuasselProvider`, types, texts, `announce`, `markdownPlainText` |
+| `@schlenkr/quassel/events` | The event contract, the pure reducer `applyEvent` and the attachment limits, without React |
+| `@schlenkr/quassel/chat.css` | The compiled stylesheet: theme variables, scoped reset and all utilities quassel uses |
+
+```tsx
+import { useReducer, useState } from "react";
+import { applyEvent, ChatInputToolbar, ChatMessages, ChatPanel, type Message } from "@schlenkr/quassel";
+import "@schlenkr/quassel/chat.css";
+
+export function Chat({ send, stop }: { send: (text: string) => Promise<void>; stop: () => void }) {
+  const [messages, dispatch] = useReducer(applyEvent, [] as Message[]);
+  const [running, setRunning] = useState(false);
+  // feed your backend's ChatEvent stream into dispatch(event) and setRunning(event.running) on "status"
+  return (
+    <ChatPanel composer={<ChatInputToolbar onSend={send} onStop={stop} running={running} rows={1} />}>
+      <ChatMessages messages={messages} running={running} detailMode="grouped" />
+    </ChatPanel>
+  );
+}
+```
+
+```css
+.my-chat {
+    --qsl-primary: #11855c;
+    --qsl-radius: 0.9rem;
+}
+```
+
+Any backend that emits the `@schlenkr/quassel/events` stream works with the same components.
+
+## Text size
+
+quassel inherits the font size of the place it is mounted in. Chat text and the input use that
+size, meta lines, step rows and labels are derived from it as smaller steps, and nothing
+compounds when elements nest. One variable changes it for a chat:
+
+```css
+.my-chat {
+    --qsl-font-size: 15px;
+}
+```
+
+`--qsl-chat-font-size` and `--qsl-text-meta` (and `-trace`, `-label`, `-xs` to `-xl`) override
+single steps. Up to 0.4.9 the root was fixed at 14px and the chat text at 13px, so hosts had to
+override sizes by hand; from 0.5.0 on that is no longer needed. Details in the
+[guide](https://github.com/SchlenkR/quassel/blob/main/docs/guide.md#text-size).
+
+## Development
+
+```sh
+pnpm install
+pnpm dev              # stylesheet in watch mode plus the gallery on http://localhost:3210
+pnpm check            # type check package and gallery
+pnpm test             # package tests (node:test with happy-dom)
+pnpm build            # stylesheet and gallery build
+pnpm release --dry-run
+```
+
+The full guide - every prop, the event contract, theming, slots, dark mode and publishing -
+is in [docs/guide.md](https://github.com/SchlenkR/quassel/blob/main/docs/guide.md). It is written so that an AI assistant can build
+an application with quassel from it.
+
+## License
+
+[MIT](https://github.com/SchlenkR/quassel/blob/main/LICENSE)

package/StepPopover.d.ts

@@ -0,0 +1,16 @@
+import { type MouseEvent } from "react";
+import { Message } from "./types";
+import { ChatTexts } from "./texts";
+export type StepPopoverOrigin = {
+    x: number;
+    y: number;
+    base: string;
+};
+export declare const stepPopoverOrigin: (event: MouseEvent<HTMLElement>) => StepPopoverOrigin;
+export declare function StepPopover({ message, position, texts, toolArgumentsText, onClose, }: {
+    message: Message;
+    position: StepPopoverOrigin;
+    texts: ChatTexts;
+    toolArgumentsText: (tool: NonNullable<Message["tool"]>) => string;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/TimestampSwitch.d.ts

@@ -0,0 +1,7 @@
+import { type ChatTexts } from "./texts";
+export declare function TimestampSwitch({ showTimestamps, onChange, texts, className }: {
+    showTimestamps: boolean;
+    onChange: (showTimestamps: boolean) => void;
+    texts?: Partial<ChatTexts>;
+    className?: string;
+}): import("react").JSX.Element;

package/TranscriptModeSwitch.d.ts

@@ -0,0 +1,8 @@
+import { type TranscriptMode } from "./types";
+import { type ChatTexts } from "./texts";
+export declare function TranscriptModeSwitch({ mode, onChange, texts, className }: {
+    mode: TranscriptMode;
+    onChange: (mode: TranscriptMode) => void;
+    texts?: Partial<ChatTexts>;
+    className?: string;
+}): import("react").JSX.Element;

package/WorkingScenes.d.ts

@@ -0,0 +1,12 @@
+export interface WorkingScenesProps {
+    /** Limits scenes to one or two visible characters for small status fields. */
+    compact?: boolean;
+    /** Text for screen readers, default "Working ...". */
+    label?: string;
+}
+/**
+ * The default working indicator: randomly rotating mini scenes. Random order and start phase,
+ * so the same scenes never feel like a loop. The working prop of ChatMessages replaces it
+ * completely.
+ */
+export declare function WorkingScenes({ label, compact }: WorkingScenesProps): import("react").JSX.Element;

package/announce.d.ts

@@ -0,0 +1,2 @@
+/** Announces text through a shared, hidden live region: throttled, and paused while the tab is hidden. */
+export declare function announce(text: string): void;

package/attachments.d.ts

@@ -0,0 +1,24 @@
+import type { ChatAttachmentInput } from "./events";
+import { MAX_CHAT_ATTACHMENTS, MAX_CHAT_ATTACHMENT_BYTES } from "./chat-attachments";
+import { type ChatTexts } from "./texts";
+export { MAX_CHAT_ATTACHMENTS, MAX_CHAT_ATTACHMENT_BYTES };
+export declare const maxAttachmentSizeLabel = "20 MiB";
+export declare function attachmentMediaType(file: {
+    name: string;
+    type: string;
+}): string;
+export declare function attachmentCapabilityError(files: readonly {
+    name: string;
+    mediaType: string;
+}[], capabilities: {
+    input: readonly string[];
+    model: string;
+}, texts?: ChatTexts): string | undefined;
+export declare function validateAttachmentSelection(existing: readonly {
+    size: number;
+}[], incoming: readonly {
+    size: number;
+}[], texts?: ChatTexts): void;
+export declare function encodeAttachment(file: File): Promise<ChatAttachmentInput>;
+export declare function formatAttachmentSize(bytes: number): string;
+export declare function attachmentDownloadUrl(url: string): string;

package/chat-attachments.d.ts

@@ -0,0 +1,6 @@
+import type { ChatAttachmentInput } from "./events";
+export declare const MAX_CHAT_ATTACHMENTS = 8;
+export declare const MAX_CHAT_ATTACHMENT_BYTES: number;
+export declare const MAX_CHAT_REQUEST_BYTES: number;
+export declare const chatAttachmentMediaType: (name: string, mediaType: string) => string;
+export declare const parseChatAttachments: (value: unknown) => ChatAttachmentInput[];

package/chat-scroll.d.ts

@@ -0,0 +1,12 @@
+interface ScrollViewport {
+    scrollTop: number;
+    readonly scrollHeight: number;
+    readonly clientHeight: number;
+}
+export declare function createChatScroll(onFollowChange?: (following: boolean) => void): {
+    layout: (viewport: ScrollViewport, dragging?: boolean) => void;
+    pause(viewport: ScrollViewport): void;
+    scroll(viewport: ScrollViewport, dragging?: boolean): void;
+    jump(viewport: ScrollViewport): void;
+};
+export {};