@workerdeck/ui 0.23.0 → 1.1.0

package/build/SessionPanel-BobynUo4.d.mts

@@ -1,669 +0,0 @@
-import * as _$react from "react";
-import { ReactNode } from "react";
-import { LucideIcon } from "lucide-react";
-import { ModelOption, PermissionMode } from "@workerdeck/protocol";
-import * as _$_workerdeck_react0 from "@workerdeck/react";
-import { ConnectionState, TranscriptState, UseToolCallHostOptions } from "@workerdeck/react";
-import { WorkerDeckClient } from "@workerdeck/client";
-
-//#region src/components/agent/PermissionModeSelect.d.ts
-type PermissionModeMeta = {
-  value: PermissionMode; /** The name Claude Code itself uses. */
-  label: string;
-  /** The chip form, for bars where the label shares a line with three other
-   * things and "Bypass permissions" would eat half of it. */
-  shortLabel: string; /** What the mode actually does — the CLI's own one-liners. */
-  description: string;
-  icon: LucideIcon;
-  dangerous?: boolean;
-};
-/**
- * The modes surfaced across UI surfaces (session creation, in-session switcher),
- * ordered by how much of the approval gate they give away.
- *
- * Notably `default` is **"Manual"**: the wire value is `default`, but calling it
- * that in the UI conflates a real mode (ask me every time) with "whatever the
- * server picked", which is the one confusion a mode chip exists to avoid. The
- * naming, the icons and the summaries are shared with the iOS app on purpose —
- * the two surfaces should read as the same list.
- */
-declare const PERMISSION_MODES: PermissionModeMeta[];
-declare const permissionModeMeta: (mode: PermissionMode) => PermissionModeMeta | undefined;
-/** One offered mode as plain data — no icon, no React. What a host chrome
- * outside the panel (a VS Code QuickPick) needs to draw the same list. */
-type PermissionModeChoice = {
-  value: PermissionMode;
-  label: string;
-  description: string;
-  dangerous?: boolean;
-  /** Offered but unreachable: a session not started for bypass can never gain
-   * it, and saying so beats omitting the row. */
-  disabled?: boolean;
-};
-/**
- * The modes this session may actually be switched into, with the reasons baked
- * in — the same filtering {@link PermissionModeSelect} applies, so an embedder
- * rendering its own picker cannot drift from the panel's.
- */
-declare function permissionModeChoices(modes?: readonly PermissionMode[], canBypass?: boolean): PermissionModeChoice[];
-interface PermissionModeSelectProps {
-  /** The session's current mode (TranscriptState.permissionMode). */
-  mode?: PermissionMode;
-  onModeChange: (mode: PermissionMode) => void;
-  /** Restrict what is offered — most of {@link PERMISSION_MODES} is Claude Code
-   * vocabulary the other engines have no meaning for. Defaults to all of them;
-   * pass the session's `capabilities.permissionModes`. */
-  modes?: readonly PermissionMode[];
-  /**
-   * Whether this session may be switched into `bypassPermissions` at all. The
-   * CLI refuses unless the process was spawned for it, so a session that didn't
-   * ask up front can never gain it. The row is shown disabled rather than hidden
-   * — "you can't have this here" is a more useful answer than a row that
-   * silently isn't there. `undefined` (an older server) offers it.
-   */
-  canBypass?: boolean;
-  /** 'toolbar' (default) is the composer's compact borderless trigger;
-   * 'form' is a standard field-sized Select for create/settings forms. */
-  variant?: 'toolbar' | 'form';
-  disabled?: boolean;
-  className?: string;
-}
-/** Permission-mode switcher: compact in the composer toolbar, field-sized in forms. */
-declare function PermissionModeSelect({
-  mode,
-  onModeChange,
-  modes,
-  canBypass,
-  variant,
-  disabled,
-  className
-}: PermissionModeSelectProps): _$react.JSX.Element;
-//#endregion
-//#region src/components/terminal/affordances.d.ts
-/**
- * The things a terminal cannot do, and this can.
- *
- * The theme's whole discipline is that it renders like a CLI — but it is not a
- * CLI, and refusing every affordance a pointer makes possible would be cosplay
- * rather than design. A terminal cannot highlight the row under your cursor and
- * cannot put a copy button on a block of output; a web view can do both for free
- * and they are genuinely useful.
- *
- * The rule that keeps this honest is that **each one costs no layout**. A hover
- * fill is a background. An action button is an overlay at the row's right edge,
- * one line tall, absolutely positioned so it displaces nothing. Turn them all
- * off and every glyph is on exactly the same cell it was on — which is what
- * makes `off` a real option rather than a degraded mode, and why it is the mode
- * a host projecting to a real terminal would choose.
- *
- * Off by nothing in particular: both default **on**, because the surface these
- * render on is a browser and pretending otherwise helps nobody. A host that
- * wants the pure article passes `affordances={false}`.
- */
-type TerminalAffordances = {
-  /** Fill the row under the pointer, on anything pressable. */hover?: boolean; /** Reveal a row's actions (copy, and whatever a row adds) on hover or focus. */
-  actions?: boolean;
-};
-declare function useAffordances(): Required<TerminalAffordances>;
-/**
- * A block that reveals its actions on hover.
- *
- * Wraps rather than decorates because the actions belong to the *block* — a
- * message is many rows and its copy button belongs at the top right of all of
- * them, not on whichever row the pointer happens to be over.
- */
-declare function WithActions({
-  actions,
-  children,
-  className
-}: {
-  actions: ReactNode;
-  children: ReactNode;
-  className?: string;
-}): _$react.JSX.Element;
-declare function CopyAction({
-  text,
-  label
-}: {
-  text: string;
-  label?: string;
-}): _$react.JSX.Element;
-//#endregion
-//#region src/components/agent/transcript-variant.d.ts
-/**
- * How the transcript draws a turn.
- *
- * - `cards` — the chat convention: bubbles, bordered tool cards, generous gaps.
- *   Right for a wide dashboard where the transcript is the page.
- * - `terminal` — the CLI's own form: every row on a character cell, no boxes
- *   anywhere, diffs as full-width bands. Right where the transcript sits beside
- *   a terminal (a VS Code dock) and where vertical space is scarce.
- *
- * `terminal` is **not** a second set of branches in the components under
- * `components/agent/`: it is its own renderer (`components/terminal/`) that the
- * shell mounts *instead* of them. So a row component here never asks which
- * variant it is in — if it is drawing at all, it is drawing cards.
- *
- * A context rather than a prop chain because the pieces that DO need it sit
- * outside the transcript (the composer, the pending prompts) and because
- * `Message`/`ToolCallCard` are exported on their own, so an embedder composing
- * them by hand gets the right treatment for free.
- */
-type TranscriptVariant = 'cards' | 'terminal';
-declare function TranscriptVariantProvider({
-  value,
-  children
-}: {
-  value: TranscriptVariant;
-  children: ReactNode;
-}): _$react.JSX.Element;
-declare function useTranscriptVariant(): TranscriptVariant;
-/**
- * How much room the transcript gives each row.
- *
- * - `comfortable` — a blank line between messages, which is what the Claude Code
- *   CLI does. The default: a transcript is prose before it is a table.
- * - `compact` — rows tight against each other, for a dock where every line of
- *   vertical space is contested.
- *
- * Separate from the variant, and deliberately: they answer different questions.
- * The variant decides *how a row is drawn* and follows from the surface; density
- * decides *how much air is around it* and is a preference the reader holds.
- *
- * Reaches `cards` only. The terminal theme's spacing is a blank *line*, decided
- * per pair of blocks by `needsBlank` — a terminal has one line height, which is
- * the whole premise — so there is nothing there for this to turn.
- */
-type TranscriptDensity = 'comfortable' | 'compact';
-declare function TranscriptDensityProvider({
-  value,
-  children
-}: {
-  value: TranscriptDensity;
-  children: ReactNode;
-}): _$react.JSX.Element;
-declare function useTranscriptDensity(): TranscriptDensity;
-/**
- * The typeface the panel runs in.
- *
- * `sans` is the host's UI font; `mono` repoints the sans token at the mono stack
- * for the panel's subtree (see the `[data-agent-font='mono']` rule in
- * `theme.css`), so the transcript reads as part of a terminal rather than as a
- * web app beside one.
- *
- * No context and no hook, unlike variant and density: nothing branches on it in
- * JS. It is one attribute on the panel root and the cascade does the rest, which
- * is also what keeps it from leaking past the panel.
- */
-type TranscriptFont = 'sans' | 'mono';
-//#endregion
-//#region src/components/agent/SessionPanel.d.ts
-/**
- * The character cell the terminal theme draws on, in **whole pixels**.
- *
- * One object rather than two props because the panel mounts three separate
- * `TerminalSurface`s — the transcript, the pending prompts, the composer — and
- * they must agree: a prompt drawn at a different line height from the rows above
- * it is three surfaces on three grids, which is the failure this theme is built
- * to make impossible. Passing one value through one prop is what keeps them from
- * drifting.
- *
- * Absent means the CLI's own 13/18. A host that follows an editor font size
- * (VS Code) hands that down instead.
- */
-type TerminalMetrics = {
-  fontSize?: number;
-  lineHeight?: number;
-};
-interface SessionPanelProps {
-  client: WorkerDeckClient;
-  sessionId: string | undefined;
-  /**
-   * Optional slot rendered at the top, above the status bar.
-   *
-   * Pass a **function** to take the session-actions (`⋯`) menu into your own
-   * chrome: it is called with the menu element, and wherever you put it is
-   * where it lives — the status bar then renders without it, so it never
-   * appears twice. Pass a plain node (or nothing) and the menu stays in the
-   * status bar's trailing slot.
-   *
-   * The seam exists because the menu can only be *built* here — it needs the
-   * capability record, the host-file verdict and the panel's own dialog state —
-   * but an embedder with a real header usually wants it up there with the rest
-   * of the session's controls, not stranded on the status line.
-   */
-  header?: ReactNode | ((slots: {
-    actions: ReactNode;
-  }) => ReactNode);
-  /**
-   * Where the info/context/usage/MCP/skills/files surfaces live. `'internal'`
-   * (default) renders them as dialogs inside the panel. `'external'` renders
-   * NO dialogs and no `⋯` menu: every affordance that would open one calls
-   * {@link onOpenPanel} instead, so an embedder can host those surfaces in its
-   * own chrome (a VS Code sidebar, a drawer) and keep the panel purely a
-   * conversation surface.
-   */
-  panelSurface?: 'internal' | 'external';
-  /**
-   * Where the status bar lives. `'internal'` (default) draws it across the top
-   * of the panel. `'external'` draws none — the readings still leave through
-   * {@link onVitals}, so an embedder with a status line of its own (VS Code's
-   * window status bar) renders them there instead of stacking a second bar
-   * inside a panel that already sits in one.
-   *
-   * Deliberately independent of {@link panelSurface}: hosting the dialogs and
-   * hosting the bar are separate decisions. One coupling to know about — the
-   * `⋯` menu lives in the bar's trailing slot, so `statusSurface: 'external'`
-   * with `panelSurface: 'internal'` must pass a **function** {@link header} to
-   * take the menu, or it has nowhere left to go.
-   */
-  statusSurface?: 'internal' | 'external';
-  /**
-   * Which end of the panel the status bar sits at. Default `top`.
-   *
-   * `bottom` is the editor convention — VS Code's status bar runs along the
-   * foot of the window — and suits a host where the panel *is* the editor area
-   * and the chrome above it already belongs to the app. Placement only; the bar
-   * is the same bar, with the same `⋯` menu in its trailing slot, so this
-   * composes with {@link statusSurface} rather than competing with it (external
-   * still means "there isn't one").
-   */
-  statusPlacement?: 'top' | 'bottom';
-  /** Where `panelSurface: 'external'` routes opens. Absent = the affordances
-   * (status-bar clicks, `/mcp`) become inert rather than half-working. */
-  onOpenPanel?: (panel: SessionSurfacePanel) => void;
-  /** Live session vitals, fired whenever they change — for embedders mirroring
-   * status/context/usage into chrome outside the panel (identity-stable via an
-   * internal ref, so an inline closure is fine). */
-  onVitals?: (vitals: SessionVitals) => void;
-  /**
-   * How the transcript draws a turn — `'cards'` (default, the chat convention)
-   * or `'terminal'`, the CLI's own form: every row on a character cell, no boxes
-   * anywhere, diffs as full-width bands. An embedder in a dock (the VS Code
-   * panel) wants `'terminal'`; a full-width dashboard may prefer cards.
-   */
-  transcriptVariant?: TranscriptVariant;
-  /**
-   * Terminal theme only: the pointer affordances a real terminal cannot offer —
-   * the hover fill, the hover-revealed copy. `false` for none. None of them
-   * costs layout, so turning them off changes no glyph's position. See
-   * {@link TerminalAffordances}.
-   */
-  affordances?: TerminalAffordances | boolean;
-  /**
-   * Terminal theme only: the character cell, in whole pixels. See
-   * {@link TerminalMetrics} — it reaches all three of the panel's terminal
-   * surfaces, which is why it is one prop and not two per surface.
-   */
-  terminalMetrics?: TerminalMetrics;
-  /**
-   * Terminal theme only: replace the scrollbar with the **overview ruler** — a
-   * `2ch` rail of coloured marks in three lanes (what you typed, the answer and
-   * its turn end, errors and a waiting approval), which you can hover to peek,
-   * click to jump, and drag to scrub.
-   *
-   * Its premise is the terminal theme's own: one line height and one cell make
-   * every row's height derivable, so a mark's position is *computed* rather than
-   * guessed from rows that have not mounted. That is why it is not offered under
-   * `cards` — there the flag is inert.
-   *
-   * `false` keeps the native scrollbar. So does `affordances={false}`, which
-   * leaves the marks painted but inert rather than removing a reader's only way
-   * to scroll.
-   */
-  scrubber?: boolean;
-  /**
-   * Bookmarked **item indices**, painted full-width on the rail. Paint only —
-   * the panel neither stores bookmarks nor offers a way to set one, because who
-   * owns that store is the embedder's question (a private pin belongs with the
-   * client's watermarks; a shared one is session metadata on the gateway).
-   */
-  scrubberMarks?: readonly number[];
-  /**
-   * Scroll a tool call into view; bump `nonce` to ask again for the same one.
-   * See {@link TranscriptProps.reveal} — this is the panel's pass-through, and
-   * exists so a surface *outside* the panel (a sessions list showing a session's
-   * running sub-agents) can say "take me to that one" without opening a second
-   * attach to find out where it is.
-   */
-  reveal?: {
-    toolUseId: string;
-    nonce: number;
-  };
-  /**
-   * Open a **sub-agent takeover**: the panel body becomes that agent's own work,
-   * with a way back. Bump `nonce` to ask again for the same one.
-   *
-   * A *request*, not a controlled value — the panel owns which agent is open,
-   * exactly as it owns `panel`. Dismissal has to work with zero host wiring
-   * (Back and Escape are the panel's own affordances), and the two hosts in
-   * scope reach this across a postMessage bridge where a controlled prop would
-   * need a live closure at the far end. Same shape and same reason as
-   * {@link SessionPanelProps.reveal}.
-   *
-   * **Withdrawing the request closes the frame.** The prop going away without a
-   * remount is itself a request — "the conversation, plainly" — and it leaves
-   * through the same path Back takes, so the reader lands on the Task row they
-   * came from. It has to mean that, because a host that keeps its request in
-   * route state (the dashboard's `?subagent=`) has exactly one way to say it:
-   * clear the search — which is what the sidebar's plain session click already
-   * navigated with, and what the browser's Back button re-arrives on. Before
-   * this, both were silently ignored and the frame outlived the address that
-   * claimed it was gone. Still not a controlled value: the panel enters and
-   * leaves frames on its own and *reports* through
-   * {@link SessionPanelProps.onSubagentChange}; only a **change** of the prop
-   * is a request.
-   *
-   * Hosts must still clear their request on a session switch: a stale one
-   * replayed at remount would open a frame the new transcript cannot answer.
-   *
-   * Claude-only in practice, and gated by data rather than by a flag — codex and
-   * provider sessions have no `parentToolUseId`, so they grow no task blocks and
-   * no sub-agent rows, and nothing can raise this.
-   */
-  openSubagent?: {
-    toolUseId: string;
-    nonce: number;
-  };
-  /**
-   * Which sub-agent the panel now has framed, or `undefined` for the session's
-   * own conversation — the outward half of
-   * {@link SessionPanelProps.openSubagent}, and a *statement* where that one is
-   * a *request*. Deliberately not an echo: the panel enters frames the host
-   * never asked for (a Task row pressed in the transcript) and leaves them on
-   * its own (Back, Escape, a reveal), so a host that tracked only its own
-   * requests would be wrong within one click. No nonce, for the same reason —
-   * a state that arrives twice is the same state, where a request that arrives
-   * twice is two requests.
-   *
-   * Never fired for a fresh mount's initial `undefined`, and never fired from
-   * an unmount. The first would be a lie with consequences: the seeding effect
-   * consumes `openSubagent` in the same commit, so for one commit the state is
-   * `undefined` even though a frame is about to open, and a host folding
-   * reports into route state would clear the very `?subagent=` request the
-   * panel is in the middle of honouring. The second lets a panel keyed away on
-   * a session switch stomp what the host already believes about the next one.
-   * See the notify effect for the mechanics.
-   *
-   * What the sessions list's secondary selection feeds on: the row of the agent
-   * on screen takes the blue and its session's card steps back to grey.
-   */
-  onSubagentChange?: (toolUseId: string | undefined) => void;
-  /**
-   * Hold the prompt of the turn you are reading at the top of the transcript.
-   * Works in both variants: the terminal clips to one line (as the CLI does),
-   * cards shows a frosted bar. The **real row** is pinned rather than a copy
-   * drawn above it, so it lines up with the rows beneath by construction.
-   */
-  stickyPrompt?: boolean;
-  /**
-   * How much air the transcript gives each row — `'comfortable'` (default: a
-   * blank line between messages, as the Claude Code CLI leaves) or `'compact'`
-   * (rows tight against one another). Independent of `transcriptVariant`: the
-   * variant follows from the surface, density is the reader's preference, and a
-   * dock is allowed to be roomy.
-   */
-  transcriptDensity?: TranscriptDensity;
-  /**
-   * The panel's typeface — `'sans'` (default, the host's UI font) or `'mono'`,
-   * which repoints the sans token at the mono stack **for this subtree only**.
-   *
-   * The third reader preference beside variant and density, and the same kind of
-   * thing: how a transcript should read is a property of the person reading it.
-   * Scoped to the panel because that is the whole claim — a monospace agent view
-   * next to an ordinary app, not a monospace app.
-   */
-  transcriptFont?: TranscriptFont;
-  /**
-   * Where the session's own controls — model and permission mode — live.
-   * `'internal'` (default) draws them in the composer's toolbar row.
-   * `'status'` draws them in the panel's OWN status bar, beside the readings
-   * they act on; the composer collapses to a single line either way. That is
-   * VS Code's arrangement without VS Code — a host whose panel carries a status
-   * bar of its own (`statusPlacement: 'bottom'`) gets the same streamlined
-   * shape without having to host the pickers itself.
-   * `'external'` draws neither: the embedder renders the pickers in its own
-   * chrome (VS Code's window status bar, where a click opens a QuickPick) and
-   * drives them through {@link onControls}.
-   *
-   * `'status'` needs a status bar to put them in — with
-   * `statusSurface: 'external'` there is none, and the two together would hide
-   * the controls entirely, so that combination falls back to the composer.
-   *
-   * The options themselves ride {@link SessionVitals} — an embedder must not
-   * attach a second time to learn what the models are.
-   */
-  controlsSurface?: 'internal' | 'external' | 'status';
-  /**
-   * Handed the session's setters once the panel is live, and `undefined` on
-   * unmount. The counterpart to `controlsSurface: 'external'`: vitals carry the
-   * readings out, this carries the commands back in. Stable identity — safe to
-   * stash in a ref.
-   */
-  onControls?: (controls: SessionControls | undefined) => void;
-  /**
-   * Click anywhere the panel isn't already doing something and the caret lands
-   * in the composer — the terminal/chat convention, and what a docked panel
-   * wants: the field is why the panel is focussed at all.
-   *
-   * Only dead space. A click that hits a control (a tool row expanding, a link,
-   * a button) or that ends a text selection is that action, not a request for
-   * the input. Off by default: a full-page surface has plenty of dead space that
-   * means nothing in particular.
-   */
-  focusComposerOnClick?: boolean;
-  /**
-   * What this session looked like when it was last looked at: how many
-   * transcript items had been seen, and when. Present and behind the current
-   * transcript → **catch-up**: a recap row at the boundary, everything above it
-   * dimmed, and a bar offering to jump there or to dismiss.
-   *
-   * The embedder owns the watermark because only it knows what "looked at"
-   * means in its own chrome — a hidden dock is not being read. The panel reports
-   * the number to remember through `SessionVitals.itemCount`.
-   */
-  unseen?: {
-    itemCount: number;
-    since?: number;
-  };
-  /**
-   * A viewer, not a seat at the session: transcript, status bar and panels as
-   * usual, but no composer and no approval prompts.
-   *
-   * For a surface that is *about* a run rather than in it — the dashboard's job
-   * detail, where the session belongs to the queue and typing into it would be a
-   * second operator arriving mid-run. Deliberately not "disabled controls": a
-   * greyed-out composer says the session is busy, an absent one says this screen
-   * does not drive it. The attach is still live and read paths are untouched,
-   * so the transcript streams and the file tree browses.
-   *
-   * It does **not** claim to be an authorization boundary. Anything holding this
-   * client can still send; what it removes is the affordance, and the honest
-   * enforcement lives on the gateway.
-   */
-  readOnly?: boolean;
-  /**
-   * Options for the browser tool host this panel runs on its own attach — or
-   * `false` to run none at all.
-   *
-   * The panel hosts server-bridged tool calls itself, because the bridge asks
-   * the *first attached client* and the panel owns the session's one attach: an
-   * embedder subscribing to the same handle separately would find this host
-   * already answering, and refusing, anything outside its allow-list. So the
-   * options come through here.
-   *
-   * Merged over the defaults, which host `eval_script` alone. Widening `tools`
-   * is a real grant — this tab will execute what the gateway asks it to for
-   * every name in the list — so it names them explicitly rather than accepting
-   * a wildcard.
-   */
-  toolHost?: UseToolCallHostOptions | false;
-  /**
-   * Keep this session's transcript warm across remounts (default true), so
-   * switching back to a recently viewed session paints instantly and replays
-   * only what it missed — `UseClaudeSessionOptions.cacheTranscript`. Set
-   * `false` for an embedder whose principal varies on one gateway URL by means
-   * the client cannot see.
-   */
-  cacheTranscript?: boolean;
-  /**
-   * Replaces the default empty state when the transcript has no messages. Pass
-   * your product's own onboarding content instead of WorkerDeck's generic
-   * "`>_` Tell the agent what to do." placeholder.
-   */
-  emptyState?: ReactNode;
-  /**
-   * Called when a link in the transcript is clicked. The embedder decides what
-   * happens: navigate in-app, open a browser tab, show a confirmation, or
-   * suppress.
-   *
-   * Return `true` (or a truthy value) to indicate the click was handled — the
-   * default action (`window.open(href, '_blank')`) is suppressed. Return
-   * `false` / `undefined` / nothing to let the browser open the link normally.
-   *
-   * Absent means "browser default" — links open in a new tab as Streamdown's
-   * `target="_blank"` intends. VS Code's webview overrides this through its own
-   * native handler (the "allow once / add to allowlist" dialog) and does not
-   * need this prop.
-   *
-   * **Typical embedder patterns:**
-   * - Relative URLs → in-app navigation, no confirmation
-   * - External URLs → confirmation dialog, or open unconditionally
-   * - Suppress all links → `() => true`
-   */
-  onLinkClick?: (href: string) => boolean | void;
-  /**
-   * Client-side tool handlers. Each key is a tool name the model can call; the
-   * handler receives the model's input and returns a result. The tool's
-   * **schema** must be registered server-side (via `tools` on
-   * `ProviderRunnerOptions`), but the handler runs here — right where the data
-   * the tool needs lives.
-   *
-   * Shorthand for `toolHost.clientTools`; when both are set, this wins for
-   * overlapping names.
-   *
-   * ```tsx
-   * <SessionPanel
-   *   clientTools={{
-   *     app_navigate: async (input) => {
-   *       router.push((input as { path: string }).path)
-   *       return { value: 'navigated' }
-   *     },
-   *   }}
-   * />
-   * ```
-   */
-  clientTools?: Record<string, _$_workerdeck_react0.ClientToolHandler>;
-  /**
-   * Base font size in **whole pixels**. Drives the overall scale of everything
-   * the panel draws — prompt, output, markdown, status bar — in both variants.
-   *
-   * Under the terminal theme it sets `--term-font-size` and derives
-   * `--term-line` at the CLI's own 13 : 18 ratio (unless {@link terminalMetrics}
-   * overrides those individually). Under cards it sets the panel root's
-   * `font-size`, which scales every `rem`/`em`-based token the type scale uses.
-   *
-   * Absent means "platform default": 13 px for the terminal theme, the
-   * inherited body size for cards. That is the right choice for a host that has
-   * no preference — the panel reads at the size the rest of the app does.
-   */
-  fontSize?: number;
-  className?: string;
-}
-/** What an embedder needs to *change* a session it doesn't own the attach for. */
-type SessionControls = {
-  setModel: (model?: string) => void;
-  setPermissionMode: (mode: PermissionMode) => void;
-  interrupt: () => void;
-  /**
-   * Put the caret in the composer.
-   *
-   * For an embedder whose own chrome is how you arrive at a session — clicking a
-   * row in VS Code's sidebar — where revealing the panel and being able to type
-   * are the same intention. The panel cannot infer it: from in here, a session
-   * appearing looks identical whether someone asked for it or it was restored.
-   */
-  focusComposer: () => void;
-};
-/** The panels the session surface can raise. One at a time, by identity: a bag
- * of booleans would let two open at once. */
-type SessionSurfacePanel = 'info' | 'context' | 'usage' | 'mcp' | 'files' | 'skills';
-/** What {@link SessionPanelProps.onVitals} reports: the live readings a host
- * chrome outside the panel would otherwise have to attach a second time for —
- * which the tool bridge forbids (it asks the first attached client). */
-type SessionVitals = {
-  status: TranscriptState['status'];
-  /**
-   * How the client is reaching the gateway. Load-bearing for a host rendering
-   * these outside the panel: `status` is the last thing the session *said*, and
-   * over a dropped socket that is a stale reading. The panel's own bar gives
-   * the connection the status slot when it isn't `'live'` for exactly this
-   * reason — an embedder showing `status` alone would present stale as current.
-   */
-  connection: ConnectionState;
-  engine: TranscriptState['engine'];
-  capabilities: TranscriptState['capabilities'];
-  model: string | undefined;
-  /** The models this session can switch to — the panel's own list, so an
-   * external picker offers exactly what the internal one would. */
-  models: ModelOption[];
-  permissionMode: TranscriptState['permissionMode'];
-  /** The modes it can switch into, already filtered by the capability record
-   * and the session's bypass grant (see `permissionModeChoices`). */
-  permissionModes: PermissionModeChoice[];
-  cwd: TranscriptState['cwd'];
-  contextUsage: TranscriptState['contextUsage'];
-  rateLimits: TranscriptState['rateLimits'];
-  /** How many transcript rows exist right now — the number an embedder stores
-   * as its "seen" watermark while the panel is actually on screen, and compares
-   * against later to know what is new. */
-  itemCount: number;
-  /** Session-cumulative cost in USD. The internal status bar renders this via
-   * `formatCost`; an external host needs it to reproduce that reading. */
-  totalCostUsd: number;
-};
-/**
- * The all-in-one embeddable session surface: status bar, streaming transcript,
- * permission prompts, composer. Attaches via useClaudeSession; remount (key) to switch
- * sessions.
- *
- * Every affordance is gated on the session's **capability record** rather than on
- * the engine name — an absent capability hides the control instead of offering
- * one that can only fail.
- */
-declare function SessionPanel({
-  client,
-  sessionId,
-  header,
-  panelSurface,
-  statusSurface,
-  statusPlacement,
-  onOpenPanel,
-  onVitals,
-  transcriptVariant,
-  transcriptDensity,
-  transcriptFont,
-  affordances,
-  terminalMetrics,
-  scrubber,
-  scrubberMarks,
-  reveal,
-  openSubagent,
-  onSubagentChange,
-  stickyPrompt,
-  controlsSurface,
-  onControls,
-  focusComposerOnClick,
-  unseen,
-  readOnly,
-  toolHost,
-  clientTools,
-  cacheTranscript,
-  emptyState,
-  onLinkClick,
-  fontSize,
-  className
-}: SessionPanelProps): _$react.JSX.Element;
-//#endregion
-export { permissionModeChoices as C, PermissionModeSelectProps as S, useAffordances as _, SessionVitals as a, PermissionModeMeta as b, TranscriptDensityProvider as c, TranscriptVariantProvider as d, useTranscriptDensity as f, WithActions as g, TerminalAffordances as h, SessionSurfacePanel as i, TranscriptFont as l, CopyAction as m, SessionPanel as n, TerminalMetrics as o, useTranscriptVariant as p, SessionPanelProps as r, TranscriptDensity as s, SessionControls as t, TranscriptVariant as u, PERMISSION_MODES as v, permissionModeMeta as w, PermissionModeSelect as x, PermissionModeChoice as y };
-//# sourceMappingURL=SessionPanel-BobynUo4.d.mts.map