@alexkroman1/aai-ui 13.2.0 → 14.0.0

package/dist/components/controls.js

@@ -1,10 +1,10 @@
 import { useSessionCore, useSessionSelector } from "../context.js";
 import { Button } from "./button.js";
-import { n as SessionUrlChips } from "../url-chips-YqhCjWfQ.js";
+import { n as SessionUrlChips } from "../url-chips-BxhzZgk2.js";
 import clsx from "clsx";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { memo } from "react";
-//#region components/controls.tsx
+//#region src/components/controls.tsx
 /** @jsxImportSource react */
 /**
 * Session control buttons: **Stop / Resume** and **New Conversation**.
@@ -27,7 +27,7 @@ import { memo } from "react";
 */
 const Controls = memo(function Controls({ className }) {
 	const running = useSessionSelector((s) => s.running);
-	const { toggle, reset } = useSessionCore();
+	const { toggle, restart } = useSessionCore();
 	return /* @__PURE__ */ jsxs("div", {
 		className: clsx("flex flex-wrap items-center gap-3 shrink-0", className),
 		children: [
@@ -38,7 +38,7 @@ const Controls = memo(function Controls({ className }) {
 			}),
 			/* @__PURE__ */ jsx(Button, {
 				variant: "ghost",
-				onClick: reset,
+				onClick: restart,
 				children: "New Conversation"
 			}),
 			/* @__PURE__ */ jsx(SessionUrlChips, { className: "basis-full sm:basis-auto sm:ml-auto sm:max-w-[60%]" })

package/dist/components/facts.d.ts

@@ -0,0 +1,81 @@
+import type { ReactNode } from "react";
+/**
+ * Props for {@link Facts}.
+ *
+ * @public
+ */
+export type FactsProps = {
+    /**
+     * The facts, in reading order. Anything `false`, `null`, `undefined` or the
+     * empty string is DROPPED, so a page writes `cond && \`${n} skipped\`` inline
+     * instead of splicing a separator into a conditional string.
+     *
+     * `0` is NOT dropped — it is a fact ("0 words"), and treating it as absent is
+     * the bug a plain truthiness filter would ship.
+     *
+     * They are TEXT rather than `ReactNode`: every one of the nine lines this
+     * replaced was a string, and taking strings is what lets this JOIN them (see
+     * the component doc) instead of interleaving keyed separator elements.
+     */
+    items: readonly (string | number | false | null | undefined)[];
+    /**
+     * Which of the two muted typographies the pages use. `"sm"` is
+     * `text-sm opacity-70`, `"xs"` is `text-xs opacity-60` — the size and the
+     * muting move together, because that is the pair every site had.
+     */
+    size?: "sm" | "xs" | undefined;
+    /**
+     * The element to render. `"p"` by default; `"span"` for a line that sits
+     * inside phrasing content, where a `<p>` is invalid nesting the browser will
+     * reparent out from under React.
+     */
+    as?: "p" | "span" | undefined;
+    /**
+     * ADDED to the base classes rather than replacing them — `tabular-nums`,
+     * `uppercase tracking-[1.2px]`. There is no `tailwind-merge` in this package,
+     * so a class that CONFLICTS with a base one is not reliably the winner.
+     */
+    className?: string | undefined;
+};
+/**
+ * A muted line of run facts, joined by `·` — "6 segments · 12:04 of audio ·
+ * 1,840 words".
+ *
+ * Nine pages had written this by hand under four different typographies for
+ * one role, two of them (`call-audit` and `spoken-summary`) byte-identical down
+ * to the payload. Three things it takes off the caller:
+ *
+ * - **The separator cannot be forgotten, and neither can the space around it.**
+ *   Four of the nine carried a literal `{" "}` at the end of a line, because
+ *   Prettier's wrap ate the space that made `· ` read as a separator rather
+ *   than as punctuation glued to the next word. A line that is correct only
+ *   because somebody remembered an invisible JSX expression is exactly the
+ *   thing a component should own.
+ * - **A fact worth omitting is omitted, and by the caller's own condition.**
+ *   The hand-written shape for a conditional fact was to splice the separator
+ *   into the string — `{x ? \` · budget exhausted\` : ""}` — which puts the
+ *   punctuation in two places and gets the leading separator wrong the moment
+ *   the fact before it also disappears. Passing the condition and letting this
+ *   drop it keeps the separator in one place.
+ * - **A line with nothing left to say renders NOTHING.** With every fact
+ *   conditional, the alternative is a muted empty row, or a bare `·`.
+ *
+ * The facts are JOINED into one string rather than interleaved as elements, and
+ * that is why the prop is text: joined, there is no per-fact `key` to invent —
+ * the same reasoning `WorkflowProgress` gives for its log lines. A line that
+ * genuinely needs an element in it (a link) wants its own markup.
+ *
+ * @example
+ * ```tsx
+ * import { Facts } from "@alexkroman1/aai-ui";
+ *
+ * function RunFacts({ words, cut }: { words: number; cut: number }) {
+ *   return <Facts size="xs" items={[`${words} words`, cut > 0 && `${cut} blind cuts`]} />;
+ * }
+ * ```
+ *
+ * @param props - Facts-line props.
+ *
+ * @public
+ */
+export declare function Facts({ items, size, as, className }: FactsProps): ReactNode;

package/dist/components/form-fields.d.ts

@@ -1,5 +1,5 @@
 import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes, TextareaHTMLAttributes } from "react";
-import type { FieldShell, FileRead } from "./form-types.ts";
+import type { FieldShell, FileReadMode } from "./form-types.ts";
 /**
  * Label + control + hint, in the layout every field here uses.
  *
@@ -47,7 +47,7 @@ export declare function Field({ label, hint, htmlFor, className, children, }: {
  *
  * @public
  */
-export declare function TextField({ name, label, hint, className, ...rest }: FieldShell & Omit<InputHTMLAttributes<HTMLInputElement>, "name" | "className">): import("react").JSX.Element;
+export declare function TextField(props: FieldShell & Omit<InputHTMLAttributes<HTMLInputElement>, "name" | "className">): import("react").JSX.Element;
 /**
  * A number input. Contributes a NUMBER to {@link FormValues}, or nothing when
  * left empty.
@@ -60,7 +60,7 @@ export declare function TextField({ name, label, hint, className, ...rest }: Fie
  *
  * @public
  */
-export declare function NumberField({ name, label, hint, className, ...rest }: FieldShell & Omit<InputHTMLAttributes<HTMLInputElement>, "name" | "className" | "type">): import("react").JSX.Element;
+export declare function NumberField(props: FieldShell & Omit<InputHTMLAttributes<HTMLInputElement>, "name" | "className" | "type">): import("react").JSX.Element;
 /**
  * A multi-line text input.
  *
@@ -116,14 +116,14 @@ export declare function CheckboxField({ name, label, hint, className, ...rest }:
  * travel in it. With `upload` the field contributes the `File` itself,
  * `useWorkflowSubmit` stores it through `POST /workflows/uploads` before
  * starting the run, and the input carries the upload id — which a step reads
- * windows of with `readUpload`. Declaring the property in the workflow's
+ * windows of with `stepReadUpload`. Declaring the property in the workflow's
  * `uploads` list makes `<WorkflowFields>` render exactly this, so a declared
  * form needs no file markup at all.
  *
  * **Without it the field describes the file and does not read it.** `read`
  * exists for the cases where the bytes really are small and really are the
  * input — a CSV of ids, a config — and the size is the author's to check. See
- * {@link FileRead} for the four values; `upload` is shorthand for
+ * {@link FileReadMode} for the four values; `upload` is shorthand for
  * `read="upload"`.
  *
  * Otherwise accepts every `<input>` attribute except `name`, `className` and
@@ -136,7 +136,7 @@ export declare function CheckboxField({ name, label, hint, className, ...rest }:
  * @public
  */
 export declare function FileField({ name, label, hint, className, read, upload, ...rest }: FieldShell & {
-    read?: FileRead;
+    read?: FileReadMode;
     /** Shorthand for `read="upload"` — see above. */
     upload?: boolean;
 } & Omit<InputHTMLAttributes<HTMLInputElement>, "name" | "className" | "type">): import("react").JSX.Element;

package/dist/components/form-types.d.ts

@@ -46,7 +46,7 @@ export type FileValue = {
  *
  * @public
  */
-export type FileRead = "none" | "text" | "dataUrl" | "upload";
+export type FileReadMode = "none" | "text" | "dataUrl" | "upload";
 /**
  * The props every field in `form.tsx` shares.
  *

package/dist/components/form.d.ts

@@ -2,7 +2,7 @@ import type { ButtonHTMLAttributes, FormHTMLAttributes, ReactNode } from "react"
 import { type ButtonSize, type ButtonVariant } from "./button.tsx";
 import type { FormValues } from "./form-types.ts";
 export { CheckboxField, Field, FileField, NumberField, SelectField, TextAreaField, TextField, } from "./form-fields.tsx";
-export type { FieldShell, FileRead, FileValue, FormValues } from "./form-types.ts";
+export type { FieldShell, FileReadMode, FileValue, FormValues } from "./form-types.ts";
 /** Props of {@link Form}. */
 export type FormProps = {
     /**

package/dist/components/message-list.js

@@ -1,3 +1,3 @@
-import { t as MessageList } from "../message-list-BJYyuIcR.js";
+import { t as MessageList } from "../message-list-CdOnSh5m.js";
 import "../context.js";
 export { MessageList };

package/dist/components/session-error-banner.d.ts

@@ -0,0 +1,69 @@
+import type { ReactNode } from "react";
+/**
+ * Props of {@link SessionErrorBanner}.
+ *
+ * Every field is optional, so `<SessionErrorBanner />` is the whole call. It is
+ * a NAMED type all the same, for the reason `ControlsProps` and
+ * `ConsoleShellProps` are: an inline object literal in the signature leaves a
+ * `createElement(SessionErrorBanner, { className })` caller unable to infer the
+ * props at all, and gives the reference page nothing to link to.
+ *
+ * @public
+ */
+export type SessionErrorBannerProps = {
+    /** Additional CSS class names for the banner, appended to its own. */
+    className?: string | undefined;
+};
+/**
+ * The announced banner for a failed session: the error's message and code, or
+ * nothing at all when the session is fine.
+ *
+ * **This used to be four lines inside `ConsoleShell`, and that is why it is its
+ * own component.** The banner was the reason `ConsoleShell` was published —
+ * `role="alert"` is the one part of that component a reviewer cannot see is
+ * missing, since per the `fatalError` latch in `session-core.ts` the banner is
+ * the ONLY remaining signal a session died (the state eyebrow beside it goes
+ * back to reading like a live session), and a screen reader is never told an
+ * unannounced one appeared. But `ConsoleShell` is a whole FRAME: a centred
+ * `max-w-190` column with its own header and footer. Every full-bleed chrome —
+ * a two-pane board, a CRT — therefore could not adopt it, rebuilt the banner
+ * instead, and the three that did had ALREADY drifted: one rendered
+ * `ERROR: {message}` and dropped the code entirely, one `ERROR: {message}
+ * ({code})`, one `{message} ({code})`. Splitting the banner out is what lets a
+ * chrome take the announced-error decision without taking the layout, and
+ * `ConsoleShell` composes this rather than keeping a second copy, so the two
+ * cannot drift again.
+ *
+ * **It reads the session itself.** There is no `error` prop: a banner that
+ * takes its text from the caller is a banner a caller can forget to wire, which
+ * is exactly the failure above with an extra step. It subscribes narrowly via
+ * {@link useSessionError}, so a page that renders it does not re-render with
+ * the transcript.
+ *
+ * **The code is shown, always.** `SessionError.code` is the eight-member wire
+ * union — it is what a user pastes into a bug report and the only part of the
+ * error that is stable across wordings — and the chrome that dropped it left
+ * its readers with a sentence and no way to say which failure it was.
+ *
+ * Must be rendered inside the providers `client()` installs.
+ *
+ * @example A full-bleed chrome that wants the banner and not the frame
+ * ```tsx
+ * import { SessionErrorBanner } from "@alexkroman1/aai-ui";
+ *
+ * function Board() {
+ *   return (
+ *     <div className="grid grid-cols-[1fr_320px] h-screen">
+ *       <main>…</main>
+ *       <aside>…</aside>
+ *       <SessionErrorBanner className="col-span-2" />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @param props - See {@link SessionErrorBannerProps}.
+ *
+ * @public
+ */
+export declare function SessionErrorBanner({ className }: SessionErrorBannerProps): ReactNode;

package/dist/components/sidebar-layout.js

@@ -1,7 +1,7 @@
 import { useTheme } from "../context.js";
 import clsx from "clsx";
 import { jsx, jsxs } from "react/jsx-runtime";
-//#region components/sidebar-layout.tsx
+//#region src/components/sidebar-layout.tsx
 /** @jsxImportSource react */
 /**
 * A two-column layout with a fixed-width sidebar and a flexible main area.

package/dist/components/start-screen.js

@@ -1,11 +1,11 @@
 import { useSessionCore, useSessionSelector, useTheme } from "../context.js";
-import { r as inkTint } from "../_colors-j8XMToi9.js";
+import { a as inkTint } from "../_colors-CpZO-88A.js";
 import { Button } from "./button.js";
-import { t as AaiLogo } from "../aai-logo-CXZGPSIY.js";
-import { t as Eyebrow } from "../eyebrow-C6ZFuiz6.js";
+import { t as AaiLogo } from "../aai-logo-CFlomZlS.js";
+import { t as Eyebrow } from "../eyebrow-UfmSz9yy.js";
 import clsx from "clsx";
 import { jsx, jsxs } from "react/jsx-runtime";
-//#region components/start-screen.tsx
+//#region src/components/start-screen.tsx
 /** @jsxImportSource react */
 /**
 * A centered start screen: a white card on the cream page with the logo, an

package/dist/components/tool-call-block.js

@@ -1,3 +1,3 @@
 import "../context.js";
-import { t as ToolCallBlock } from "../tool-call-block-tcPQAkcP.js";
+import { t as ToolCallBlock } from "../tool-call-block-C2t_5fpp.js";
 export { ToolCallBlock };

package/dist/components/tool-config-context.d.ts

@@ -8,7 +8,7 @@ export type ToolDisplayConfig = Record<string, {
     label?: string;
 }>;
 /**
- * Context for tool display configuration. Installed by `client()` from
+ * Context for tool display configuration. Installed by `mountClient()` from
  * `ClientConfig.tools`; the built-in components read it via `useToolConfig`.
  *
  * @internal

package/dist/components/workflow-progress.d.ts

@@ -1,17 +1,17 @@
-import type { ReactNode } from "react";
+import { type ReactNode } from "react";
 import type { WorkflowApi } from "../workflow-client.ts";
 /**
  * What a run has said so far, rendered.
  *
  * The complement of a status line, and the reason both exist: a run is
  * `running` for its whole life, so a one-round job and a ten-round one look
- * identical while they happen. These lines come from the run itself (`report()`
+ * identical while they happen. These lines come from the run itself (`stepReport()`
  * in a `"use step"` body), which is the only channel a workflow has before it
  * produces an output.
  *
- * Three rules are baked in, and they are why this is a component rather than
+ * Four rules are baked in, and they are why this is a component rather than
  * three lines each page writes for itself — the two templates that had written
- * it had written all three, comments included:
+ * it had written three of them, comments included:
  *
  * - **It renders nothing until there is something to render.** `supported` is
  *   what keeps this from being an empty box forever on an agent deployed before
@@ -25,6 +25,13 @@ import type { WorkflowApi } from "../workflow-client.ts";
  *   or opening a finished run tomorrow — shows how it got there rather than an
  *   empty box. That is `useWorkflowProgress`'s doing; this is what makes it
  *   visible.
+ * - **They are ANNOUNCED**, for the reason the first paragraph gives: this is
+ *   the only channel a run has before it produces an output, and a `<pre>` that
+ *   grows is a silent one. A screen-reader user pressing "Digest" got nothing
+ *   between the click and a terminal state minutes later — no "fetching", no
+ *   "summarising", no evidence the button did anything. See `role="log"` below.
+ *   The six pages that render this pass only `className`, so no template could
+ *   have fixed it locally; that is what makes it this component's job.
  *
  * @example
  * ```tsx

package/dist/context.d.ts

@@ -1,34 +1,45 @@
 import { type ReactNode } from "react";
-import type { SessionCore, SessionSnapshot } from "./session-core-types.ts";
-import type { ClientTheme } from "./types.ts";
+import type { BrowserSession, SessionSnapshot } from "./session-core-types.ts";
+import type { AgentState, ClientTheme, SessionError } from "./types.ts";
 /**
- * Provides the {@link SessionCore} the session hooks read. `client()`
+ * Provides the {@link BrowserSession} the session hooks read. `mountClient()`
  * installs it automatically; a custom tree only needs it when bypassing
- * `client()` and mounting React itself.
+ * `mountClient()` and mounting React itself.
  *
  * @internal
  */
-export declare function SessionProvider({ value, children }: {
-    value: SessionCore;
+export declare function SessionProvider({ value, children, }: {
+    value: BrowserSession;
     children?: ReactNode;
-}): import("react").FunctionComponentElement<import("react").ProviderProps<SessionCore | null>>;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<BrowserSession | null>>;
+/**
+ * The session's control methods, and nothing else — what a `client.tsx` may
+ * legitimately CALL on a session, as against what it may read.
+ *
+ * Declared once and merged into {@link Session} rather than written out at both
+ * places: the two lists have to be the same list, and a member added to one and
+ * not the other is a hook that cannot do what `useSession()` can.
+ *
+ * Method signatures come from {@link BrowserSession} — one source of truth.
+ *
+ * @public
+ */
+export type SessionActions = Pick<BrowserSession, "start" | "cancel" | "resetState" | "reset" | "restart" | "disconnect" | "toggle" | "end">;
 /**
  * What {@link useSession} returns: the live {@link SessionSnapshot} fields
  * (`state`, `messages`, `toolCalls`, `agentState`, live transcripts, `error`,
  * `apiUrl`, `started`/`running`/`recording`, …) merged with the session's
- * control methods (`start`, `toggle`, `reset`, `resetState`, `disconnect`,
- * `cancel`, `end`).
+ * control methods (`start`, `toggle`, `reset`, `restart`, `resetState`,
+ * `disconnect`, `cancel`, `end`).
  *
  * Note there is no text-send method — sessions are voice-only; the only
  * client→server inputs are audio and the control methods above.
  *
- * Method signatures come from {@link SessionCore} — one source of truth.
- *
  * @public
  */
-export type Session = SessionSnapshot & Pick<SessionCore, "start" | "cancel" | "resetState" | "reset" | "disconnect" | "toggle" | "end">;
+export type Session = SessionSnapshot & SessionActions;
 /**
- * Return the raw {@link SessionCore} from context without subscribing to
+ * Return the raw {@link BrowserSession} from context without subscribing to
  * snapshot changes. Useful for accessing stable methods (`start`, `toggle`,
  * `reset`, …) from components that select narrow state via
  * {@link useSessionSelector}.
@@ -36,15 +47,73 @@ export type Session = SessionSnapshot & Pick<SessionCore, "start" | "cancel" | "
  * Not part of the package's public export surface — internal to aai-ui
  * components.
  */
-export declare function useSessionCore(): SessionCore;
+export declare function useSessionCore(): BrowserSession;
+/**
+ * The session's control methods — `start`, `cancel`, `resetState`, `reset`,
+ * `restart`, `disconnect`, `toggle`, `end` — with **no snapshot
+ * subscription**.
+ *
+ * This is the narrow half of {@link useSession}, and it is the half a custom
+ * chrome could not reach. `<Controls>` and `<StartScreen>` in this package pair
+ * a one-field `useSessionSelector` with this package's own `useSessionCore`
+ * (`context.ts`, unpublished); a `client.tsx`
+ * could not, because that hook is not published — so a footer needing `start`
+ * and `toggle` held a WHOLE-SNAPSHOT `useSession()`, and `session-core.ts`
+ * rebuilds the snapshot object on every change. Measured consequence: four
+ * components across three templates re-rendered on every STT partial and every
+ * streaming delta, in files whose every other component is narrowly subscribed
+ * on purpose. One of them (`infocom-adventure`'s `TitleScreen`) reads nothing
+ * from the snapshot at all and subscribes to all of it for `session.start`.
+ *
+ * **Why publishing this does not reopen what `/internal` closed.**
+ * `useSessionCore` hands back the STORE — `subscribe`, `getSnapshot`,
+ * `connect`, `Symbol.dispose` — which is the framework's own plumbing, the same
+ * category as the providers and `buildAgentUrl` that live on
+ * `@alexkroman1/aai-ui/internal`. A client that holds it can subscribe out of
+ * band of React, dial a socket the mount did not, and dispose the session under
+ * the tree that is rendering it. What comes back from here is the SAME eight
+ * methods `useSession()` already publishes on its result, built into a fresh
+ * object rather than passed through, so the store is not reachable from it.
+ * There is no new capability here — only the existing one without the
+ * subscription tax.
+ *
+ * Identity-stable per core, so it is safe in a dependency array and in a
+ * `memo()` child's props: the methods are closures created once by
+ * `createBrowserSession`, and the object wrapping them is memoized on the core.
+ *
+ * Throws outside the provider `mountClient()` installs, like every session hook.
+ *
+ * @example A footer that acts on the session without re-rendering with it
+ * ```tsx
+ * import { useSessionActions, useSessionSelector } from "@alexkroman1/aai-ui";
+ *
+ * function Footer() {
+ *   // Two narrow subscriptions and no snapshot read: this row re-renders when
+ *   // `running` flips, and not on every transcript delta.
+ *   const running = useSessionSelector((s) => s.running);
+ *   const { toggle, end } = useSessionActions();
+ *   return (
+ *     <>
+ *       <button onClick={toggle}>{running ? "Pause" : "Resume"}</button>
+ *       <button onClick={end}>Hang up</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @returns The eight control methods — see {@link SessionActions}.
+ *
+ * @public
+ */
+export declare function useSessionActions(): SessionActions;
 /**
  * Return the live {@link Session}: the current snapshot fields plus the
  * control methods (`start`, `toggle`, `reset`, `resetState`, `disconnect`,
  * `cancel`, `end`).
  *
- * Throws if used outside the provider `client()` installs (the error names
+ * Throws if used outside the provider `mountClient()` installs (the error names
  * `<SessionProvider>` — you only mount that yourself when bypassing
- * `client()`). Re-renders the component on *every* snapshot change; for a
+ * `mountClient()`). Re-renders the component on *every* snapshot change; for a
  * component that reads one field, prefer {@link useSessionSelector} for a
  * targeted subscription.
  *
@@ -94,9 +163,63 @@ export declare function useSession(): Session;
  */
 export declare function useSessionSelector<T>(selector: (snapshot: SessionSnapshot) => T, isEqual?: (a: T, b: T) => boolean): T;
 /**
- * Provides the theme the components read via `useTheme`. `client()` installs
+ * The agent's live {@link AgentState} — `disconnected`, `connecting`, `ready`,
+ * `listening`, `thinking`, `speaking`, `error` — on its own narrow
+ * subscription.
+ *
+ * `useSessionSelector((s) => s.state)` spelled once. It is one of exactly two
+ * snapshot fields that more than one custom chrome ever selects (the other is
+ * {@link useSessionError}), and it had been written inline at eight sites —
+ * including inside this package and, worse, in `ConsoleShell`'s own `@example`,
+ * which taught the inline form to everyone who read it.
+ *
+ * **Named `useSessionStatus`, not `useSessionState`.** `useAgentState` is the
+ * SLOT hook — the agent's own synced application state, whatever a
+ * `sessionSlot()` projects — and `AgentState` here is the phase of the CALL.
+ * Two different concepts one letter apart, so the shorter-sounding name is the
+ * one deliberately not taken.
+ *
+ * Pair it with {@link AGENT_STATE_LABELS} for a rendered word; the raw member
+ * is a wire value, not a label.
+ *
+ * @example
+ * ```tsx
+ * import { AGENT_STATE_LABELS, useSessionStatus } from "@alexkroman1/aai-ui";
+ *
+ * function StatusDot() {
+ *   const status = useSessionStatus();
+ *   return <span data-state={status}>{AGENT_STATE_LABELS[status]}</span>;
+ * }
+ * ```
+ *
+ * @returns The current agent state.
+ *
+ * @public
+ */
+export declare function useSessionStatus(): AgentState;
+/**
+ * The session's current {@link SessionError}, or `null` when there is none, on
+ * its own narrow subscription.
+ *
+ * The other half of {@link useSessionStatus} — the second of the two fields a
+ * custom chrome reads over and over, and the one whose absence is invisible:
+ * per the `fatalError` latch in `session-core.ts` the error is the ONLY
+ * remaining signal that a session died, since the state beside it goes back to
+ * reading like a live one.
+ *
+ * A chrome rendering it owes `role="alert"` — which is what
+ * {@link SessionErrorBanner} is for, and why reaching for that beats reaching
+ * for this.
+ *
+ * @returns The current error, or `null`.
+ *
+ * @public
+ */
+export declare function useSessionError(): SessionError | null;
+/**
+ * Provides the theme the components read via `useTheme`. `mountClient()` installs
  * it automatically (from `ClientConfig.theme`); a custom tree only needs it
- * when bypassing `client()` and mounting React itself.
+ * when bypassing `mountClient()` and mounting React itself.
  *
  * @internal
  */
@@ -110,7 +233,7 @@ export declare function ThemeProvider({ value, children, }: {
  * provider is present, so components can call it unconditionally.
  *
  * This is how a custom component stays on the agent's palette: a
- * `client({ theme })` override reaches it here, where a hardcoded colour or a
+ * `mountClient({ theme })` override reaches it here, where a hardcoded colour or a
  * Tailwind class cannot see it.
  *
  * @example