@tribepad/themis 1.10.1 → 1.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tribepad/themis",
-  "version": "1.10.1",
+  "version": "1.11.2",
   "description": "Accessible React component library built on React Aria primitives",
   "author": "Tribepad <mbasford@tribepad.com>",
   "license": "MIT",
@@ -152,45 +152,45 @@
     "@internationalized/date": "^3.12.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "react-aria": "^3.49.0",
-    "react-aria-components": "^1.18.0",
-    "react-stately": "^3.47.0",
+    "react-aria": "^3.50.0",
+    "react-aria-components": "^1.19.0",
+    "react-stately": "^3.48.0",
     "tailwind-merge": "^3.6.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@size-limit/preset-small-lib": "^12.1.0",
-    "@storybook/addon-a11y": "^10.4.4",
-    "@storybook/addon-mcp": "^0.6.0",
-    "@storybook/react-vite": "^10.4.4",
+    "@storybook/addon-a11y": "^10.5.0",
+    "@storybook/addon-mcp": "^0.7.0",
+    "@storybook/react-vite": "^10.5.0",
     "@tailwindcss/vite": "^4.3.2",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
-    "@types/node": "^26.1.0",
+    "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
-    "@typescript-eslint/eslint-plugin": "^8.62.1",
-    "@typescript-eslint/parser": "^8.62.1",
-    "@vitejs/plugin-react": "^6.0.2",
+    "@typescript-eslint/eslint-plugin": "^8.63.0",
+    "@typescript-eslint/parser": "^8.63.0",
+    "@vitejs/plugin-react": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",
-    "eslint": "^10.6.0",
+    "eslint": "^10.7.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-storybook": "10.4.4",
-    "globals": "^17.6.0",
-    "happy-dom": "^20.10.2",
+    "eslint-plugin-storybook": "10.5.0",
+    "globals": "^17.7.0",
+    "happy-dom": "^20.10.6",
     "jest-axe": "^10.0.0",
     "jsdom": "^29.1.1",
-    "lucide-react": "^1.23.0",
+    "lucide-react": "^1.24.0",
     "motion": "^12.42.2",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "size-limit": "^12.1.0",
-    "storybook": "^10.4.4",
+    "storybook": "^10.5.0",
     "tsup": "^8.5.1",
-    "tsx": "^4.23.0",
+    "tsx": "^4.23.1",
     "typescript": "^6.0.3",
-    "vite": "^8.1.3",
+    "vite": "^8.1.4",
     "vitest": "^4.1.10",
     "zod": "^4.4.3"
   },
@@ -201,7 +201,8 @@
     "overrides": {
       "postcss@<8.5.10": "^8.5.12",
       "undici@>=7.0.0 <7.28.0": "^7.28.0",
-      "@babel/core@<=7.29.0": "^7.29.6"
+      "@babel/core@<=7.29.0": "^7.29.6",
+      "esbuild@<0.28.1": "^0.28.1"
     }
   },
   "engines": {

package/src/elements/Sidebar/Sidebar.stories.tsx

@@ -321,6 +321,31 @@ export const LinkItems: Story = {
   ),
 };
 
+/**
+ * Rail items that navigate via a plain `<a href>` (`routing="native"`), bypassing
+ * React Aria's router. Use for cross-app/zone links whose href must be literal,
+ * and so an app-level capture handler (e.g. an unsaved-changes guard) can
+ * intercept the click — a real anchor is required for that.
+ */
+export const NativeRoutingLinkItems: Story = {
+  render: () => (
+    <div className="flex h-screen bg-[var(--page-background)]">
+      <Sidebar>
+        <Sidebar.Rail aria-label="Main navigation">
+          <Sidebar.RailItem id="home" icon={<Home />} label="Home" href="/" routing="native" isActive />
+          <Sidebar.RailItem id="docs" icon={<FileText />} label="Docs" href="/docs" routing="native" />
+          <Sidebar.RailItem id="help" icon={<HelpCircle />} label="Help" href="/help" routing="native" />
+        </Sidebar.Rail>
+      </Sidebar>
+      <main className="flex-1 p-6">
+        <p className="text-[var(--page-foreground)]">
+          These rail items render as plain anchors the browser navigates directly.
+        </p>
+      </main>
+    </div>
+  ),
+};
+
 /** Default rail variant */
 export const DefaultRail: Story = {
   render: () => <SidebarDemo showPopovers railVariant="default" />,

package/src/elements/ChatInterface/README.md

@@ -1,408 +0,0 @@
-# ChatInterface
-
-Accessible chatbot UI element for Themis. WCAG 2.2 AAA compliant. Designed to host AI support chatbots — the consumer owns the messages, status, and websocket; ChatInterface renders the transcript, manages keyboard/screen-reader concerns, and emits events.
-
-## Quick start
-
-```tsx
-import { useState } from 'react';
-import { ChatInterface, type ChatMessage } from '@tribepad/themis/elements/ChatInterface';
-
-function SupportChat() {
-  const [messages, setMessages] = useState<ChatMessage[]>([]);
-  const [status, setStatus] = useState<'idle' | 'streaming' | 'error'>('idle');
-
-  const handleSend = (text: string) => {
-    setMessages((m) => [
-      ...m,
-      { id: crypto.randomUUID(), role: 'user', status: 'complete', content: text },
-    ]);
-    // Wire up your AI call / websocket here. As tokens arrive, push a NEW assistant
-    // message object — never mutate in place. See "Performance rules" below.
-  };
-
-  return (
-    <div style={{ height: 600 }}>
-      <ChatInterface
-        messages={messages}
-        status={status}
-        onSendMessage={handleSend}
-      />
-    </div>
-  );
-}
-```
-
-The component fills its container — give it a fixed-height parent (page, panel, modal).
-
-## Mental model
-
-ChatInterface is **fully controlled**. Every piece of conversation state lives in the consumer; ChatInterface is a presentation layer.
-
-| Responsibility | Owner |
-|---|---|
-| `messages[]` array | Consumer |
-| Streaming over websocket | Consumer |
-| Persistence / history | Consumer |
-| Markdown parsing & sanitisation | Consumer (via render prop) |
-| Talking-to-a-human form | Consumer (fires `onEscalate`) |
-| Visual rendering | ChatInterface |
-| Keyboard handling | ChatInterface |
-| Live-region announcements to screen readers | ChatInterface |
-| 44×44 touch targets for buttons | ChatInterface |
-| Auto-scroll, auto-resize input, IME handling | ChatInterface |
-
-## Message types
-
-`messages` is a discriminated union over `role`. Each entry has `id`, `role`, `status`, optional `createdAt`, and role-specific fields.
-
-```ts
-type ChatRole = 'user' | 'assistant' | 'system';
-type ChatMessageStatus = 'complete' | 'streaming' | 'thinking' | 'error';
-
-interface ChatUserMessage {
-  id: string;
-  role: 'user';
-  status: 'complete' | 'error';   // user messages never stream/think
-  content: string;
-  createdAt?: number;
-}
-
-interface ChatAssistantMessage {
-  id: string;
-  role: 'assistant';
-  status: ChatMessageStatus;
-  content: string;                 // markdown source (consumer renders)
-  parts?: ThinkingPart[];          // visible thinking / tool calls
-  errorMessage?: string;           // free-form error detail
-  createdAt?: number;
-}
-
-interface ChatSystemMessage {
-  id: string;
-  role: 'system';
-  status: 'complete';
-  content: ReactNode;              // free-form (already-rendered React node)
-  announce?: boolean;              // default false (visual-only)
-  createdAt?: number;
-}
-
-type ThinkingPart =
-  | { kind: 'text'; text: string }
-  | { kind: 'tool_call'; name: string; status: 'running' | 'done' | 'error'; summary?: string };
-```
-
-### Status states
-
-The top-level `status` prop drives the **input area** (Send vs Stop button, disabled state). Each message also has a `status` field describing its own lifecycle.
-
-| Top-level `status` | Send button | Stop button | Input |
-|---|---|---|---|
-| `idle` | enabled | hidden | enabled |
-| `streaming` | hidden | enabled | disabled |
-| `error` | enabled | hidden | disabled |
-
-Per-message status drives bubble rendering:
-
-| `message.status` | Visual |
-|---|---|
-| `complete` | normal bubble |
-| `thinking` | "Thinking…" pill + tool-call rows visible |
-| `streaming` | typing dots indicator |
-| `error` | destructive border + `errorMessage` + Try again / Submit a support request buttons |
-
-At most one assistant message can be `streaming` or `thinking` at a time. Dev mode warns if more than one is found.
-
-## Markdown rendering — read this carefully
-
-ChatInterface treats `message.content` as **opaque** — it does NOT parse or sanitise markdown. Consumers wire up their own renderer via two render props:
-
-```tsx
-<ChatInterface
-  ...
-  renderAssistantContent={(message) => /* return ReactNode */}
-  renderUserContent={(message) => /* return ReactNode */}
-/>
-```
-
-If you don't pass these, content renders as plain text in `<div className="whitespace-pre-wrap">{content}</div>`. Markdown source will be visible verbatim — which is ugly but unambiguous.
-
-### Recommended setup with `react-markdown`
-
-This is the **minimum safe configuration**. Removing any of these allows XSS via assistant content (which is attacker-influenced if your LLM is exposed to user input):
-
-```tsx
-import ReactMarkdown from 'react-markdown';
-import rehypeSanitize from 'rehype-sanitize';
-
-const MarkdownRenderer = ({ content }: { content: string }) => (
-  <ReactMarkdown
-    rehypePlugins={[rehypeSanitize]}
-    urlTransform={(url) => {
-      // Strip dangerous schemes from links and images.
-      const lower = url.toLowerCase().trim();
-      if (lower.startsWith('javascript:') || lower.startsWith('data:') || lower.startsWith('vbscript:') || lower.startsWith('file:')) {
-        return '';
-      }
-      return url;
-    }}
-    components={{
-      a: ({ href, children, ...props }) => (
-        <a href={href} target="_blank" rel="noopener noreferrer nofollow" {...props}>
-          {children}
-        </a>
-      ),
-      // Disable images by default — assistant-controlled image URLs are a tracking-pixel /
-      // SSRF / CSP risk. Opt back in only if you've configured CSP `img-src` and you
-      // trust the assistant's content origin.
-      img: () => null,
-    }}
-  >
-    {content}
-  </ReactMarkdown>
-);
-
-<ChatInterface
-  ...
-  renderAssistantContent={(m) => <MarkdownRenderer content={m.content} />}
-/>
-```
-
-### Things you must NOT do inside renderers
-
-- **Do not** include `aria-live`, `aria-busy`, or `role="log"` attributes anywhere in your rendered output. ChatInterface owns the live-region semantics; nesting another live region inside the log breaks the AT announcement strategy. (Dev mode warns if it detects this.)
-- **Do not** run side effects (focus management, fetches, state updates). Renderers must be pure.
-- **Do not** emit `data-action="retry"` or `data-action="stop"` / `data-action="send"` / `data-action="jump-to-latest"` / `data-action="escalate"` — these are reserved attributes ChatInterface uses to find its own controls.
-
-## Custom input
-
-The default input is a Themis-styled multi-line textarea (Enter sends, Shift+Enter newlines). To swap in your own — typically a rich-text editor that outputs markdown — pass `inputComponent`:
-
-```tsx
-import { forwardRef, useImperativeHandle, useRef } from 'react';
-import type { ChatInputComponent, ChatInputComponentHandle } from '@tribepad/themis/elements/ChatInterface';
-
-const RichInput: ChatInputComponent = forwardRef(function RichInput(
-  { isDisabled, placeholder, onSubmit, onChange, onFocus, onBlur, 'aria-label': ariaLabel },
-  ref
-) {
-  const editorRef = useRef<HTMLDivElement>(null);
-
-  useImperativeHandle(ref, (): ChatInputComponentHandle => ({
-    focus: () => editorRef.current?.focus(),
-    clear: () => { /* reset your editor's value */ },
-    submit: () => {
-      // Extract the editor's current value AS MARKDOWN and call onSubmit.
-      // No-op if empty/whitespace — never call onSubmit with empty string.
-      const md = readMarkdownFromEditor();
-      if (md.trim()) onSubmit(md);
-    },
-    setValue: (md) => { /* parse markdown back into your editor's state */ },
-  }));
-
-  return <div ref={editorRef} contentEditable={!isDisabled} aria-label={ariaLabel} ... />;
-});
-```
-
-### Custom input contract
-
-ChatInterface gives the input these props:
-
-- `isDisabled: boolean` — true while top-level status is `streaming` / `error` or consumer-disabled. **Must** be honoured (check synchronously in your submit handler).
-- `placeholder?: string`
-- `maxLength?: number` — best-effort. ChatInterface enforces a defence-in-depth backstop on receive.
-- `'aria-label'?: string`
-- `onSubmit: (markdown: string) => void` — call when user confirms.
-- `onChange?: (markdown: string) => void` — optional; fire on changes for char counts. **Not** used by ChatInterface to drive Send button state.
-- `onFocus?: () => void` / `onBlur?: () => void`
-
-The input MUST expose this imperative handle:
-
-- `focus(): void`
-- `clear(): void` — called after a successful send.
-- `submit(): void` — called when Send button is pressed; extract value and invoke `onSubmit`. **Must no-op on empty/whitespace.**
-- `setValue(markdown: string): void` — programmatic prefill (suggested-question UX). Should not change focus; cursor should land at end.
-
-### Custom input rules
-
-- **Do NOT** render your own submit button. Send/Stop is owned by ChatInterface. Use ChatInterface's `inputActions` slot for additional buttons (attach, model picker, etc.).
-- IME composition handling is your responsibility. The default input checks `event.isComposing || event.keyCode === 229` on keydown.
-- If you provide `inputComponent`, you should also provide `renderUserContent` — otherwise user messages render as raw markdown source. Dev mode warns.
-
-## Performance rules
-
-ChatInterface is heavily memoised. **Following these two rules is the difference between smooth streaming and dropped frames at 30–100Hz token rates:**
-
-### 1. Pass new message objects on update
-
-When a message's `content`, `parts`, `status`, `errorMessage`, or `createdAt` changes, pass a **new object**:
-
-```tsx
-// CORRECT
-setMessages((m) =>
-  m.map((msg) =>
-    msg.id === streamingId ? { ...msg, content: msg.content + token } : msg
-  )
-);
-
-// WRONG — mutates in place; bubble will not re-render
-const target = messages.find((m) => m.id === streamingId);
-target.content += token;
-setMessages([...messages]);
-```
-
-### 2. Memoize render-prop functions and avatar nodes
-
-```tsx
-// CORRECT — stable references; bubble memo holds.
-const renderAssistantContent = useCallback(
-  (m: ChatAssistantMessage) => <MarkdownRenderer content={m.content} />,
-  []
-);
-const assistantAvatar = useMemo(() => <Avatar src={...} />, []);
-
-<ChatInterface
-  renderAssistantContent={renderAssistantContent}
-  assistantAvatar={assistantAvatar}
-  ...
-/>
-
-// WRONG — fresh references every render bust the bubble memo,
-// re-running your markdown parser on every completed message every token tick.
-<ChatInterface
-  renderAssistantContent={(m) => <MarkdownRenderer content={m.content} />}
-  assistantAvatar={<Avatar src={...} />}
-  ...
-/>
-```
-
-When `renderAssistantContent` is stable, ChatInterface caches the rendered ReactNode for each completed message in a bounded LRU (max 200 entries) keyed on `(id, content)` — your parser only runs once per message, not per render.
-
-### 3. Optional: wrap completion-flip in `startTransition`
-
-For best perceived perf when transitioning a streaming message to `complete`, wrap the final state update in a transition:
-
-```tsx
-import { startTransition } from 'react';
-
-// Completion arrives:
-startTransition(() => {
-  setMessages((m) =>
-    m.map((msg) => msg.id === streamingId ? { ...msg, status: 'complete', content: final } : msg)
-  );
-  setStatus('idle');
-});
-```
-
-This lets React keep painting incoming tokens with priority over the heavier completion render.
-
-## Accessibility behaviour
-
-### Live regions
-
-ChatInterface uses a two-region pattern:
-
-- **Log region** (`role="log"` + `aria-label` + `tabIndex={0}`) — visual + navigable. **No `aria-live`.** Screen reader users locate it via landmarks/rotor and navigate with arrow keys. Token mutations during streaming do NOT announce.
-- **Status region** (sr-only `role="status"` + `aria-live="polite"`) — single canonical AT announcement channel. FIFO queue with 500ms minimum interval and 1s dedup window.
-
-### What gets announced
-
-- **Response complete** — `"Assistant replied: <first ~200 chars of rendered text>"` (truncated with "…full response in transcript" if longer). Built from the bubble's rendered DOM `innerText` after commit; Unicode-normalised (control chars / zero-width / bidi overrides stripped) before announcement.
-- **Generation stopped** — `"Generation stopped"` exactly, when top-level status flips `streaming → idle`.
-- **Response failed** — `"Response failed"` exactly, when an assistant message transitions to `status: 'error'`. Never interpolates `errorMessage` (errored bubble carries the full text visibly + via AT navigation). On error transition, focus moves from the now-vanished Stop button to "Try again".
-- **Bounded "still working"** — `"Assistant is still working"` after 3s, 15s, 60s of token silence during streaming. Capped at 3 announcements per stream. Gated on `document.visibilityState === 'visible'`. Suppressible via `progressAnnouncements={false}`.
-
-### What does NOT get announced
-
-- Per-token streaming text mutations.
-- Thinking-state entry. (No proactive ping; the bounded "still working" timer at 3s+ covers slow responses.)
-- Tool-call transitions (running → done → error).
-- New user messages.
-- Send/Stop/Clear button presses (the underlying actions are user-initiated; AT users already know they pressed the button).
-
-### Reduced motion
-
-When the OS preference `prefers-reduced-motion: reduce` is on, ChatInterface suppresses motion in three ways:
-
-- **Streaming text is not revealed token-by-token.** Mid-stream, the bubble shows a static "Generating response…" placeholder and non-animated typing dots; the full message snaps into place when status flips to `complete`. This avoids layout-shift / scroll-anchor churn that some users find disorienting.
-- **Animations** (typing dots, "Thinking…" pill pulse, running tool-call spinner) are static.
-- **Auto-scroll** ignores the `smooth: true` option — scroll is always instant.
-
-Thinking phase is unaffected — it already renders static parts and a (gated) pill, with no tokens streaming.
-
-### Keyboard
-
-- **Tab** order: log region → input → Send / Stop → input actions slot → escalation buttons.
-- **Enter** sends; **Shift+Enter** inserts a newline.
-- **`sendShortcut: 'mod-enter'`** opt-in: requires Cmd/Ctrl+Enter to send (Enter alone inserts newline).
-- IME composition is respected — Enter while composing does not send.
-- The log region is keyboard-focusable so users can arrow-scroll the transcript.
-- The "Thoughts" disclosure under thinking-equipped messages is a native `<details>`/`<summary>` — keyboard-toggleable, AT-friendly without ARIA.
-
-## Imperative handle
-
-```tsx
-import { useRef } from 'react';
-import type { ChatInterfaceHandle } from '@tribepad/themis/elements/ChatInterface';
-
-const ref = useRef<ChatInterfaceHandle>(null);
-
-ref.current?.focusInput();              // moves focus into the textarea / custom input
-ref.current?.scrollToBottom({ smooth: true });  // jumps the log to latest (smooth respects reduced-motion)
-```
-
-`scrollToMessage` is intentionally not exposed in v1 — there's no concrete consumer use case yet. Open a PR if you need it.
-
-## Props reference
-
-| Prop | Type | Default | Notes |
-|---|---|---|---|
-| `messages` | `ChatMessage[]` | required | Pass new objects on update — see Performance rules. |
-| `status` | `'idle' \| 'streaming' \| 'error'` | required | |
-| `onSendMessage` | `(text: string) => void` | required | Synchronous. ChatInterface enforces `maxInputLength` truncation before calling. |
-| `onStopGeneration` | `() => void` | — | Required when `status` can be `'streaming'`. |
-| `onRetry` | `(messageId: string) => void` | — | Renders Try again button on errored bubbles. |
-| `onEscalate` | `() => void` | — | Renders Submit-a-support-request button on errored bubbles. |
-| `renderAssistantContent` | `(m: ChatAssistantMessage) => ReactNode` | plain text | Pure render function. Memoize for cache to work. |
-| `renderUserContent` | `(m: ChatUserMessage) => ReactNode` | plain text | |
-| `inputComponent` | `ChatInputComponent` | built-in textarea | Custom input. See Custom input section. |
-| `assistantAvatar` | `ReactNode` | — | Memoize to avoid memo-busting. |
-| `userAvatar` | `ReactNode` | — | Memoize to avoid memo-busting. |
-| `header` | `ReactNode` | — | Slot above the log. |
-| `emptyState` | `ReactNode` | — | Rendered inside the log when `messages.length === 0`. |
-| `inputActions` | `ReactNode` | — | Buttons beside Send/Stop (attach, model picker, etc.). |
-| `placeholder` | `string` | `'Type a message…'` | |
-| `isDisabled` | `boolean` | `false` | Forces input + Send disabled. |
-| `maxInputLength` | `number` | — | Defence-in-depth truncation at the ChatInterface boundary. |
-| `sendShortcut` | `'enter' \| 'mod-enter'` | `'enter'` | Default-input only. Custom inputs choose their own keybindings. |
-| `progressAnnouncements` | `boolean` | `true` | When false, suppresses bounded "still working" pings. |
-| `completionAnnouncementMaxChars` | `number` | `200` | Clamped to [50, 1000]; out-of-range values dev-warn. |
-| `aria-label` | `string` | `'Chat'` | Region label. |
-| `logLabel` | `string` | `'Conversation transcript'` | |
-| `thinkingDisclosureLabel` | `string` | `'Thoughts'` | i18n hook. |
-
-## Limitations (v1)
-
-- **Long conversations** — `content-visibility: auto` skips layout for offscreen bubbles, which keeps things smooth up to ~1000–2000 messages on a mid-range device. Beyond that, consider paginating in your consumer state. Full virtualisation is a v2 candidate when concrete demand arrives. Dev mode warns when `messages.length > 1000`.
-- **Multi-part assistant messages** — assistant `content` is a single string. Interleaved `[text, tool_call, text]` content (common in agent-style assistants) is not modelled in v1; tool calls are visible separately via `parts[]` but inline-with-text is not. Parts-first model is a v2 candidate, non-breaking when added.
-- **Attachments** — user messages are text-only. File/image attachments need to be added via the `inputActions` slot for the upload UI and sent through your own `onSendMessage` channel; the rendered version goes through `renderUserContent`. Native attachment data on user messages is a v2 candidate.
-- **System message renderers** — system messages bypass `renderAssistantContent` / `renderUserContent`. Their `content` is `ReactNode`, so render whatever you want — but they're not run through the markdown render pipeline.
-- **Citations** — RAG-style `[1][2]` source markers should be embedded in the assistant's markdown content as standard markdown links. There's no first-class citation type in v1.
-- **Multi-AI persona avatars** — `assistantAvatar` is a single prop, not per-message. If your conversation has multiple assistants, you'll need to encode persona via `renderAssistantContent` styling.
-- **Message editing / deletion UX** — not modelled. The data model supports it (consumer can omit a deleted message from `messages`), but the bubble itself doesn't render edit/delete controls. Add via custom render prop if needed.
-- **Copy / regenerate buttons** — not provided. Add via your `renderAssistantContent` render prop.
-- **Reactions** — not modelled.
-
-## Trusted Types compatibility
-
-ChatInterface is Trusted Types compatible. It does not assign user-controlled strings to `innerHTML`, `outerHTML`, `insertAdjacentHTML`, `setHTMLUnsafe`, `document.write`, `Range.createContextualFragment`, or `DOMParser.parseFromString`-with-HTML. If you adopt `react-markdown` for rendering, verify your specific configuration is TT-compatible (`rehype-raw` is not).
-
-## Storybook examples
-
-`pnpm storybook`, then look at `Elements/ChatInterface`. Stories cover:
-
-- Empty / Plain / Streaming / Thinking / ErrorState
-- BYO Markdown (with the recommended secure configuration)
-- Custom input (contenteditable RTE)
-- Long conversation (200 turns)
-- Reduced motion