@usetheo/ui 0.13.0 → 0.13.1

package/dist/components/composites/text-prompt/text-prompt.d.ts

@@ -0,0 +1,48 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/**
+ * TextPrompt — free-text "ask the user" card for agent surfaces.
+ *
+ * The open-ended sibling of `ChoicePrompt`: a question with an optional header
+ * chip and a single-line (`Input`) or multi-line (`Textarea`) field. Equivalent
+ * to the "Other" affordance promoted to a question of its own.
+ *
+ * Renders one question at a time — sequencing is the consumer's responsibility.
+ * Controlled (`value` + `onValueChange`) or uncontrolled (`defaultValue`).
+ */
+/** Payload handed to `onConfirm`. */
+export interface TextPromptResult {
+    /** The typed text. */
+    text: string;
+}
+export interface TextPromptProps extends Omit<HTMLAttributes<HTMLElement>, "onSelect"> {
+    /** The question being asked. */
+    question: ReactNode;
+    /** Optional secondary line under the question. */
+    description?: ReactNode;
+    /** Optional short header chip (rendered as a Badge). */
+    badge?: ReactNode;
+    /** Controlled text value. */
+    value?: string;
+    /** Initial text when uncontrolled. */
+    defaultValue?: string;
+    /** Fired with the text on every keystroke. */
+    onValueChange?: (text: string) => void;
+    /** Field placeholder. */
+    placeholder?: string;
+    /** Render a multi-line Textarea instead of a single-line Input. */
+    multiline?: boolean;
+    /** Rows for the Textarea when `multiline`. Default 3. */
+    rows?: number;
+    /** Require non-empty text before Confirm enables. */
+    required?: boolean;
+    /** Confirm button label. Defaults to "Confirm". Omit `onConfirm` to hide it. */
+    confirmLabel?: ReactNode;
+    /** Cancel button label. Defaults to "Cancel". Omit `onCancel` to hide it. */
+    cancelLabel?: ReactNode;
+    /** Pressing Confirm. Receives the typed text. */
+    onConfirm?: (result: TextPromptResult) => void;
+    /** Pressing Cancel. */
+    onCancel?: () => void;
+}
+declare const TextPrompt: import("react").ForwardRefExoticComponent<TextPromptProps & import("react").RefAttributes<HTMLElement>>;
+export { TextPrompt };

package/dist/components/composites/usage-meter/index.d.ts

@@ -0,0 +1 @@
+export { UsageMeter, type UsageMeterProps, type UsageMetric } from "./usage-meter.js";

package/dist/components/composites/usage-meter/usage-meter.d.ts

@@ -0,0 +1,56 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/**
+ * UsageMeter — multi-metric stacked usage card.
+ *
+ * PaaS-shape sibling of `<CostMeter>` (which is mono-USD). Displays N
+ * metrics with arbitrary units (GB, requests, build-minutes, seats) per
+ * the reference TheoCloud dashboard mockup. Each row = label + value/max
+ * + `<Progress>` fill bar.
+ *
+ * Composition:
+ *
+ *   <UsageMeter
+ *     title="Last 30 days"
+ *     action={<Badge variant="outline">Upgrade</Badge>}
+ *     metrics={[
+ *       { label: "Fast Data Transfer", value: 0, max: 100, unit: "GB" },
+ *       { label: "Edge Requests", value: 0, max: 1_000_000, unit: "req",
+ *         formatter: (v, m) => `${v} / ${m >= 1e6 ? `${m / 1e6}M` : m}` },
+ *     ]}
+ *   />
+ *
+ * Over-quota detection: when `value > max`, the value text gets the
+ * `text-warning` class and the underlying `<Progress>` uses
+ * `intent="warning"` (bar fills 100% via Progress's own clamping).
+ *
+ * `compact` mode renders only the bars (no label/value text) — useful in
+ * narrow nav-bar slots.
+ *
+ * Imports the sibling `<Progress>` primitive via relative path (per RFC
+ * dashboard-paas-primitives D3) — primitives must not depend on the
+ * `@theokit/ui` barrel.
+ */
+export interface UsageMetric {
+    /** Display label (e.g. "Fast Data Transfer"). */
+    label: ReactNode;
+    /** Current consumption. */
+    value: number;
+    /** Maximum allowed in the current period. */
+    max: number;
+    /** Unit string (e.g. "GB", "req", "min"). Rendered after value/max. */
+    unit?: string;
+    /** Optional custom formatter — overrides default `${value} / ${max} ${unit}`. */
+    formatter?: (value: number, max: number, unit?: string) => string;
+}
+export interface UsageMeterProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Card title (e.g. "Last 30 days", "This billing period"). */
+    title?: ReactNode;
+    /** Optional right-aligned action slot (e.g. an Upgrade Badge or Button). */
+    action?: ReactNode;
+    /** Array of metrics to display. Order preserved. */
+    metrics: UsageMetric[];
+    /** When true, show only the bars without label/value text (sparkline mode). */
+    compact?: boolean;
+}
+declare const UsageMeter: import("react").ForwardRefExoticComponent<UsageMeterProps & import("react").RefAttributes<HTMLDivElement>>;
+export { UsageMeter };

package/dist/components/primitives/action-bar/action-bar.d.ts

@@ -0,0 +1,34 @@
+import type { ElementType, HTMLAttributes, ReactNode } from "react";
+/**
+ * ActionBar — page-top action strip primitive.
+ *
+ * A horizontal flexbox row with three optional slots:
+ *   - Search input (flex-1, grows to fill)
+ *   - Filter icon button (next to search)
+ *   - Primary action button (right-aligned)
+ *
+ * Returns `null` when no props are provided — don't render an empty
+ * bar. Used standalone or composed inside `<PageShell>` (Brief #5).
+ *
+ * @example
+ *   <ActionBar
+ *     search={{ placeholder: "Search projects…", value: q, onChange: setQ }}
+ *     primaryAction={{ label: "New project", icon: Plus, onClick: openModal }}
+ *   />
+ */
+export interface ActionBarProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    search?: {
+        placeholder: string;
+        value: string;
+        onChange: (value: string) => void;
+    };
+    primaryAction?: {
+        label: ReactNode;
+        icon?: ElementType;
+        onClick: () => void;
+        loading?: boolean;
+    };
+    onFilterClick?: () => void;
+}
+declare const ActionBar: import("react").ForwardRefExoticComponent<ActionBarProps & import("react").RefAttributes<HTMLDivElement>>;
+export { ActionBar };

package/dist/components/primitives/action-bar/index.d.ts

@@ -0,0 +1 @@
+export { ActionBar, type ActionBarProps } from "./action-bar.js";

package/dist/components/primitives/agent-error-card/agent-error-card.d.ts

@@ -0,0 +1,47 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/**
+ * AgentErrorCard — inline error / blocked-state card for an agent stream.
+ *
+ * Renders when the agent run hits a wall it can't recover from on its own:
+ * rate limit, context overflow, auth lost, tool failure, network error.
+ * Severity is always destructive; the `kind` drives the icon and helps the
+ * consumer wire recovery actions in the footer slot.
+ */
+export type AgentErrorKind = "rate-limit" | "context-overflow" | "auth" | "tool-failure" | "network" | "generic";
+/**
+ * G5 T2.3 — derive an AgentErrorKind from a TheoErrorEnvelope `code` string.
+ *
+ * Maps the canonical TheoErrorCode union (theokit/server + @theokit/sdk
+ * cross-layer envelope) to the AgentErrorKind that drives the icon + visual
+ * severity in this primitive. Unknown codes fall back to 'generic'.
+ *
+ * Consumer pattern (without coupling to theokit/server types):
+ *
+ * ```tsx
+ * <AgentErrorCard envelopeCode={env.code} title={env.message} />
+ * ```
+ *
+ * Or use the helper directly when fully controlling the kind prop:
+ *
+ * ```tsx
+ * <AgentErrorCard kind={kindFromEnvelopeCode(env.code)} title={env.message} />
+ * ```
+ */
+export declare function kindFromEnvelopeCode(code: string): AgentErrorKind;
+interface AgentErrorCardProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    kind?: AgentErrorKind;
+    /**
+     * G5 T2.3 — canonical TheoErrorCode (e.g. `"UNAUTHORIZED"`, `"RATE_LIMITED"`)
+     * used to derive `kind` automatically. The explicit `kind` prop takes
+     * precedence when both are passed. Pass `envelope.code` from a
+     * `TheoErrorEnvelope` directly — no coupling to theokit/server types.
+     */
+    envelopeCode?: string;
+    title: ReactNode;
+    detail?: ReactNode;
+    /** Recovery action slot (Retry, Reset, Re-auth, etc.). */
+    actions?: ReactNode;
+    timestamp?: ReactNode;
+}
+declare const AgentErrorCard: import("react").ForwardRefExoticComponent<AgentErrorCardProps & import("react").RefAttributes<HTMLElement>>;
+export { AgentErrorCard };

package/dist/components/primitives/agent-error-card/index.d.ts

@@ -0,0 +1 @@
+export { AgentErrorCard, type AgentErrorKind, kindFromEnvelopeCode, } from "./agent-error-card.js";

package/dist/components/primitives/agent-event/agent-event.d.ts

@@ -0,0 +1,25 @@
+import type { HTMLAttributes } from "react";
+import type { AgentEvent as AgentEventModel } from "../../../types/agent.js";
+interface AgentEventProps extends HTMLAttributes<HTMLDivElement> {
+    event: AgentEventModel;
+    /**
+     * If true, clicking the row toggles `event.detail` visibility.
+     */
+    collapsible?: boolean;
+    /**
+     * Force the collapsible state (for controlled scenarios).
+     */
+    defaultOpen?: boolean;
+}
+/**
+ * AgentEvent — single event row in the agent timeline.
+ *
+ * Composition: type icon + label + path + diff stats + status icon + (optional) chevron.
+ * Running events show a spinner via motion-safe:animate-spin (respects
+ * `prefers-reduced-motion`); failed events flash red.
+ *
+ * When `collapsible` is true and `event.detail` is provided, the row renders as
+ * a native `<button>` for correct keyboard and screen-reader semantics.
+ */
+declare const AgentEvent: import("react").ForwardRefExoticComponent<AgentEventProps & import("react").RefAttributes<HTMLDivElement>>;
+export { AgentEvent };

package/dist/components/primitives/agent-event/index.d.ts

@@ -0,0 +1 @@
+export { AgentEvent } from "./agent-event.js";

package/dist/components/primitives/agent-handoff/agent-handoff.d.ts

@@ -0,0 +1,24 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface HandoffParty {
+    /** Display name, e.g. "planner". */
+    name: string;
+    /** Optional avatar initials (max 2 chars). */
+    initials?: string;
+    /** Identity tone matching AgentProfile. */
+    tone?: "primary" | "accent" | "success" | "warning" | "info" | "muted";
+}
+interface AgentHandoffProps extends HTMLAttributes<HTMLElement> {
+    from: HandoffParty;
+    to: HandoffParty;
+    /** What is being handed off — short reason / payload preview. */
+    reason: ReactNode;
+    /** Optional metadata footer (e.g. timestamp, token budget). */
+    footer?: ReactNode;
+}
+/**
+ * AgentHandoff — visual marker of one agent delegating to another. Pairs
+ * with AgentProfile for the identity tones; place it in the timeline so the
+ * user sees the baton being passed.
+ */
+declare const AgentHandoff: import("react").ForwardRefExoticComponent<AgentHandoffProps & import("react").RefAttributes<HTMLElement>>;
+export { AgentHandoff };

package/dist/components/primitives/agent-handoff/index.d.ts

@@ -0,0 +1 @@
+export { AgentHandoff, type HandoffParty } from "./agent-handoff.js";

package/dist/components/primitives/agent-profile/agent-profile.d.ts

@@ -0,0 +1,28 @@
+import type { ButtonHTMLAttributes, ReactNode } from "react";
+export interface AgentProfileDescriptor {
+    id: string;
+    /** Display name, e.g. "Coder", "Planner", "Reviewer". */
+    name: string;
+    /** Avatar initials (2 chars max). Falls back to first 2 letters of name. */
+    initials?: string;
+    /** Optional short description for tooltips and the dropdown. */
+    description?: ReactNode;
+    /**
+     * Identity tone — colors the avatar so users tell agents apart at a glance.
+     */
+    tone?: "primary" | "accent" | "success" | "warning" | "info" | "muted";
+    /** Optional badge text (e.g. "experimental"). */
+    badge?: ReactNode;
+}
+interface AgentProfileProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
+    agents: AgentProfileDescriptor[];
+    activeId: string;
+    onChange?: (id: string) => void;
+}
+/**
+ * AgentProfile — switcher between multiple agent profiles (coder, planner,
+ * reviewer, etc.). Each profile gets its own tone so the user can spot at a
+ * glance which "persona" is currently driving the session.
+ */
+declare const AgentProfile: import("react").ForwardRefExoticComponent<AgentProfileProps & import("react").RefAttributes<HTMLButtonElement>>;
+export { AgentProfile };

package/dist/components/primitives/agent-profile/index.d.ts

@@ -0,0 +1 @@
+export { AgentProfile, type AgentProfileDescriptor } from "./agent-profile.js";

package/dist/components/primitives/agent-starting-state/agent-starting-state.d.ts

@@ -0,0 +1,15 @@
+import type { OutputHTMLAttributes, ReactNode } from "react";
+interface AgentStartingStateProps extends OutputHTMLAttributes<HTMLOutputElement> {
+    /** Title shown next to the spinner. Default "Starting up…". */
+    label?: ReactNode;
+    /** Optional secondary copy explaining the bootstrap step. */
+    hint?: ReactNode;
+}
+/**
+ * AgentStartingState — full-width skeleton shown while the agent boots.
+ *
+ * Visual: violet spinner + label, optional hint below. Wrapped in a soft card.
+ * Uses semantic `<output aria-live="polite">` so screen readers announce the state.
+ */
+declare const AgentStartingState: import("react").ForwardRefExoticComponent<AgentStartingStateProps & import("react").RefAttributes<HTMLOutputElement>>;
+export { AgentStartingState };

package/dist/components/primitives/agent-starting-state/index.d.ts

@@ -0,0 +1 @@
+export { AgentStartingState } from "./agent-starting-state.js";

package/dist/components/primitives/agent-streaming/agent-streaming.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/**
+ * AgentStreaming — inline "agent is thinking / typing" indicator.
+ *
+ * Renders inside an agent stream while the model is producing a response.
+ * Default visual is 3 violet dots pulsing. If `partial` is provided, renders
+ * the streamed-so-far text with a caret. Optional `model` label on the right.
+ */
+interface AgentStreamingProps extends HTMLAttributes<HTMLDivElement> {
+    /** Streamed-so-far text. When present, replaces the dots animation. */
+    partial?: ReactNode;
+    /** Optional model name shown as a chip. */
+    model?: ReactNode;
+}
+declare const AgentStreaming: import("react").ForwardRefExoticComponent<AgentStreamingProps & import("react").RefAttributes<HTMLDivElement>>;
+export { AgentStreaming };

package/dist/components/primitives/agent-streaming/index.d.ts

@@ -0,0 +1 @@
+export { AgentStreaming } from "./agent-streaming.js";

package/dist/components/primitives/alert/alert.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/**
+ * Alert — persistent inline notice. Distinct from `Toast` (transient,
+ * corner-positioned, multiple stackable) and `EmptyState` (centered card
+ * for no-data affordances). Full-width-of-section banner that stays
+ * visible until the user acts.
+ *
+ * `intent` drives icon + color tokens. `destructive` intent renders
+ * `role="alert"` for assertive screen-reader announcement; the other
+ * three intents render `role="status"` (polite). `onDismiss`, when
+ * provided, renders a trailing `X` button. `action` slot accepts any
+ * ReactNode (typically a `<Button>` or anchor).
+ *
+ * @example
+ *   <Alert
+ *     intent="warning"
+ *     title="Verify your email"
+ *     description="We sent a link to your email."
+ *     action={<Button size="sm" onClick={resend}>Resend</Button>}
+ *   />
+ */
+export type AlertIntent = "info" | "success" | "warning" | "destructive";
+export interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, "title" | "role"> {
+    intent?: AlertIntent;
+    title?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    onDismiss?: () => void;
+}
+declare const Alert: import("react").ForwardRefExoticComponent<AlertProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Alert };

package/dist/components/primitives/alert/index.d.ts

@@ -0,0 +1 @@
+export { Alert, type AlertProps, type AlertIntent } from "./alert.js";

package/dist/components/primitives/artifact-preview/artifact-preview.d.ts

@@ -0,0 +1,25 @@
+import type { HTMLAttributes, ReactNode } from "react";
+interface ArtifactPreviewProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    title: ReactNode;
+    /** Optional source/destination label (e.g. "Google Drive", "Local · ~/reports"). */
+    source?: ReactNode;
+    /**
+     * Tabs at the bottom of the artifact (e.g. "Expense Report | Currency Summary").
+     * Caller controls the active state externally.
+     */
+    tabs?: ReactNode;
+    /** Top toolbar actions. Defaults to refresh + maximize + close. */
+    toolbar?: ReactNode;
+    onMaximize?: () => void;
+    onRefresh?: () => void;
+    onClose?: () => void;
+}
+/**
+ * ArtifactPreview — shell for previewing a generated artifact (XLSX, PDF, image…).
+ *
+ * Renders a toolbar + content slot + optional bottom tabs. The actual preview
+ * (spreadsheet, PDF embed, image) is the caller's `children`, so this stays
+ * dependency-free.
+ */
+declare const ArtifactPreview: import("react").ForwardRefExoticComponent<ArtifactPreviewProps & import("react").RefAttributes<HTMLElement>>;
+export { ArtifactPreview };

package/dist/components/primitives/artifact-preview/index.d.ts

@@ -0,0 +1 @@
+export { ArtifactPreview } from "./artifact-preview.js";

package/dist/components/primitives/attachment-chip/attachment-chip.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes } from "react";
+import type { Attachment } from "../../../types/chat.js";
+interface AttachmentChipProps extends HTMLAttributes<HTMLDivElement> {
+    attachment: Attachment;
+    onRemove?: (id: string) => void;
+}
+/**
+ * AttachmentChip — file pill shown in chat composer or message attachments row.
+ *
+ * Visual: rounded chip with type-icon + name + size + optional remove button.
+ * Truncates the name with `text-ellipsis`; full name available via title.
+ */
+declare const AttachmentChip: import("react").ForwardRefExoticComponent<AttachmentChipProps & import("react").RefAttributes<HTMLDivElement>>;
+export { AttachmentChip };

package/dist/components/primitives/attachment-chip/index.d.ts

@@ -0,0 +1 @@
+export { AttachmentChip } from "./attachment-chip.js";

package/dist/components/primitives/audit-log-entry/audit-log-entry.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export type AuditActorKind = "user" | "agent" | "system";
+export type AuditSeverity = "info" | "warning" | "error";
+export interface AuditEntry {
+    id: string;
+    /** Who triggered the action. */
+    actor: {
+        kind: AuditActorKind;
+        name: string;
+    };
+    /** Verb / action label, e.g. "wrote file", "ran command". */
+    action: string;
+    /** Target of the action (file path, command, etc). */
+    target?: ReactNode;
+    /** ISO timestamp / friendly label. */
+    timestamp: string;
+    severity?: AuditSeverity;
+    /** Optional detail block (multi-line). */
+    detail?: ReactNode;
+}
+interface AuditLogEntryProps extends HTMLAttributes<HTMLElement> {
+    entry: AuditEntry;
+}
+/**
+ * AuditLogEntry — one row in the agent audit log. Tells the user exactly
+ * who did what and when. Severity colors the timestamp and target.
+ */
+declare const AuditLogEntry: import("react").ForwardRefExoticComponent<AuditLogEntryProps & import("react").RefAttributes<HTMLElement>>;
+export { AuditLogEntry };

package/dist/components/primitives/audit-log-entry/index.d.ts

@@ -0,0 +1 @@
+export { AuditLogEntry, type AuditActorKind, type AuditEntry, type AuditSeverity, } from "./audit-log-entry.js";

package/dist/components/primitives/auto-compact-notice/auto-compact-notice.d.ts

@@ -0,0 +1,24 @@
+import type { HTMLAttributes, ReactNode } from "react";
+interface AutoCompactNoticeProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    /** Optional custom title. */
+    title?: ReactNode;
+    /**
+     * How many turns until the next auto-compaction. Used to render an inline
+     * countdown chip.
+     */
+    turnsRemaining?: number;
+    /** Approx tokens that will be removed/summarized. */
+    tokensToCompact?: number;
+    onCompactNow?: () => void;
+    onDismiss?: () => void;
+}
+/**
+ * AutoCompactNotice — inline banner warning the user that the agent is
+ * about to summarize / compact older context. Lets them act early (compact
+ * now) or dismiss.
+ *
+ * Critical for transparency: a user must not be surprised by silent context
+ * loss. This component announces it before it happens.
+ */
+declare const AutoCompactNotice: import("react").ForwardRefExoticComponent<AutoCompactNoticeProps & import("react").RefAttributes<HTMLElement>>;
+export { AutoCompactNotice };

package/dist/components/primitives/auto-compact-notice/index.d.ts

@@ -0,0 +1 @@
+export { AutoCompactNotice } from "./auto-compact-notice.js";

package/dist/components/primitives/avatar/avatar.d.ts

@@ -0,0 +1,26 @@
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import { type VariantProps } from "class-variance-authority";
+import type { ComponentPropsWithoutRef } from "react";
+/**
+ * Avatar — user/team avatar with safe fallback to initials.
+ *
+ * Composition:
+ *   <Avatar size="md">
+ *     <Avatar.Image src="…" alt="…" />
+ *     <Avatar.Fallback>AA</Avatar.Fallback>
+ *   </Avatar>
+ *
+ * Built on Radix Avatar (handles image load failures → fallback automatically).
+ * Sizes scale on the root; fallback inherits the size's text scale.
+ */
+declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | "xl" | null | undefined;
+    tone?: "accent" | "primary" | "muted" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface AvatarProps extends ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
+}
+declare const Avatar: import("react").ForwardRefExoticComponent<AvatarProps & import("react").RefAttributes<HTMLSpanElement>> & {
+    Image: import("react").ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & import("react").RefAttributes<HTMLImageElement>, "ref"> & import("react").RefAttributes<HTMLImageElement>>;
+    Fallback: import("react").ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & import("react").RefAttributes<HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+};
+export { Avatar, avatarVariants };

package/dist/components/primitives/avatar/index.d.ts

@@ -0,0 +1 @@
+export { Avatar, avatarVariants } from "./avatar.js";

package/dist/components/primitives/badge/badge.d.ts

@@ -0,0 +1,33 @@
+import { type VariantProps } from "class-variance-authority";
+import type { HTMLAttributes } from "react";
+/**
+ * Badge — small status / tag indicator.
+ *
+ * Variants:
+ *   - default     muted surface, hairline border
+ *   - primary     violet outline + soft violet bg
+ *   - accent      burnt sienna (celebration / pro / beta)
+ *   - success     deploy succeeded
+ *   - warning     attention needed
+ *   - destructive failed
+ *   - outline     transparent, just border
+ *
+ * Status dots are inlined via `<Badge.Dot />` for things like "Building…",
+ * "Running", "Failed" rows in deployment lists.
+ */
+declare const badgeVariants: (props?: ({
+    variant?: "accent" | "primary" | "success" | "warning" | "destructive" | "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
+}
+declare const Badge: import("react").ForwardRefExoticComponent<BadgeProps & import("react").RefAttributes<HTMLSpanElement>>;
+interface BadgeDotProps extends HTMLAttributes<HTMLSpanElement> {
+    pulse?: boolean;
+    tone?: "primary" | "accent" | "success" | "warning" | "destructive" | "muted";
+}
+declare const Dot: import("react").ForwardRefExoticComponent<BadgeDotProps & import("react").RefAttributes<HTMLSpanElement>>;
+declare const BadgeWithDot: typeof Badge & {
+    Dot: typeof Dot;
+};
+export { BadgeWithDot as Badge, badgeVariants };

package/dist/components/primitives/badge/index.d.ts

@@ -0,0 +1 @@
+export { Badge, badgeVariants, type BadgeProps } from "./badge.js";

package/dist/components/primitives/branch-indicator/branch-indicator.d.ts

@@ -0,0 +1,13 @@
+import { type HTMLAttributes } from "react";
+/**
+ * BranchIndicator — small "×N" pill that shows when a run was retried/branched.
+ *
+ * Renders `null` when `branchCount < 2` OR when not a positive integer.
+ * EC-10 guard: parametrized over [-1, 0, 0.5] in tests.
+ */
+export interface BranchIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    branchCount: number;
+    tooltipText?: string;
+    "data-testid"?: string;
+}
+export declare const BranchIndicator: import("react").ForwardRefExoticComponent<BranchIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/primitives/branch-indicator/index.d.ts

@@ -0,0 +1 @@
+export { BranchIndicator, type BranchIndicatorProps, } from "./branch-indicator.js";

package/dist/components/primitives/browser-controls/browser-controls.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes } from "react";
+interface BrowserControlsProps extends HTMLAttributes<HTMLDivElement> {
+    url: string;
+    onUrlChange?: (next: string) => void;
+    onBack?: () => void;
+    onForward?: () => void;
+    onReload?: () => void;
+    /**
+     * Disable URL editing (some previews are read-only).
+     */
+    readOnlyUrl?: boolean;
+}
+/**
+ * BrowserControls — back/forward/reload + URL bar.
+ *
+ * Used as the top of PreviewPanel in the Code workspace.
+ */
+declare const BrowserControls: import("react").ForwardRefExoticComponent<BrowserControlsProps & import("react").RefAttributes<HTMLDivElement>>;
+export { BrowserControls };

package/dist/components/primitives/browser-controls/index.d.ts

@@ -0,0 +1 @@
+export { BrowserControls } from "./browser-controls.js";

package/dist/components/primitives/build-log-stream/build-log-stream.d.ts

@@ -0,0 +1,51 @@
+import type { HTMLAttributes } from "react";
+export type LogLevel = "info" | "warn" | "error" | "success" | "debug";
+export interface LogLine {
+    id: string;
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    source?: string;
+}
+interface BuildLogStreamProps extends HTMLAttributes<HTMLDivElement> {
+    lines: LogLine[];
+    /**
+     * If true, shows level filter chips above the stream.
+     */
+    filterable?: boolean;
+    /**
+     * Controlled filter — which levels are visible. Empty Set = show all.
+     *
+     * Pick one mode: either always pass `visibleLevels` + `onVisibleLevelsChange`
+     * (controlled), or never (uncontrolled). Mixing the two between renders is
+     * not supported and may produce surprising state.
+     */
+    visibleLevels?: Set<LogLevel>;
+    onVisibleLevelsChange?: (levels: Set<LogLevel>) => void;
+    /**
+     * Height of the scrollable region.
+     */
+    height?: string | number;
+    /**
+     * Maximum number of lines rendered. When exceeded, only the tail is shown
+     * and a banner indicates truncation. Defaults to 2000 — set higher with
+     * caution; React reconciliation cost scales linearly.
+     */
+    maxLines?: number;
+    /**
+     * Screen-reader live-region politeness for newly appended lines. Defaults
+     * to `"off"` because build-log streams can be high-volume; opt into
+     * `"polite"` only when running the build in the foreground.
+     */
+    live?: "off" | "polite";
+}
+/**
+ * BuildLogStream — terminal-like log viewer with timestamps + level coloring.
+ *
+ * Used in Code workspace and PaaS deployment views. Geist Mono throughout.
+ * Lines fade in via animate-fade-in-up on mount; new lines (when prepended/appended)
+ * are not animated to avoid feedback noise (consumer's responsibility to render
+ * incrementally if needed).
+ */
+declare const BuildLogStream: import("react").ForwardRefExoticComponent<BuildLogStreamProps & import("react").RefAttributes<HTMLDivElement>>;
+export { BuildLogStream };

package/dist/components/primitives/build-log-stream/index.d.ts

@@ -0,0 +1 @@
+export { BuildLogStream, type LogLevel, type LogLine } from "./build-log-stream.js";