@tribepad/themis 1.3.4 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,39 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-04-30
+
+### Added
+- **ChatInterface** — accessible chatbot UI element for hosting AI support chats (WCAG 2.2 AAA target).
+  - Stateless / fully controlled: consumer owns `messages[]`, `status`, websocket, persistence; ChatInterface emits events (`onSendMessage`, `onStopGeneration`, `onRetry`, `onEscalate`).
+  - Live-region architecture: `<div role="log">` is visual + navigable (no `aria-live`); a single sr-only `<div role="status" aria-live="polite">` is the canonical AT announcement channel with FIFO queue, 500ms min interval, 1s dedup, 32-entry cap, 200ms hold.
+  - Announcements: completion (preview from rendered DOM `innerText`, normalised + truncated to clamped [50, 1000] chars), generation-stopped, response-failed, bounded slow-response "still working" pings (3s/15s/60s, capped at 3, visibility-gated, suppressible via `progressAnnouncements: false`).
+  - Pluggable input: built-in Themis-styled multi-line textarea (`field-sizing: content` primary path with rAF-batched JS fallback, IME-safe Enter via `event.isComposing || keyCode === 229`, `autoComplete="off"`); consumers can swap in a rich-text editor via `inputComponent` honouring a small forwardRef contract (`focus`/`clear`/`submit`/`setValue`).
+  - Render-prop content: `renderAssistantContent` / `renderUserContent` for consumer-owned markdown rendering (library treats `content` as opaque). Bounded LRU cache (200 entries, `(id, content)` keyed) skips re-rendering completed messages on token ticks.
+  - Memoised bubble with custom comparator covering `id`/`role`/`status`/`content`/`errorMessage`/`createdAt` + shallow-equal `parts`; documented immutability requirement on the `messages` prop.
+  - Auto-scroll: IntersectionObserver sentinel (256px `rootMargin` to tolerate `content-visibility: auto` placeholder churn); `overflow-anchor: none` to prevent browser anchoring fighting auto-scroll; rAF-throttled scroll on streaming-bubble growth; reduced-motion forces non-smooth.
+  - Reduced motion: streaming bubble shows static "Generating response…" placeholder instead of revealing tokens; typing dots, thinking pill, running tool-call spinner are static; `prefers-reduced-motion: reduce` honoured throughout.
+  - Three-layer architecture: Send/Stop/Retry/Escalate/Jump-to-latest all reuse Themis Button's 44×44 touch targets; input wrapper has `min-h-[44px]` to align with buttons.
+  - Discriminated-union message model (user / assistant / system) with strict (`.strict()`) Zod schemas. System messages bypass renderers; thinking parts (`text` / `tool_call`) render as visible rows during thinking, collapse into a `<details>` "Thoughts" disclosure when the response begins.
+  - Security: no `dangerouslySetInnerHTML` anywhere (regression-tested); JSX-escaping for all consumer-supplied strings; Unicode normalisation strips C0/C1, zero-width, bidi overrides, isolates, BOM from announcement text; `maxInputLength` enforced as defence-in-depth at the ChatInterface boundary; XSS-as-text test matrix.
+  - 85 new tests across `.contract.test.ts`, `.test.tsx`, `.a11y.test.tsx`. Storybook stories: Empty, PlainConversation, Streaming, Thinking, ErrorState, ByoMarkdown (with documented secure `react-markdown` + `rehype-sanitize` setup), CustomInput (RTE example), LongConversation (200 turns), ReducedMotion.
+  - Comprehensive component README at `src/elements/ChatInterface/README.md` documenting performance rules, security model, custom-input contract, AT behaviour, and v1 limitations (no message virtualisation past ~1000–2000 messages, no parts-first model, no attachments, no message editing UI; all v2 candidates).
+
+### Changed
+- **`src/styles/defaults.css`** — added `--chat-input-max-lines` token (default `6`) for the ChatInterface input cap.
+
+## [1.3.5] - 2026-04-27
+
+### Security
+- Patched the lone `pnpm audit` advisory by adding a `pnpm.overrides` entry for `postcss@<8.5.10` → `^8.5.12` (GHSA-qx2v-qp2m-jg93, XSS via unescaped `</style>` in CSS stringify output).
+
+### Changed
+- Bumped 19 dependencies to latest patch/minor/major: `react-aria` 3.47→3.48, `react-aria-components` 1.16→1.17, `react-stately` 3.45→3.46, `eslint` 9→10 (with matching `@eslint/js`), `@vitejs/plugin-react` 5→6, `jsdom` 28→29, `size-limit` + `@size-limit/preset-small-lib` 11→12, `@storybook/addon-mcp` 0.4→0.6, `@internationalized/date` 3.12.0→3.12.1, `@tailwindcss/vite` 4.2.2→4.2.4, `@typescript-eslint/*` 8.58→8.59, `vite` 8.0.8→8.0.10, `vitest` 4.1.4→4.1.5, `@vitest/coverage-v8` 4.1.4→4.1.5, `lucide-react` 1.8→1.11, `eslint-plugin-storybook` 10.3.3→10.3.5. TypeScript held at 5.9.3 to keep emitted `.d.ts` compatible with downstream consumers on TS 5.
+
+### Fixed
+- **`useResizable`** — removed dead initialisation of `newRightSize` (was unconditionally overwritten before being read); now declared via `let newRightSize: number;`. Behaviour unchanged.
+- **`useOTPInput`** — same dead-initialisation cleanup for `isValid` in two locations; declared via `let isValid: boolean;`. Behaviour unchanged. Both fixes silence the new ESLint 10 `no-useless-assignment` rule.
+
 ## [1.3.2] - 2026-04-23
 
 ### Fixed

package/dist/elements/ChatInterface/ChatInputArea.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from 'react';
+import type { ChatInputComponent, ChatInputComponentHandle, ChatTopLevelStatus } from './ChatInterface.types';
+/**
+ * Wraps the (default or custom) input + Send/Stop button + inputActions slot.
+ *
+ * The Send button is ALWAYS enabled when the input area isn't disabled — it does not gate on
+ * input emptiness. The contract guarantees `submit()` is no-op on empty input, so harmless
+ * clicks on an empty input produce no message.
+ *
+ * `isDisabled` truth table (forwarded to the input):
+ * - consumer.isDisabled === true → true
+ * - status === 'streaming' → true
+ * - status === 'error' → true
+ * - otherwise → false
+ *
+ * Stop button is shown only when status === 'streaming'.
+ */
+interface ChatInputAreaProps {
+    status: ChatTopLevelStatus;
+    consumerDisabled: boolean;
+    inputComponent?: ChatInputComponent;
+    placeholder?: string;
+    maxInputLength?: number;
+    sendShortcut: 'enter' | 'mod-enter';
+    inputActions?: ReactNode;
+    inputAriaLabel: string;
+    /** Forwarded to consumer's `onSendMessage`. ChatInterface enforces maxInputLength backstop here. */
+    onSendMessage: (text: string) => void;
+    onStopGeneration?: () => void;
+    /** Receives the input handle so the parent can implement `chatRef.current.focusInput()`. */
+    registerInputHandle: (handle: ChatInputComponentHandle | null) => void;
+    /** Tells ChatInterface that an `error` → `idle` transition just happened so it can move focus. */
+    className?: string;
+}
+export declare function ChatInputArea({ status, consumerDisabled, inputComponent, placeholder, maxInputLength, sendShortcut, inputActions, inputAriaLabel, onSendMessage, onStopGeneration, registerInputHandle, className, }: ChatInputAreaProps): React.ReactElement;
+export {};
+//# sourceMappingURL=ChatInputArea.d.ts.map

package/dist/elements/ChatInterface/ChatInputArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatInputArea.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatInputArea.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAM5D,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;GAcG;AACH,UAAU,kBAAkB;IAC1B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,OAAO,GAAG,WAAW,CAAC;IACpC,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,oGAAoG;IACpG,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B,4FAA4F;IAC5F,mBAAmB,EAAE,CAAC,MAAM,EAAE,wBAAwB,GAAG,IAAI,KAAK,IAAI,CAAC;IACvE,kGAAkG;IAClG,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,SAAS,GACV,EAAE,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAiGzC"}

package/dist/elements/ChatInterface/ChatInterface.d.ts

@@ -0,0 +1,24 @@
+import type { ChatInterfaceHandle, ChatInterfaceProps } from './ChatInterface.types';
+/**
+ * ChatInterface — WCAG 2.2 AAA-compliant chatbot UI.
+ *
+ * Stateless from the library's perspective: consumer owns the messages array,
+ * status, and websocket. ChatInterface renders + emits events.
+ *
+ * Live-region architecture:
+ * - `<div role="log">` — visual + navigable, no `aria-live`. AT users locate via landmarks/rotor.
+ * - `<div role="status" aria-live="polite">` — single sr-only AT announcement channel.
+ * - Tokens mutate the streaming bubble's text content in place (silent).
+ * - On streaming → complete, the bubble's rendered DOM `innerText` is normalised, truncated,
+ *   and pinged into the status region as `"Assistant replied: <preview>"`.
+ *
+ * IMMUTABILITY: Pass a new message object when its content/parts/status/errorMessage/createdAt
+ * changes. In-place mutation will not re-render (memoised bubbles).
+ *
+ * Markdown rendering is the consumer's responsibility via `renderAssistantContent` /
+ * `renderUserContent`. ChatInterface treats content as opaque string. See README for
+ * `react-markdown` + `rehype-sanitize` integration guidance.
+ */
+declare const ChatInterface: import("react").ForwardRefExoticComponent<ChatInterfaceProps & import("react").RefAttributes<ChatInterfaceHandle>>;
+export { ChatInterface };
+//# sourceMappingURL=ChatInterface.d.ts.map

package/dist/elements/ChatInterface/ChatInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatInterface.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatInterface.tsx"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAGV,mBAAmB,EACnB,kBAAkB,EAEnB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,aAAa,oHAuUlB,CAAC;AAgBF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/elements/ChatInterface/ChatInterface.hooks.d.ts

@@ -0,0 +1,46 @@
+export declare function normaliseAnnouncementText(input: string): string;
+/**
+ * Truncate to `maxChars`, suffixing with the supplied `suffix` if truncated.
+ * `maxChars` is clamped to [50, 1000] before truncation.
+ */
+export declare function truncateAnnouncement(text: string, maxChars: number | undefined, suffix?: string): string;
+/**
+ * Auto-resize a textarea based on its scrollHeight, capped at `--chat-input-max-lines × line-height`.
+ * On browsers supporting `field-sizing: content`, the JS path is a no-op (CSS handles it).
+ * On older browsers, the JS measurement is rAF-batched to collapse N keystrokes per frame into one reflow.
+ */
+export declare function useAutoResizeTextarea(textareaRef: React.RefObject<HTMLTextAreaElement | null>, value: string, maxLines?: number): void;
+/**
+ * Track whether the user is "stuck to bottom" using an IntersectionObserver on a sentinel element
+ * at the bottom of the log. No scroll listener — browser-native.
+ *
+ * `rootMargin` is wide (256px) to tolerate scrollHeight churn from `content-visibility: auto`
+ * placeholders being measured as bubbles scroll into view.
+ *
+ * Returns:
+ * - `isAtBottom` — true if the bottom sentinel is intersecting the root.
+ * - `scrollToBottom(opts?)` — imperative scroll (respects reduced-motion).
+ */
+export declare function useTranscriptScroll(scrollContainerRef: React.RefObject<HTMLDivElement | null>, sentinelRef: React.RefObject<HTMLDivElement | null>, prefersReducedMotion: boolean): {
+    isAtBottom: boolean;
+    scrollToBottom: (opts?: {
+        smooth?: boolean;
+    }) => void;
+};
+export declare function useStillWorkingTimer(args: {
+    isStreaming: boolean;
+    streamingContentLength: number;
+    enabled: boolean;
+    message: string;
+    onAnnounce: (text: string) => void;
+}): void;
+export declare function useAnnouncementQueue(opts?: {
+    minIntervalMs?: number;
+    dedupWindowMs?: number;
+    holdMs?: number;
+    maxQueueSize?: number;
+}): {
+    current: string;
+    enqueue: (text: string) => void;
+};
+//# sourceMappingURL=ChatInterface.hooks.d.ts.map

package/dist/elements/ChatInterface/ChatInterface.hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatInterface.hooks.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatInterface.hooks.ts"],"names":[],"mappings":"AA6BA,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU/D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,SAAiC,GACtC,MAAM,CAUR;AAeD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAAC,EACxD,KAAK,EAAE,MAAM,EACb,QAAQ,SAAI,GACX,IAAI,CAqCN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,EAC1D,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,EACnD,oBAAoB,EAAE,OAAO,GAC5B;IACD,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;CACvD,CA+BA;AAkBD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,WAAW,EAAE,OAAO,CAAC;IACrB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,GAAG,IAAI,CA2EP;AAiBD,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,CAgFvD"}

package/dist/elements/ChatInterface/ChatInterface.styles.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Root container — fills the parent.
+ */
+export declare const chatRootVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const chatHeaderVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/**
+ * Log region — visual + navigable. NO `aria-live`. Scroll container.
+ * `overflow-anchor: none` prevents browser scroll-anchoring fighting auto-scroll while the streaming bubble grows.
+ */
+export declare const chatLogVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/**
+ * Message bubble — wrapper for a single message row.
+ * `content-visibility: auto` skips layout for offscreen bubbles. Skip on streaming bubble.
+ */
+export declare const chatBubbleRowVariants: (props?: ({
+    align?: "user" | "assistant" | "system" | null | undefined;
+    offscreen?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * The visible bubble itself.
+ */
+export declare const chatBubbleVariants: (props?: ({
+    role?: "user" | "assistant" | "system" | null | undefined;
+    isError?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Avatar slot beside a bubble.
+ */
+export declare const chatAvatarSlotVariants: (props?: ({
+    role?: "user" | "assistant" | "system" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Input area at the bottom of the chat.
+ */
+export declare const chatInputAreaVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/**
+ * The default input wrapper (Layer 1 of the input).
+ *
+ * `min-h-[44px]` matches the Button outer touch-target height so an empty single-line input
+ * visually aligns with the Send/Stop button. With `field-sizing: content` on the textarea,
+ * the wrapper grows naturally as the user types multi-line; `items-end` on the parent keeps
+ * the bottoms aligned (the wrapper's top rises while the button stays anchored).
+ */
+export declare const chatInputWrapperVariants: (props?: ({
+    isDisabled?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * The textarea inside the wrapper. JS path for browsers that don't support `field-sizing: content`.
+ */
+export declare const chatInputTextareaVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/**
+ * Typing indicator (three dots) shown during active token streaming.
+ */
+export declare const chatTypingIndicatorVariants: (props?: ({
+    animate?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Thinking pill shown while assistant message has status === 'thinking'.
+ */
+export declare const chatThinkingPillVariants: (props?: ({
+    animate?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Tool-call row inside the thinking display.
+ */
+export declare const chatToolCallRowVariants: (props?: ({
+    status?: "error" | "running" | "done" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Jump-to-latest floating button. 44x44 layer-1 + visual layer.
+ */
+export declare const chatJumpToLatestVariants: (props?: ({
+    visible?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * sr-only utility for the status region. Stays out of visual flow but accessible.
+ */
+export declare const chatStatusRegionVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/**
+ * Action row below an errored assistant bubble (Try again / Submit a support request).
+ */
+export declare const chatErrorActionsVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+//# sourceMappingURL=ChatInterface.styles.d.ts.map

package/dist/elements/ChatInterface/ChatInterface.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatInterface.styles.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatInterface.styles.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,gBAAgB,oFAE5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,oFAE9B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,oFAE3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;8EAahC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;8EAiB9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;8EAYlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,oFAEjC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;8EAWpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,oFAErC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B;;8EAWvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB;;8EAWpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;8EAYnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB;;8EAWpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,oFAEpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,oFAEpC,CAAC"}

package/dist/elements/ChatInterface/ChatInterface.types.d.ts

@@ -0,0 +1,340 @@
+import { z } from 'zod';
+import type { ForwardRefExoticComponent, ReactNode, RefAttributes } from 'react';
+/**
+ * ChatInterface — public types and Zod schemas.
+ *
+ * Schemas use `.strict()` so unknown keys throw rather than strip silently.
+ * Production callers should NEVER call `.parse()` directly — internal validation
+ * is gated on `process.env.NODE_ENV !== 'production'` so tsup tree-shakes it out.
+ */
+export declare const ChatRoleSchema: z.ZodEnum<{
+    user: "user";
+    assistant: "assistant";
+    system: "system";
+}>;
+export type ChatRole = z.infer<typeof ChatRoleSchema>;
+export declare const ChatMessageStatusSchema: z.ZodEnum<{
+    error: "error";
+    complete: "complete";
+    streaming: "streaming";
+    thinking: "thinking";
+}>;
+export type ChatMessageStatus = z.infer<typeof ChatMessageStatusSchema>;
+export declare const ChatTopLevelStatusSchema: z.ZodEnum<{
+    error: "error";
+    streaming: "streaming";
+    idle: "idle";
+}>;
+export type ChatTopLevelStatus = z.infer<typeof ChatTopLevelStatusSchema>;
+export declare const ThinkingPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool_call">;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        running: "running";
+        done: "done";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type ThinkingPart = z.infer<typeof ThinkingPartSchema>;
+declare const ChatUserMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodLiteral<"user">;
+    status: z.ZodEnum<{
+        error: "error";
+        complete: "complete";
+    }>;
+    content: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ChatUserMessage = z.infer<typeof ChatUserMessageSchema>;
+declare const ChatAssistantMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodLiteral<"assistant">;
+    status: z.ZodEnum<{
+        error: "error";
+        complete: "complete";
+        streaming: "streaming";
+        thinking: "thinking";
+    }>;
+    content: z.ZodString;
+    parts: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool_call">;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            done: "done";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">>>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ChatAssistantMessage = z.infer<typeof ChatAssistantMessageSchema>;
+/**
+ * System messages bypass `renderAssistantContent` / `renderUserContent`.
+ * `content` is `ReactNode` (not validated by Zod beyond presence) so consumers
+ * can drop in formatted blocks ("Conversation started", session expiry notes).
+ */
+export interface ChatSystemMessage {
+    id: string;
+    role: 'system';
+    status: 'complete';
+    content: ReactNode;
+    /** Default false — system messages are visual-only. Set true to announce via the status region. */
+    announce?: boolean;
+    createdAt?: number;
+}
+export declare const ChatMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodLiteral<"user">;
+    status: z.ZodEnum<{
+        error: "error";
+        complete: "complete";
+    }>;
+    content: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodLiteral<"assistant">;
+    status: z.ZodEnum<{
+        error: "error";
+        complete: "complete";
+        streaming: "streaming";
+        thinking: "thinking";
+    }>;
+    content: z.ZodString;
+    parts: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool_call">;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            done: "done";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">>>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodLiteral<"system">;
+    status: z.ZodLiteral<"complete">;
+    content: z.ZodUnknown;
+    announce: z.ZodOptional<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;
+export type ChatMessage = ChatUserMessage | ChatAssistantMessage | ChatSystemMessage;
+/**
+ * Props ChatInterface passes to the input component (default OR custom).
+ *
+ * Trust boundary: the input emits `markdown: string` via `onSubmit`. ChatInterface
+ * treats it as opaque and forwards to `props.onSendMessage`. Sanitisation is the
+ * consumer's responsibility (in `renderAssistantContent` / `renderUserContent`).
+ */
+export interface ChatInputComponentProps {
+    /** True while top-level status is streaming/error or consumer-disabled. Custom inputs MUST honour. */
+    isDisabled: boolean;
+    placeholder?: string;
+    /** Best-effort cap. Default input enforces strictly; ChatInterface enforces a defence-in-depth backstop. */
+    maxLength?: number;
+    'aria-label'?: string;
+    /**
+     * Called when the user confirms (Enter, Cmd+Enter, RTE submit, etc.).
+     * The string MUST be markdown. Must NOT be called with empty/whitespace.
+     */
+    onSubmit: (markdown: string) => void;
+    /**
+     * Optional. Fires on value changes for char-count UX or analytics.
+     * Custom inputs MAY debounce or throttle. ChatInterface does NOT use this to drive Send button state —
+     * Send is always enabled when ChatInterface isn't disabled.
+     */
+    onChange?: (markdown: string) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+}
+/**
+ * Imperative methods the input must expose via `forwardRef` + `useImperativeHandle`.
+ */
+export interface ChatInputComponentHandle {
+    /** Move focus to the input. ChatInterface delegates `chatRef.current.focusInput()` here. */
+    focus: () => void;
+    /** Reset the input's value. Called after a successful send. */
+    clear: () => void;
+    /**
+     * Trigger a submit. The input extracts its current value and invokes its own `onSubmit`.
+     * No-op when empty/whitespace — never calls `onSubmit` with empty string.
+     * This empty-guard is the contract: Send button is always enabled when ChatInterface isn't disabled,
+     * and harmless clicks on an empty input produce no message.
+     */
+    submit: () => void;
+    /**
+     * Programmatically set the input's value (suggested-question prefill, edit-prior-message).
+     * Does NOT change focus. Cursor lands at end. Consumers wanting focus call `focus()` separately.
+     * `setValue` followed by `submit` is a documented feature; consumers wanting human-only origination
+     * should track origination state themselves.
+     */
+    setValue: (markdown: string) => void;
+}
+export type ChatInputComponent = ForwardRefExoticComponent<ChatInputComponentProps & RefAttributes<ChatInputComponentHandle>>;
+export interface ChatInterfaceHandle {
+    focusInput: () => void;
+    scrollToBottom: (opts?: {
+        smooth?: boolean;
+    }) => void;
+}
+/**
+ * Zod schema for runtime validation. Production callers should not invoke `.parse()` —
+ * internal validation is dev-only.
+ */
+export declare const ChatInterfacePropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    children: z.ZodOptional<z.ZodAny>;
+    id: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        streaming: "streaming";
+        idle: "idle";
+    }>;
+    messages: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodLiteral<"user">;
+        status: z.ZodEnum<{
+            error: "error";
+            complete: "complete";
+        }>;
+        content: z.ZodString;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodLiteral<"assistant">;
+        status: z.ZodEnum<{
+            error: "error";
+            complete: "complete";
+            streaming: "streaming";
+            thinking: "thinking";
+        }>;
+        content: z.ZodString;
+        parts: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"tool_call">;
+            name: z.ZodString;
+            status: z.ZodEnum<{
+                error: "error";
+                running: "running";
+                done: "done";
+            }>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "kind">>>;
+        errorMessage: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodLiteral<"system">;
+        status: z.ZodLiteral<"complete">;
+        content: z.ZodUnknown;
+        announce: z.ZodOptional<z.ZodBoolean>;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    onSendMessage: z.ZodCustom<(text: string) => void, (text: string) => void>;
+    onStopGeneration: z.ZodOptional<z.ZodCustom<() => void, () => void>>;
+    onRetry: z.ZodOptional<z.ZodCustom<(messageId: string) => void, (messageId: string) => void>>;
+    onEscalate: z.ZodOptional<z.ZodCustom<() => void, () => void>>;
+    renderAssistantContent: z.ZodOptional<z.ZodAny>;
+    renderUserContent: z.ZodOptional<z.ZodAny>;
+    inputComponent: z.ZodOptional<z.ZodAny>;
+    assistantAvatar: z.ZodOptional<z.ZodAny>;
+    userAvatar: z.ZodOptional<z.ZodAny>;
+    header: z.ZodOptional<z.ZodAny>;
+    emptyState: z.ZodOptional<z.ZodAny>;
+    inputActions: z.ZodOptional<z.ZodAny>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    isDisabled: z.ZodOptional<z.ZodBoolean>;
+    maxInputLength: z.ZodOptional<z.ZodNumber>;
+    sendShortcut: z.ZodOptional<z.ZodEnum<{
+        enter: "enter";
+        "mod-enter": "mod-enter";
+    }>>;
+    progressAnnouncements: z.ZodOptional<z.ZodBoolean>;
+    completionAnnouncementMaxChars: z.ZodOptional<z.ZodNumber>;
+    logLabel: z.ZodOptional<z.ZodString>;
+    thinkingDisclosureLabel: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Render-prop renderers. Consumers parse markdown and produce a ReactNode.
+ * MUST be pure render functions — no side effects. MUST NOT include `aria-live`,
+ * `aria-busy`, or `role="log"` (ChatInterface owns the live-region semantics).
+ */
+export type ChatAssistantRenderer = (message: ChatAssistantMessage) => ReactNode;
+export type ChatUserRenderer = (message: ChatUserMessage) => ReactNode;
+export interface ChatInterfaceProps {
+    /**
+     * The full conversation transcript. ChatInterface is fully controlled — the consumer
+     * owns this array and updates it via setState/reducer/etc.
+     *
+     * IMMUTABILITY: Pass a new message object when its `content`, `parts`, `status`,
+     * `errorMessage`, or `createdAt` changes. In-place mutation will not re-render.
+     */
+    messages: ChatMessage[];
+    /** Top-level status drives the input area (Send vs Stop, disabled state). */
+    status: ChatTopLevelStatus;
+    /** Required when status can be 'streaming'. */
+    onSendMessage: (text: string) => void;
+    onStopGeneration?: () => void;
+    onRetry?: (messageId: string) => void;
+    onEscalate?: () => void;
+    /** @see ChatAssistantRenderer for purity rules. */
+    renderAssistantContent?: ChatAssistantRenderer;
+    renderUserContent?: ChatUserRenderer;
+    /** Custom input component honouring the ChatInputComponent contract. Defaults to the built-in Themis-styled multi-line input. */
+    inputComponent?: ChatInputComponent;
+    /** Memoize inline JSX (e.g. `useMemo(() => <Avatar ... />, [])`) so it doesn't bust the bubble memo. */
+    assistantAvatar?: ReactNode;
+    userAvatar?: ReactNode;
+    header?: ReactNode;
+    emptyState?: ReactNode;
+    inputActions?: ReactNode;
+    placeholder?: string;
+    isDisabled?: boolean;
+    maxInputLength?: number;
+    /** Default 'enter'. 'mod-enter' = Cmd/Ctrl+Enter. Only honoured by the default input. */
+    sendShortcut?: 'enter' | 'mod-enter';
+    /**
+     * Default true. When false, suppresses the bounded "still working" pings (3s/15s/60s slow-response safety net).
+     * Note: disabling removes the only AT signal of a hung stream.
+     */
+    progressAnnouncements?: boolean;
+    /** Default 200. Clamped to [50, 1000] at runtime; out-of-range values dev-warn and clamp. */
+    completionAnnouncementMaxChars?: number;
+    'aria-label'?: string;
+    /** Default "Conversation transcript". */
+    logLabel?: string;
+    /** Default "Thoughts". */
+    thinkingDisclosureLabel?: string;
+    className?: string;
+    'data-testid'?: string;
+}
+export {};
+//# sourceMappingURL=ChatInterface.types.d.ts.map

package/dist/elements/ChatInterface/ChatInterface.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatInterface.types.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatInterface.types.ts"],"names":[],"mappings":"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"}

package/dist/elements/ChatInterface/ChatLiveRegions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Single sr-only `role="status"` region — the canonical AT announcement channel.
+ * The log region (separate component) has NO `aria-live`; all announcements flow through here.
+ *
+ * @see ChatInterface.hooks.ts → useAnnouncementQueue for the FIFO + dedup + rate-limit logic.
+ */
+declare const ChatLiveRegions: import("react").NamedExoticComponent<{
+    current: string;
+    className?: string;
+    testId?: string;
+}>;
+export { ChatLiveRegions };
+//# sourceMappingURL=ChatLiveRegions.d.ts.map

package/dist/elements/ChatInterface/ChatLiveRegions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatLiveRegions.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatLiveRegions.tsx"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,QAAA,MAAM,eAAe;aAKV,MAAM;gBACH,MAAM;aACT,MAAM;EAaf,CAAC;AAEH,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/elements/ChatInterface/ChatMessageBubble.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+import type { ChatAssistantRenderer, ChatMessage, ChatUserRenderer } from './ChatInterface.types';
+/**
+ * Single message bubble. Memoized with a custom comparator covering all visual-relevant fields.
+ *
+ * IMMUTABILITY: consumers MUST pass a new message object when content/parts/status/errorMessage/createdAt changes.
+ * In-place mutation will not re-render. (Documented on the public `messages` prop.)
+ */
+interface BubbleProps {
+    message: ChatMessage;
+    isStreamingHere: boolean;
+    isOffscreen: boolean;
+    assistantAvatar?: ReactNode;
+    userAvatar?: ReactNode;
+    renderAssistantContent?: ChatAssistantRenderer;
+    renderUserContent?: ChatUserRenderer;
+    thinkingDisclosureLabel: string;
+    contentRef?: React.RefCallback<HTMLDivElement>;
+    onRetry?: (id: string) => void;
+    onEscalate?: () => void;
+}
+declare const ChatMessageBubble: import("react").NamedExoticComponent<BubbleProps>;
+export { ChatMessageBubble };
+//# sourceMappingURL=ChatMessageBubble.d.ts.map

package/dist/elements/ChatInterface/ChatMessageBubble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatMessageBubble.d.ts","sourceRoot":"","sources":["../../../src/elements/ChatInterface/ChatMessageBubble.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAY7C,OAAO,KAAK,EAEV,qBAAqB,EACrB,WAAW,EAGX,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAE/B;;;;;GAKG;AAEH,UAAU,WAAW;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,SAAS,CAAC;IAC5B,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,sBAAsB,CAAC,EAAE,qBAAqB,CAAC;IAC/C,iBAAiB,CAAC,EAAE,gBAAgB,CAAC;IACrC,uBAAuB,EAAE,MAAM,CAAC;IAChC,UAAU,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAqDD,QAAA,MAAM,iBAAiB,mDAqCH,CAAC;AA6JrB,OAAO,EAAE,iBAAiB,EAAE,CAAC"}