@tangle-network/sandbox-ui 0.113.7 → 0.114.0

package/dist/index-DPePq7c8.d.ts

@@ -0,0 +1,1340 @@
+import "./model-brand-B9A4H9pJ.js";
+import "./template-card-L-4gmjx2.js";
+import * as React$1 from "react";
+import React, { ReactNode } from "react";
+import { Clock } from "lucide-react";
+import { HarnessType as HarnessType$1 } from "@tangle-network/agent-interface";
+//#region src/dashboard/app-sidebar.d.ts
+interface SidebarUser {
+  email: string;
+  name?: string;
+  tier?: string;
+  avatarUrl?: string;
+}
+/** Theme modes offered by the account menu's Appearance section. */
+type ThemeMode = "light" | "dark" | "system";
+/**
+ * Host-supplied controller for the account-menu Appearance section. The rail is
+ * theme-engine-agnostic: each app wires this to its own theme hook (gtm-agent
+ * uses the shared `useTheme`; the sandbox app uses its `vault`-aware
+ * `useThemeMode`). Provide it to {@link ProfileAvatar} to render Light/Dark/System.
+ */
+interface AppearanceController {
+  value: ThemeMode;
+  onChange: (mode: ThemeMode) => void;
+  /** Which modes to offer, in order. Defaults to all three. */
+  modes?: ThemeMode[];
+}
+/**
+ * Compact light/dark switch driven by the shared `useTheme` hook.
+ *
+ * @deprecated The redesigned rail no longer renders a standalone theme toggle —
+ * theme lives in the account menu as a Light/Dark/System control via the
+ * `appearance` controller on {@link ProfileAvatar} (and both layouts). Kept for
+ * backward compatibility; not used by `SidebarLayout`/`DashboardLayout`.
+ */
+declare function RailThemeToggle({ className }: {
+  className?: string;
+}): React$1.JSX.Element;
+interface RailCollapseToggleProps {
+  /** Whether the rail is currently collapsed (icon-only). */
+  collapsed: boolean;
+  /** Render with a label beside the chevron (expanded/labeled rail) vs. icon-only. */
+  showLabel?: boolean;
+  onToggle: () => void;
+  className?: string;
+}
+declare function RailCollapseToggle({ collapsed, showLabel, onToggle, className }: RailCollapseToggleProps): React$1.JSX.Element;
+interface RailHeaderProps {
+  /** Brand mark shown on the left, e.g. `<Logo iconOnly />`. */
+  brand?: React$1.ReactNode;
+  /** Destination for the brand link. When set with `LinkComponent`, the brand is a link. */
+  brandHref?: string;
+  /**
+   * Optional middle content (e.g. a project/workspace switcher).
+   *
+   * When `brand` is set, this is expanded-only — the collapsed rail has room
+   * for the mark alone. When `brand` is NOT set this content owns the rail top
+   * in BOTH states, so it is also rendered collapsed; read `useSidebar()` to
+   * swap in a compact mark there.
+   */
+  children?: React$1.ReactNode;
+  /** Whether the rail is collapsed (icon-only). */
+  collapsed: boolean;
+  /** Collapse/expand the rail. */
+  onToggle: () => void;
+  /**
+   * Whether the rail can collapse/expand. When `false`, no panel toggle is
+   * rendered and the collapsed header shows the brand without the hover-morph.
+   * Defaults to `true`.
+   */
+  collapsible?: boolean;
+  LinkComponent?: React$1.ComponentType<any>;
+  className?: string;
+}
+declare function RailHeader({ brand, brandHref, children, collapsed, onToggle, collapsible, LinkComponent, className }: RailHeaderProps): React$1.JSX.Element;
+interface SidebarProps {
+  children: React$1.ReactNode;
+  className?: string;
+  style?: React$1.CSSProperties;
+}
+declare function Sidebar({ children, className, style }: SidebarProps): React$1.JSX.Element;
+interface SidebarRailProps {
+  children: React$1.ReactNode;
+  className?: string;
+  /**
+   * Render the rail at the wider mobile-drawer width so labels fit
+   * beside the icons. Defaults to the 64px icon-only rail used on
+   * desktop.
+   */
+  wide?: boolean;
+}
+declare function SidebarRail({ children, className, wide }: SidebarRailProps): React$1.JSX.Element;
+interface SidebarRailHeaderProps {
+  children: React$1.ReactNode;
+  className?: string;
+}
+/**
+ * @deprecated Superseded by {@link RailHeader}, the three-slot header
+ * (brand · middle · panel toggle) used by both shells. Kept for backward
+ * compatibility; no longer rendered by `SidebarLayout`/`DashboardLayout`.
+ */
+declare function SidebarRailHeader({ children, className }: SidebarRailHeaderProps): React$1.JSX.Element;
+interface SidebarRailNavProps {
+  children: React$1.ReactNode;
+  className?: string;
+  /**
+   * Click handler on the `<nav>` itself. Layouts use it (with a
+   * `target === currentTarget` guard) so clicking the empty body of a collapsed
+   * rail expands it, without intercepting clicks on the nav items.
+   */
+  onClick?: React$1.MouseEventHandler<HTMLElement>;
+}
+declare function SidebarRailNav({ children, className, onClick }: SidebarRailNavProps): React$1.JSX.Element;
+interface SidebarRailFooterProps {
+  children: React$1.ReactNode;
+  className?: string;
+}
+declare function SidebarRailFooter({ children, className }: SidebarRailFooterProps): React$1.JSX.Element;
+interface RailSeparatorProps {
+  className?: string;
+}
+declare function RailSeparator({ className }: RailSeparatorProps): React$1.JSX.Element;
+interface RailButtonProps {
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  label: string;
+  isActive?: boolean;
+  badge?: number;
+  onClick?: () => void;
+  className?: string;
+  /** Show label text next to icon (for mobile drawer) */
+  showLabel?: boolean;
+  /**
+   * Render the rail-button styling onto a single child element (e.g. a router
+   * `<Link>`) instead of an inner `<button>`. The child receives the button
+   * classes, `title`, and the icon/label/badge as its content — so navigation
+   * items stay real anchors (keyboard, cmd-click, prefetch) without copying the
+   * class recipe or nesting `<a><button>`.
+   */
+  asChild?: boolean;
+  children?: React$1.ReactNode;
+  /**
+   * `"primary"` gives the item a distinct emphasized pill (accent fill + accent
+   * border) so it stands out from the rest of the nav, e.g. a "New" action.
+   * Defaults to `"normal"`.
+   */
+  variant?: "normal" | "primary";
+  /**
+   * Inline style for the rendered row. Layouts use it to set `--stagger-index`
+   * so a rail of nav items arrives as a sequence rather than a flash; the
+   * variable has to land on the animated element itself, which is this one.
+   */
+  style?: React$1.CSSProperties;
+}
+declare function RailButton({ icon: Icon, label, isActive, badge, onClick, className, showLabel, asChild, children, variant, style }: RailButtonProps): React$1.JSX.Element;
+interface RailFlyoutProps {
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  label: string;
+  /** Highlight the trigger (e.g. when a child route is active). */
+  isActive?: boolean;
+  /** Show the label text beside the icon (labeled rail) vs. icon-only. */
+  showLabel?: boolean;
+  /** Heading rendered at the top of the open flyout. Defaults to `label`. */
+  title?: string;
+  /** Flyout body — the sub-surfaces revealed when the item is opened. */
+  children: React$1.ReactNode;
+  className?: string;
+  /** @see {@link RailButtonProps.style} — carries `--stagger-index` in a rail. */
+  style?: React$1.CSSProperties;
+}
+/**
+ * A rail entry that reveals its sub-surfaces in a small panel anchored to the
+ * RIGHT of the rail item, rather than pushing the rail open with an inline
+ * accordion. Opens on click, closes on outside-click, Escape, or selecting an
+ * item inside it. Use for a single "door" (e.g. Studio) that fronts several
+ * related destinations without permanently spending rail height on them.
+ */
+declare function RailFlyout({ icon: Icon, label, isActive, showLabel, title, children, className, style }: RailFlyoutProps): React$1.JSX.Element;
+/** A single entry in a sub-item's hover actions menu (kebab). */
+interface RailSubItemAction {
+  id: string;
+  label: string;
+  icon?: React$1.ComponentType<{
+    className?: string;
+  }>;
+  /** Style the item as a destructive action (e.g. delete). */
+  destructive?: boolean;
+  onSelect: () => void;
+}
+/** A sub-destination revealed by a {@link RailExpandable} item. */
+interface RailExpandableSubItem {
+  id: string;
+  label: string;
+  icon?: React$1.ComponentType<{
+    className?: string;
+  }>;
+  href: string;
+  prefetch?: "none" | "intent" | "render" | "viewport";
+  /** Show a live working indicator on the row while the item is busy. */
+  isLoading?: boolean;
+  /** Render the row emphasized (bold + accent) so it stands out — e.g. a
+   *  trailing "view all" action below a capped list. */
+  emphasis?: boolean;
+  /** Mark the row as unread — bold label + a leading dot. Suppressed while
+   *  `isLoading` so a responding row shows only the working indicator. */
+  unread?: boolean;
+  /** Hover-revealed kebab actions (e.g. rename/delete). Rendered on the
+   *  labeled rail only; ignored in the collapsed-rail flyout. */
+  actions?: RailSubItemAction[];
+}
+interface RailExpandableProps {
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  label: string;
+  /** Destination for the row itself. Clicking the label navigates here. */
+  href?: string;
+  /** Highlight the row (e.g. its own route or a child route is active). */
+  isActive?: boolean;
+  /** Labeled (expanded) rail vs. icon-only (collapsed) rail. */
+  showLabel?: boolean;
+  /** Fixed sub-items. Mutually exclusive with `loadSubItems`. */
+  subItems?: RailExpandableSubItem[];
+  /** Lazy sub-items — called once on first open; the result is cached. */
+  loadSubItems?: () => Promise<RailExpandableSubItem[]>;
+  /** Start expanded on mount (labeled rail). Defaults to collapsed. */
+  defaultOpen?: boolean;
+  /** Ids of sub-items whose route is active (drives sub-item highlight). */
+  activeSubIds?: string[];
+  /** Shown when the resolved sub-item list is empty. */
+  emptyLabel?: string;
+  /** Called when the row or a sub-item navigates (e.g. to close a mobile drawer). */
+  onNavigate?: () => void;
+  LinkComponent?: React$1.ComponentType<any>;
+  className?: string;
+  /** @see {@link RailButtonProps.style} — carries `--stagger-index` in a rail. */
+  style?: React$1.CSSProperties;
+}
+/**
+ * A nav item that reveals sub-items. On the labeled rail it expands inline as an
+ * accordion: the leading icon morphs into a chevron on hover, clicking the
+ * chevron toggles the list, and clicking the label navigates (`href`). On the
+ * icon-only rail it shows the sub-items in a right-anchored flyout on hover.
+ * Sub-items can be fixed (`subItems`) or lazy (`loadSubItems`, with a loading
+ * skeleton). Used for e.g. a "History" entry fronting recent sessions.
+ */
+declare function RailExpandable({ icon: Icon, label, href, isActive, showLabel, subItems, loadSubItems, activeSubIds, emptyLabel, defaultOpen, onNavigate, LinkComponent, className, style }: RailExpandableProps): React$1.JSX.Element;
+interface RailModeButtonProps {
+  mode: string;
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  label: string;
+  badge?: number;
+  className?: string;
+  /** Show label text next to icon (for mobile drawer) */
+  showLabel?: boolean;
+  /** @see {@link RailButtonProps.style} — carries `--stagger-index` in a rail. */
+  style?: React$1.CSSProperties;
+}
+declare function RailModeButton({ mode, icon, label, badge, className, showLabel, style }: RailModeButtonProps): React$1.JSX.Element;
+interface SidebarPanelProps {
+  children: React$1.ReactNode;
+  className?: string;
+}
+declare function SidebarPanel({ children, className }: SidebarPanelProps): React$1.JSX.Element;
+interface SidebarPanelHeaderProps {
+  children?: React$1.ReactNode;
+  title?: string;
+  className?: string;
+}
+declare function SidebarPanelHeader({ children, title, className }: SidebarPanelHeaderProps): React$1.JSX.Element;
+interface SidebarPanelContentProps {
+  children: React$1.ReactNode;
+  className?: string;
+}
+declare function SidebarPanelContent({ children, className }: SidebarPanelContentProps): React$1.JSX.Element;
+interface SidebarContentProps {
+  children: React$1.ReactNode;
+  className?: string;
+}
+declare function SidebarContent({ children, className }: SidebarContentProps): React$1.JSX.Element;
+interface ProfileAvatarProps {
+  user?: SidebarUser | null;
+  isLoading?: boolean;
+  onLogout?: () => void;
+  onSettingsClick?: () => void;
+  settingsHref?: string;
+  /** Extra dropdown items rendered before settings/logout */
+  children?: React$1.ReactNode;
+  className?: string;
+  /** Show name/email beside the avatar (for a labeled rail) instead of an icon-only avatar button. */
+  showDetails?: boolean;
+  /**
+   * When provided, the menu renders an Appearance section (Light/Dark/System)
+   * driven by this host-supplied controller. Omit to hide it.
+   */
+  appearance?: AppearanceController;
+  LinkComponent?: React$1.ComponentType<any>;
+}
+declare function ProfileAvatar({ user, isLoading, onLogout, onSettingsClick, settingsHref, children, className, showDetails, appearance, LinkComponent }: ProfileAvatarProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/rail-tooltip.d.ts
+interface RailTooltipProps {
+  /** Tooltip text shown to the right of the trigger. */
+  label: string;
+  /** The trigger element (icon button / link). */
+  children: React$1.ReactNode;
+  /** Disable the tooltip (e.g. when the rail is expanded and the label is inline). */
+  disabled?: boolean;
+  className?: string;
+}
+/**
+ * Quiet styled tooltip for the icon-only rail, rendered in a portal anchored to
+ * the RIGHT of the trigger. The portal is essential: the rail's nav is a
+ * vertical scroll container (`overflow-y-auto`), which the CSS spec forces to
+ * also clip horizontally — an in-flow tooltip would be cut off at the rail's
+ * edge. Positioned via `getBoundingClientRect` on hover/focus, shown after a
+ * short delay, and `pointer-events-none` so it never interferes with the
+ * trigger. Hidden from the a11y tree (`aria-hidden`) since the trigger already
+ * carries an accessible name.
+ *
+ * `disabled` suppresses the tooltip but NOT the wrapper. Returning a fragment
+ * instead changes the rendered element type, and React reconciles by type: the
+ * trigger inside would be torn down and rebuilt every time the rail toggles
+ * between icon-only and labeled. A rebuilt element replays its CSS entrance, so
+ * the whole nav would re-stagger on a collapse that moved nothing off screen.
+ * One element type, both states.
+ */
+declare function RailTooltip({ label, children, disabled, className }: RailTooltipProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/sidebar-context.d.ts
+/** Width constants (px) — Tangle Quiet density (ChatGPT-minimal) */
+declare const SIDEBAR_RAIL_WIDTH = 56;
+declare const SIDEBAR_PANEL_WIDTH = 268;
+declare const SIDEBAR_TOTAL_WIDTH: number;
+/**
+ * Width of the mobile drawer when the rail is rendered with labels
+ * (`showLabel` on {@link RailButton}). The standard 64px rail is only
+ * wide enough for icons; labels need a wider container to avoid truncation.
+ */
+declare const SIDEBAR_MOBILE_WIDTH = 256;
+/**
+ * Rail width when labels are shown beside icons on desktop. The default rail is
+ * icon-only at {@link SIDEBAR_RAIL_WIDTH}; a labeled rail needs room for the
+ * longest nav label plus its badge.
+ */
+declare const SIDEBAR_RAIL_LABELED_WIDTH = 248;
+interface SidebarContextValue {
+  /** Whether the content panel beside the rail is open */
+  panelOpen: boolean;
+  setPanelOpen: (open: boolean) => void;
+  togglePanel: () => void;
+  /** Current panel mode (app-defined, e.g. "projects", "batches") */
+  mode: string;
+  setMode: (mode: string) => void;
+  /** Switch mode — opens panel if closed, closes if same mode clicked */
+  switchMode: (mode: string) => void;
+  /** Whether entire sidebar (rail + panel) is hidden (focus mode) */
+  hidden: boolean;
+  setHidden: (hidden: boolean) => void;
+  /** Computed content margin in px */
+  contentMargin: number;
+  /** Whether there are panels at all */
+  hasPanels: boolean;
+  /**
+   * Whether the labeled nav rail is collapsed to the icon-only width. Independent
+   * of {@link panelOpen} (the slide-out content panel) — two separate collapses.
+   * Only meaningful when the rail is label-capable; an icon-only rail stays
+   * icon-only regardless.
+   */
+  railCollapsed: boolean;
+  setRailCollapsed: (collapsed: boolean) => void;
+  toggleRail: () => void;
+  /**
+   * Rail width in px — derived from {@link railCollapsed}: the icon-only width
+   * when collapsed (or when the rail is not label-capable), the labeled width
+   * when expanded.
+   */
+  railWidth: number;
+}
+interface SidebarProviderProps {
+  defaultPanelOpen?: boolean;
+  defaultMode?: string;
+  hasPanels?: boolean;
+  /**
+   * Whether the rail can show labels beside icons. When `true`, the expanded
+   * rail renders at {@link SIDEBAR_RAIL_LABELED_WIDTH} and the user can collapse
+   * it to the icon-only {@link SIDEBAR_RAIL_WIDTH} via {@link toggleRail}. When
+   * `false` (default) the rail is permanently icon-only and `railCollapsed` has
+   * no width effect.
+   */
+  labeledRail?: boolean;
+  /**
+   * Controlled panel-open state. When provided, the provider treats panel
+   * visibility as controlled: it never reads or writes localStorage and
+   * reports changes through {@link onPanelOpenChange} instead. Use this in
+   * server-rendered apps — seed it from a value the server also has (e.g. a
+   * cookie) so the SSR markup matches the first client render. The localStorage
+   * read in the uncontrolled path is what diverges from SSR and breaks hydration.
+   */
+  panelOpen?: boolean;
+  onPanelOpenChange?: (open: boolean) => void;
+  /**
+   * Controlled rail-collapsed state. Parallels {@link panelOpen}: when provided
+   * the provider never touches localStorage for the rail and reports changes
+   * through {@link onRailCollapsedChange}. Seed it from a cookie in SSR apps so
+   * the rail width survives reload without a hydration mismatch.
+   */
+  railCollapsed?: boolean;
+  onRailCollapsedChange?: (collapsed: boolean) => void;
+  /** Initial rail-collapsed state for the uncontrolled path. Default: expanded. */
+  defaultRailCollapsed?: boolean;
+  children: React$1.ReactNode;
+}
+declare function SidebarProvider({ defaultPanelOpen, defaultMode, hasPanels, labeledRail, panelOpen: controlledPanelOpen, onPanelOpenChange, railCollapsed: controlledRailCollapsed, onRailCollapsedChange, defaultRailCollapsed, children }: SidebarProviderProps): React$1.JSX.Element;
+declare function useSidebar(): SidebarContextValue;
+//#endregion
+//#region src/dashboard/credit-balance.d.ts
+interface CreditBalanceProps {
+  amount: number;
+  description?: string;
+  onTopUp?: (amount: number) => void;
+  quickAmounts?: number[];
+  className?: string;
+}
+declare function CreditBalance({ amount, description, onTopUp, quickAmounts, className }: CreditBalanceProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/out-of-credits.d.ts
+/**
+ * Canonical "out of credits" UX, shared across every Tangle product.
+ *
+ * Backends emit a 402 with `{ error, code: "insufficient_balance", manageUrl,
+ * plan?, remainingBalanceUsd? }` when a billable action can't be funded. The
+ * frontend catches it, calls {@link parseInsufficientBalance} to extract the
+ * shape, and renders {@link OutOfCreditsModal} — a single "add credits /
+ * subscribe" CTA that links to the platform billing page (`manageUrl`).
+ *
+ * This replaces the per-app bespoke handling (silent failures, raw errors,
+ * un-clickable text) with one component so the funnel is uniform + testable.
+ */
+declare const INSUFFICIENT_BALANCE_CODE = "insufficient_balance";
+interface InsufficientBalance {
+  /** Platform billing URL to add credits / subscribe / connect a card. */
+  manageUrl: string;
+  /** Current plan, when the backend includes it. */
+  plan?: string;
+  /** Remaining balance (USD), when included. */
+  remainingBalanceUsd?: number;
+  /** Backend-supplied human message, when included. */
+  message?: string;
+}
+/**
+ * Detect + parse an insufficient-balance 402 from a parsed JSON body. Returns
+ * the typed shape when the body is an insufficient-balance error, else `null`.
+ * Falls back to the platform default billing URL when the backend omits
+ * `manageUrl` so the CTA is never dead.
+ */
+declare function parseInsufficientBalance(payload: unknown, opts?: {
+  defaultManageUrl?: string;
+}): InsufficientBalance | null;
+interface OutOfCreditsModalProps {
+  /** Parsed insufficient-balance details (from {@link parseInsufficientBalance}). */
+  balance: InsufficientBalance | null;
+  /** Dismiss handler. When omitted the modal cannot be closed (hard paywall). */
+  onClose?: () => void;
+  /** Override the primary CTA label. Default "Add credits". */
+  ctaLabel?: string;
+  className?: string;
+}
+/**
+ * Modal shown when a user runs out of credits. Renders nothing when
+ * `balance` is null. The primary CTA opens the platform billing page where
+ * the user can add credits, subscribe, or connect a card for pay-per-use.
+ */
+declare function OutOfCreditsModal({ balance, onClose, ctaLabel, className }: OutOfCreditsModalProps): React$1.JSX.Element | null;
+//#endregion
+//#region src/dashboard/cluster-status-bar.d.ts
+interface ClusterStatusItem {
+  icon?: React$1.ReactNode;
+  label: string;
+  value: React$1.ReactNode;
+  valueClass?: string;
+}
+interface ClusterStatusBarProps {
+  items: ClusterStatusItem[];
+  latency?: string;
+  className?: string;
+}
+declare function ClusterStatusBar({ items, latency, className }: ClusterStatusBarProps): React$1.JSX.Element | null;
+//#endregion
+//#region src/dashboard/resource-meter.d.ts
+interface ResourceMeterProps {
+  label: string;
+  value: number;
+  max?: number;
+  unit?: string;
+  icon?: React$1.ReactNode;
+  /**
+   * Overrides the right-hand readout. Use for values the raw
+   * `value{unit}/max{unit}` template can't express, e.g. byte sizes
+   * ("1.2 GB / 4 GB"). The bar fill still derives from value/max.
+   */
+  valueLabel?: string;
+  className?: string;
+}
+declare function ResourceMeter({ label, value, max, unit, valueLabel, icon, className }: ResourceMeterProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/resource-snapshot.d.ts
+interface ResourceSnapshotItem {
+  /** Stable React key; falls back to `label` plus row index when omitted. */
+  id?: string;
+  label: string;
+  /** Current value, in the same unit as `max`. */
+  value: number;
+  /** Full-scale value. Omit to treat `value` as a 0-100 percent. */
+  max?: number;
+  /** Unit suffix for the default `value{unit}/max{unit}` readout. */
+  unit?: string;
+  /** Right-hand readout override (e.g. "1.2 GB / 4 GB"). */
+  valueLabel?: string;
+  icon?: React$1.ReactNode;
+}
+interface ResourceSnapshotProps {
+  title?: string;
+  /** Right-aligned header slot, e.g. a "View metrics" link. */
+  action?: React$1.ReactNode;
+  items: ResourceSnapshotItem[];
+  loading?: boolean;
+  /** When set, replaces the meters with an error line. */
+  error?: string | null;
+  className?: string;
+}
+/**
+ * Compact at-a-glance resource panel: a stack of {@link ResourceMeter}
+ * rows for an instantaneous CPU / memory / disk read. Time-series detail
+ * belongs in a dedicated metrics view; this is the snapshot.
+ */
+declare function ResourceSnapshot({ title, action, items, loading, error, className }: ResourceSnapshotProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/activity-feed.d.ts
+interface ActivityItem {
+  /** Stable key. */
+  id: string;
+  icon?: React$1.ReactNode;
+  title: string;
+  detail?: string;
+  /** Wall-clock ms. Drives ordering and the relative timestamp. */
+  timestamp?: number;
+}
+interface ActivityFeedProps {
+  title?: string;
+  action?: React$1.ReactNode;
+  items: ActivityItem[];
+  loading?: boolean;
+  /** Caps the rendered rows after sorting newest-first. Default 6. */
+  maxItems?: number;
+  emptyLabel?: string;
+  className?: string;
+}
+/**
+ * Newest-first list of recent sandbox activity (commits, snapshots,
+ * lifecycle events). Items are sorted by `timestamp` descending here so
+ * callers can merge heterogeneous sources without pre-sorting.
+ */
+declare function ActivityFeed({ title, action, items, loading, maxItems, emptyLabel, className }: ActivityFeedProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/sandbox-card.d.ts
+type SandboxStatus = "running" | "hibernating" | "provisioning" | "stopped" | "failed" | "archived" | "creating";
+type TeamRole = "owner" | "admin" | "member" | "viewer";
+interface SandboxCardData {
+  id: string;
+  name: string;
+  nodeId?: string;
+  status: SandboxStatus;
+  /**
+   * A user-customized container image (e.g. `ghcr.io/acme/api:sha-1a2b`).
+   * Surfaced only when set — sandboxes run a managed agent runtime image by
+   * default, which is not operator-relevant and is intentionally not shown.
+   */
+  customImage?: string;
+  /** @deprecated The product has no user-selectable environment. Use `customImage`. */
+  image?: string;
+  /** @deprecated No longer rendered; the card derives its glyph from status. */
+  imageIcon?: React$1.ReactNode;
+  /** Allocated vCPU count. */
+  vcpu?: number;
+  /** Live CPU utilization, 0–100. */
+  cpuPercent?: number;
+  /** Live RAM in use (GB). */
+  ramUsed?: number;
+  /** Allocated RAM (GB). */
+  ramTotal?: number;
+  /** Disk in use (GB). */
+  diskUsed?: number;
+  /** Allocated disk (GB). */
+  diskTotal?: number;
+  /** Human-readable uptime since last start, e.g. "3d 4h" or "12m". */
+  uptime?: string;
+  provisioningMessage?: string;
+  provisioningPercent?: number;
+  archivedAt?: string;
+  /**
+   * Populated when the sandbox is shared with a team. Drives a small
+   * "shared with X" badge in the card header so a user can see at a
+   * glance which of their sandboxes are personal vs. collaborative.
+   */
+  team?: {
+    id: string;
+    name?: string;
+    /** Caller's role in the team — the card uses this to gate the Delete action. */
+    role: TeamRole;
+  };
+}
+interface SandboxCardProps {
+  sandbox: SandboxCardData;
+  onOpenIDE?: (id: string) => void;
+  onOpenTerminal?: (id: string) => void;
+  /** Preferred start handler; drives the footer + dropdown Resume action. */
+  onResume?: (id: string) => void;
+  /**
+   * @deprecated Use `onResume`. Retained for back-compat: only a
+   * `hibernating` card falls back to `onWake` when `onResume` is absent.
+   */
+  onWake?: (id: string) => void;
+  onRestore?: (id: string) => void;
+  onDelete?: (id: string) => void;
+  onStop?: (id: string) => void;
+  onFork?: (id: string) => void;
+  onKeepAlive?: (id: string) => void;
+  onUsage?: (id: string) => void;
+  onHealth?: (id: string) => void;
+  className?: string;
+}
+declare function canAdminSandbox(sandbox: SandboxCardData): boolean;
+declare function SandboxCard({ sandbox, onOpenIDE, onOpenTerminal, onWake, onRestore, onDelete, onStop, onResume, onFork, onKeepAlive, onUsage, onHealth, className }: SandboxCardProps): React$1.JSX.Element;
+interface NewSandboxCardProps {
+  onClick?: () => void;
+  className?: string;
+}
+declare function NewSandboxCard({ onClick, className }: NewSandboxCardProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/sandbox-table.d.ts
+interface SandboxTableProps {
+  sandboxes: SandboxCardData[];
+  page?: number;
+  pageSize?: number;
+  total?: number;
+  onPageChange?: (page: number) => void;
+  onOpenIDE?: (id: string) => void;
+  onOpenTerminal?: (id: string) => void;
+  onSSH?: (id: string) => void;
+  /**
+   * Resume a stopped / failed / archived sandbox, or wake a hibernating
+   * one. Surfaces an explicit "Resume" (or "Wake Up" for `hibernating`)
+   * button in the actions cell and makes the row body clickable for any
+   * status this prop covers. Preferred over `onWake` for new code — the
+   * two are kept as separate props only so existing consumers that
+   * wired up `onWake` for hibernating continue to work.
+   */
+  onResume?: (id: string) => void;
+  /**
+   * @deprecated Use `onResume` instead. Retained for back-compat:
+   * when `onResume` is not provided but `onWake` is, hibernating rows
+   * will still surface a Wake action. New consumers should pass
+   * `onResume` so stopped / failed / archived rows also get a start
+   * affordance.
+   */
+  onWake?: (id: string) => void;
+  onMore?: (id: string) => void;
+  /** Fired on the user's first click; the caller owns the confirmation step. */
+  onDelete?: (id: string) => void;
+  onStop?: (id: string) => void;
+  onKeepAlive?: (id: string) => void;
+  onUsage?: (id: string) => void;
+  onHealth?: (id: string) => void;
+  onFork?: (id: string) => void;
+  className?: string;
+}
+declare function SandboxTable({ sandboxes, page, pageSize, total, onPageChange, onOpenIDE, onOpenTerminal, onSSH, onResume, onWake, onMore, onDelete, onStop, onKeepAlive, onUsage, onHealth, onFork, className }: SandboxTableProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/invoice-table.d.ts
+interface Invoice {
+  id: string;
+  date: string;
+  amount: number;
+  status: "paid" | "pending" | "failed";
+}
+interface InvoiceTableProps {
+  invoices: Invoice[];
+  onExportAll?: () => void;
+  onLoadMore?: () => void;
+  onViewInvoice?: (id: string) => void;
+  hasMore?: boolean;
+  className?: string;
+}
+declare function InvoiceTable({ invoices, onExportAll, onLoadMore, onViewInvoice, hasMore, className }: InvoiceTableProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/plan-cards.d.ts
+interface PlanFeature {
+  text: string;
+}
+interface PlanCardData {
+  id: string;
+  name: string;
+  price: number;
+  period?: string;
+  features: PlanFeature[];
+  popular?: boolean;
+  current?: boolean;
+  ctaLabel?: string;
+  onSelect?: (id: string) => void;
+}
+interface PlanCardsProps {
+  plans: PlanCardData[];
+  className?: string;
+}
+declare function PlanCards({ plans, className }: PlanCardsProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/backend-selector.d.ts
+interface Backend {
+  type: string;
+  label: string;
+  description?: string;
+  /** Optional leading brand glyph (e.g. a HarnessLogo) shown in the trigger and rows. */
+  icon?: ReactNode;
+}
+type BackendSelectorVariant = "field" | "pill";
+interface BackendSelectorProps {
+  backends: Backend[];
+  selected: string;
+  onChange: (selected: string) => void;
+  /**
+   * Trigger appearance. "pill" (default) = compact inline pill — logo + short
+   * label only. "field" = full-width form field with a label above. Either
+   * way the long descriptor lives only as subtext inside the open dropdown,
+   * never on the closed trigger.
+   */
+  variant?: BackendSelectorVariant;
+  label?: string;
+  placeholder?: string;
+  className?: string;
+  /** Extra classes merged onto the trigger itself (after the built-in defaults). */
+  triggerClassName?: string;
+}
+declare function BackendSelector({ backends, selected, onChange, variant, label, placeholder, className, triggerClassName }: BackendSelectorProps): import("react").JSX.Element;
+//#endregion
+//#region src/dashboard/harness-picker.d.ts
+interface HarnessOption extends Backend {
+  type: HarnessType$1;
+  /**
+   * Whether this harness can drive an interactive chat session. `false` for
+   * shell-only backends (`cli-base`) that have no conversational agent — the
+   * chat composer filters these out (see {@link chatCapableHarnesses}) while
+   * scheduled/non-chat surfaces keep them.
+   */
+  chatCapable: boolean;
+}
+/**
+ * Default option list with human-readable copy. Order is curated so the
+ * recommended choice (`opencode`) appears first; `cli-base` (no agent) last.
+ *
+ * Descriptions name what the AGENT is, in one short line that fits the menu row
+ * without wrapping. They deliberately do NOT mention credentials: which keys a
+ * deployment supplies is a product decision, not a property of the harness, and
+ * an env-var name (`ANTHROPIC_API_KEY`) is developer text that has no place in a
+ * customer-facing menu. A product whose deployment really does require a
+ * user-supplied key says so through `optionsOverride`.
+ */
+declare const HARNESS_OPTIONS: readonly HarnessOption[];
+/** Harness types that can drive an interactive chat session. */
+declare const chatCapableHarnesses: ReadonlyArray<HarnessType$1>;
+interface HarnessPickerProps extends Omit<BackendSelectorProps, "backends" | "selected" | "onChange"> {
+  value: HarnessType$1;
+  onChange: (next: HarnessType$1) => void;
+  /** Filter the available harnesses (e.g. by plan tier). Defaults to all. */
+  available?: ReadonlyArray<HarnessType$1>;
+  /** Override or extend the option metadata. Keys are HarnessType. */
+  optionsOverride?: Partial<Record<HarnessType$1, Partial<Omit<HarnessOption, "type">>>>;
+}
+/**
+ * Type-safe harness/backend selector for sandbox-backed agent products.
+ *
+ * Wraps the generic {@link BackendSelector} with the canonical harness list
+ * baked in, so consumers don't have to re-declare it (or risk drifting from
+ * the SDK enum).
+ */
+declare function HarnessPicker({ value, onChange, available, optionsOverride, label, ...rest }: HarnessPickerProps): import("react").JSX.Element;
+//#endregion
+//#region src/dashboard/harness-logo.d.ts
+/**
+ * Per-harness brand glyph. `logoUrl` is a bundled lobehub data-url rendered
+ * as a CSS mask filled with the foreground token (single-color brand mark,
+ * theme-safe). `icon` is an honest lucide fallback for harnesses that have
+ * no published brand mark — never an invented logo.
+ */
+interface HarnessBrand {
+  label: string;
+  logoUrl?: string;
+  icon?: React$1.ComponentType<{
+    className?: string;
+  }>;
+}
+declare const HARNESS_BRAND: Partial<Record<HarnessType$1, HarnessBrand>>;
+interface HarnessLogoProps {
+  type: HarnessType$1;
+  /** Chip edge length in px. Default 16 (matches the model pill glyph). */
+  size?: number;
+  className?: string;
+}
+/**
+ * Brand chip for a harness, matching `BrandLogo`'s render contract in
+ * `lib/model-brand`: a rounded `bg-background ring-1 ring-border` chip wrapping
+ * either a foreground-filled CSS-mask of the brand SVG or a lucide fallback
+ * glyph. Keeps harness pills visually consistent with model pills.
+ */
+declare function HarnessLogo({ type, size, className }: HarnessLogoProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/dashboard-layout.d.ts
+type ProductVariant = "sandbox";
+interface NavItem {
+  id: string;
+  label: string;
+  href?: string;
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  badge?: number;
+}
+interface DashboardUser {
+  email: string;
+  name?: string;
+  tier?: string;
+  avatarUrl?: string;
+}
+interface TopNavLink {
+  label: string;
+  href: string;
+}
+interface PanelConfig {
+  mode: string;
+  title: string;
+  content: React$1.ReactNode;
+}
+interface DashboardLayoutProps {
+  children: React$1.ReactNode;
+  variant?: ProductVariant;
+  /** Navigation items for the rail */
+  navItems: NavItem[];
+  /** Nav item IDs that act as panel mode switchers (others are direct links) */
+  modeItems?: string[];
+  /** Panel content per mode */
+  panels?: PanelConfig[];
+  activeNavId?: string;
+  user?: DashboardUser | null;
+  isLoading?: boolean;
+  onLogout?: () => void;
+  onSettingsClick?: () => void;
+  settingsHref?: string;
+  onNewSandbox?: () => void;
+  className?: string;
+  sidebarClassName?: string;
+  contentClassName?: string;
+  topNavLinks?: TopNavLink[];
+  activeTopNavHref?: string;
+  /** Arbitrary content rendered at the leading (left) edge of the top bar —
+   * e.g. a workspace/team switcher — so consumers don't need a second bar. */
+  topBarLeading?: React$1.ReactNode;
+  LinkComponent?: React$1.ComponentType<any>;
+  /**
+   * Where the in-app logo links. Defaults to "/" (backward compatible);
+   * pass an in-app path (e.g. "/dashboard") so the logo never bounces an
+   * authenticated user back out to the public marketing homepage.
+   */
+  logoHref?: string;
+  /**
+   * @deprecated No longer wired. The redesigned {@link RailHeader} renders the
+   * brand mark plus a dedicated panel-toggle button; the logo is no longer the
+   * collapse control. Kept for back-compat; has no effect.
+   */
+  onLogoClick?: () => void;
+  /**
+   * @deprecated No longer wired (see {@link onLogoClick}). Has no effect.
+   */
+  logoAriaLabel?: string;
+  /**
+   * Let the icon rail expand to a labeled rail. When true, the rail logo
+   * toggles between icon-only and labeled instead of navigating.
+   */
+  labeledRail?: boolean;
+  /**
+   * Initial rail-collapsed state when `labeledRail` is set and the rail is
+   * uncontrolled. Defaults to expanded (`false`). Pass `true` to start on the
+   * compact icon rail — the user's choice then persists to localStorage.
+   */
+  defaultRailCollapsed?: boolean;
+  footer?: React$1.ReactNode;
+  defaultPanelOpen?: boolean;
+  defaultMode?: string;
+  /** Extra content in the rail footer (above profile avatar) */
+  railFooter?: React$1.ReactNode;
+  /** Extra dropdown items in the profile menu */
+  profileMenuItems?: React$1.ReactNode;
+  /**
+   * When provided, the profile menu shows an Appearance section
+   * (Light/Dark/System) driven by this host-supplied controller. Replaces the
+   * old standalone rail theme toggle.
+   */
+  appearance?: AppearanceController;
+  /** Notification data for the bell dropdown */
+  notifications?: {
+    items: {
+      id: string;
+      title: string;
+      message: string;
+      read: boolean;
+      createdAt: string;
+    }[];
+    unreadCount: number;
+    onMarkRead?: (id: string) => void;
+    onMarkAllRead?: () => void;
+  };
+}
+declare function DashboardLayout({ defaultPanelOpen, defaultMode, labeledRail, defaultRailCollapsed, ...props }: DashboardLayoutProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/sidebar-layout.d.ts
+/** A sub-destination revealed inside a nav item's right-flyout. */
+interface SidebarLayoutFlyoutItem {
+  id: string;
+  label: string;
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  href: string;
+  prefetch?: "none" | "intent" | "render" | "viewport";
+}
+interface SidebarLayoutNavItem {
+  id: string;
+  label: string;
+  icon: React$1.ComponentType<{
+    className?: string;
+  }>;
+  /** Destination for link items. Omit when `togglesPanel` or `flyoutItems` is set. */
+  href?: string;
+  /** Render this item as the panel toggle instead of a link. */
+  togglesPanel?: boolean;
+  /**
+   * Render this item as a right-flyout "door" fronting these sub-destinations
+   * instead of a link. The flyout opens to the right of the rail item. Takes
+   * precedence over `href`/`togglesPanel`.
+   */
+  flyoutItems?: SidebarLayoutFlyoutItem[];
+  /** Ids of `flyoutItems` whose route is currently active (drives the door highlight). */
+  flyoutActiveIds?: string[];
+  /**
+   * Give the item an emphasized "primary" pill so it stands out (e.g. a "New"
+   * action). Ignored for `togglesPanel`/`flyoutItems`/`expandable` items.
+   */
+  variant?: "normal" | "primary";
+  /**
+   * Render as an expandable item: an inline accordion on the labeled rail, a
+   * hover flyout on the icon-only rail. `href` (if set) navigates; the
+   * disclosure reveals `subItems` (fixed) or `loadSubItems()` (lazy). Takes
+   * precedence over `href`/`togglesPanel`/`flyoutItems`.
+   */
+  expandable?: boolean;
+  /** Fixed sub-items for an `expandable` item (icon optional). */
+  subItems?: RailExpandableSubItem[];
+  /** Lazy sub-items for an `expandable` item — loaded once on first open. */
+  loadSubItems?: () => Promise<RailExpandableSubItem[]>;
+  /** Ids of an `expandable` item's sub-items whose route is active. */
+  subActiveIds?: string[];
+  /** Empty-state text for an `expandable` item that resolves to no sub-items. */
+  emptyLabel?: string;
+  /** Start an `expandable` item expanded on mount (labeled rail). */
+  defaultOpen?: boolean;
+  badge?: number;
+  /**
+   * React Router prefetch behavior for this link, forwarded to the underlying
+   * `<Link prefetch>`. Omit to preserve the router's default (no prefetch).
+   * Ignored for panel-toggle items and for `LinkComponent`s that don't support it.
+   */
+  prefetch?: "none" | "intent" | "render" | "viewport";
+}
+interface SidebarLayoutProps {
+  children: React$1.ReactNode;
+  /** Rail navigation, in display order. Each item is a link or the panel toggle. */
+  navItems: SidebarLayoutNavItem[];
+  /** Id of the active link item (drives the highlighted state). */
+  activeId?: string;
+  /** Content rendered inside the slide-out panel (e.g. a SessionSidebar). */
+  panel?: React$1.ReactNode;
+  /** Logo element rendered in the rail header. */
+  logo?: React$1.ReactNode;
+  /** Destination for the logo link. */
+  logoHref?: string;
+  /**
+   * Content rendered in the rail header in place of the logo link — e.g. a
+   * project/workspace switcher. Spans the header so the app's primary
+   * orientation control sits at the top of the rail. When set, `logo`/`logoHref`
+   * are ignored. The header keeps its `h-14` height for cross-view alignment.
+   */
+  railHeaderContent?: React$1.ReactNode;
+  user?: SidebarUser | null;
+  isLoading?: boolean;
+  onLogout?: () => void;
+  onSettingsClick?: () => void;
+  settingsHref?: string;
+  /** Extra items rendered before settings/logout in the profile menu. */
+  profileMenuItems?: React$1.ReactNode;
+  /**
+   * When provided, the profile menu shows an Appearance section
+   * (Light/Dark/System) driven by this host-supplied controller. The host wires
+   * it to its own theme engine. Replaces the old standalone rail theme toggle.
+   */
+  appearance?: AppearanceController;
+  /**
+   * @deprecated No-op. The standalone rail theme toggle was replaced by the
+   * account-menu `appearance` control. Accepted (and ignored) for backward
+   * compatibility; will be removed in a future major.
+   */
+  showThemeToggle?: boolean;
+  /**
+   * @deprecated No-op. The collapse/expand control now always lives in the
+   * header (`RailHeader`). Accepted (and ignored) for backward compatibility;
+   * will be removed in a future major.
+   */
+  railCollapseToggle?: "header" | "footer";
+  /** Extra content in the rail footer, above the profile avatar. */
+  railFooter?: React$1.ReactNode;
+  LinkComponent?: React$1.ComponentType<any>;
+  /**
+   * Controlled panel-open state. Provide it (seeded from a server-readable
+   * source such as a cookie) in SSR apps so the panel survives reload without a
+   * hydration mismatch. Omit to let the panel persist to localStorage.
+   */
+  panelOpen?: boolean;
+  onPanelOpenChange?: (open: boolean) => void;
+  defaultPanelOpen?: boolean;
+  /** Hide the whole sidebar below this breakpoint (content spans full width). */
+  hideBelow?: "md" | "lg";
+  /**
+   * Make the rail label-capable: it renders labels beside the icons on a wider
+   * rail and gains a collapse/expand control that toggles between the labeled
+   * width and the icon-only rail (icons + hover tooltips). When omitted the rail
+   * is permanently icon-only with no collapse control.
+   */
+  railLabels?: boolean;
+  /**
+   * Controlled rail-collapsed state. Provide it (seeded from a server-readable
+   * source such as a cookie) in SSR apps so the collapsed/expanded rail survives
+   * reload without a hydration mismatch. Omit to let the rail persist to
+   * localStorage. Independent of `panelOpen` — the nav rail and the slide-out
+   * panel collapse separately. Only meaningful with `railLabels`.
+   */
+  railCollapsed?: boolean;
+  onRailCollapsedChange?: (collapsed: boolean) => void;
+  /** Initial rail-collapsed state when uncontrolled (default: expanded). */
+  defaultRailCollapsed?: boolean;
+  /**
+   * Close the panel when a link nav item is clicked. Useful when the panel is
+   * contextual to one section (e.g. a chat thread list) rather than a global
+   * dock. Selecting items inside the panel itself does not trigger this.
+   */
+  closePanelOnNavigate?: boolean;
+  className?: string;
+  sidebarClassName?: string;
+  /** Class for the `<main>` content region (e.g. `flex h-screen ... overflow-hidden`). */
+  contentClassName?: string;
+}
+/**
+ * App shell built on the sidebar rail + slide-out panel, without a top nav bar.
+ * Apps supply nav items, an optional panel, and profile/branding props; the
+ * standard look, panel docking, content-margin coordination, and responsive
+ * hide all live here. Pair `panelOpen`/`onPanelOpenChange` with a cookie for
+ * SSR-safe persistence.
+ */
+declare function SidebarLayout({ panelOpen, onPanelOpenChange, defaultPanelOpen, railCollapsed, onRailCollapsedChange, defaultRailCollapsed, ...props }: SidebarLayoutProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/profile-selector.d.ts
+interface Profile {
+  id: string;
+  name: string;
+  description?: string;
+  is_builtin?: boolean;
+  extends?: string;
+  model?: string;
+  metrics?: {
+    total_runs: number;
+    success_rate: number;
+    avg_duration_ms: number;
+  };
+}
+interface ProfileSelectorProps {
+  profiles: Profile[];
+  selectedId?: string | null;
+  onSelect: (profile: Profile | null) => void;
+  onCreateClick?: () => void;
+  onManageClick?: () => void;
+  label?: string;
+  placeholder?: string;
+  showMetrics?: boolean;
+  className?: string;
+}
+declare function ProfileSelector({ profiles, selectedId, onSelect, onCreateClick, onManageClick, label, placeholder, showMetrics, className }: ProfileSelectorProps): import("react").JSX.Element;
+/**
+ * Profile performance comparison card.
+ * Shows metrics from multiple profiles side by side.
+ */
+interface ProfileComparisonProps {
+  profiles: Profile[];
+  className?: string;
+}
+declare function ProfileComparison({ profiles, className }: ProfileComparisonProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/dashboard/metric-area-chart.d.ts
+interface MetricChartPoint {
+  /** Wall-clock ms. */
+  at: number;
+  /** Null renders a gap in the series, never a zero. */
+  value: number | null;
+}
+type MetricChartTone = "primary" | "success" | "warning" | "danger";
+interface MetricAreaChartProps {
+  points: MetricChartPoint[];
+  label: string;
+  /** Formats the current value and y-axis bounds (e.g. percent, bytes). */
+  formatValue: (value: number) => string;
+  /**
+   * Fixed y-axis maximum (100 for percents, memory total for bytes).
+   * Omitted = auto-scale to the observed maximum with 10% headroom.
+   */
+  maxValue?: number;
+  /** Secondary line under the current value (e.g. "of 8 GiB"). */
+  detail?: React$1.ReactNode;
+  tone?: MetricChartTone;
+  /** Plot height in px. Defaults to 96. */
+  height?: number;
+  /** Shown instead of the plot while no point has a value yet. */
+  emptyState?: React$1.ReactNode;
+  className?: string;
+}
+/**
+ * Lightweight live time-series panel (Prometheus/Grafana idiom): big
+ * current value, area chart of the rolling window, dashed gridlines.
+ * Pure SVG — no chart dependency. Null samples render as gaps.
+ */
+declare function MetricAreaChart({ points, label, formatValue, maxValue, detail, tone, height, emptyState, className }: MetricAreaChartProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/variant-list.d.ts
+type VariantStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+type VariantOutcome = "pending_review" | "accepted" | "rejected" | "merged_with_conflicts" | "expired";
+interface Variant {
+  id: string;
+  label: string;
+  sublabel?: string;
+  status: VariantStatus;
+  outcome?: VariantOutcome;
+  durationMs?: number;
+  error?: string;
+  summary?: string;
+  /** Link to view variant details (e.g., chat UI) */
+  detailsUrl?: string;
+}
+interface VariantListProps {
+  variants: Variant[];
+  selectedId?: string | null;
+  onSelect?: (id: string) => void;
+  onAccept?: (id: string) => void;
+  onReject?: (id: string) => void;
+  isActioning?: string | null;
+  className?: string;
+}
+declare function VariantList({ variants, selectedId, onSelect, onAccept, onReject, isActioning, className }: VariantListProps): import("react").JSX.Element;
+//#endregion
+//#region src/dashboard/system-logs.d.ts
+interface SystemLogsViewerProps {
+  apiUrl: string;
+  token: string;
+  className?: string;
+}
+declare function SystemLogsViewer({ apiUrl, token, className }: SystemLogsViewerProps): React.JSX.Element;
+//#endregion
+//#region src/dashboard/usage-summary.d.ts
+interface UsageSummaryData {
+  computeHours: number;
+  activeSessions: number;
+  messagesSent: number;
+  estimatedCost: number;
+}
+interface UsageSummaryProps {
+  data: UsageSummaryData | null;
+  loading?: boolean;
+  className?: string;
+}
+declare function UsageSummary({ data, loading, className }: UsageSummaryProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/git-panel.d.ts
+interface GitStatusData {
+  branch: string;
+  isDirty: boolean;
+  ahead: number;
+  behind: number;
+  staged: string[];
+  modified: string[];
+  untracked: string[];
+}
+interface GitCommitData {
+  shortSha: string;
+  message: string;
+  author: string;
+  date: string;
+}
+interface GitPanelProps {
+  status: GitStatusData | null;
+  log: GitCommitData[];
+  loading?: boolean;
+  onRefresh?: () => void;
+  className?: string;
+}
+declare function GitPanel({ status, log, loading, onRefresh, className }: GitPanelProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/ports-list.d.ts
+interface ExposedPort {
+  port: number;
+  url: string;
+  status: "active" | "pending";
+}
+interface PortsListProps {
+  ports: ExposedPort[];
+  onExposePort: (port: number) => void;
+  onRemovePort?: (port: number) => void;
+  isExposing?: boolean;
+  className?: string;
+}
+declare function PortsList({ ports, onExposePort, onRemovePort, isExposing, className }: PortsListProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/process-list.d.ts
+interface ProcessInfo {
+  pid: number;
+  command: string;
+  running: boolean;
+  exitCode?: number;
+  startedAt?: string;
+  cwd?: string;
+}
+interface ProcessListProps {
+  processes: ProcessInfo[];
+  onSpawn: (command: string) => void;
+  onKill: (pid: number) => void;
+  loading?: boolean;
+  className?: string;
+}
+declare function ProcessList({ processes, onSpawn, onKill, loading, className }: ProcessListProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/network-config.d.ts
+interface NetworkConfigData {
+  blockOutbound: boolean;
+  allowList: string[];
+}
+interface NetworkConfigProps {
+  config: NetworkConfigData | null;
+  onUpdate: (config: Partial<NetworkConfigData>) => void;
+  loading?: boolean;
+  className?: string;
+}
+declare function NetworkConfig({ config, onUpdate, loading, className }: NetworkConfigProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/backend-config.d.ts
+interface BackendStatusData {
+  running: boolean;
+  model?: string;
+  provider?: string;
+  uptime?: number;
+}
+interface McpServer {
+  name: string;
+  command: string;
+  args?: string[];
+  status?: "running" | "stopped" | "error";
+}
+interface BackendConfigProps {
+  status: BackendStatusData | null;
+  mcpServers: McpServer[];
+  onAddMcp: (server: {
+    name: string;
+    command: string;
+    args?: string[];
+  }) => void;
+  onRemoveMcp: (name: string) => void;
+  /** Render a restart action only when the host has a real restart operation. */
+  onRestart?: () => void;
+  loading?: boolean;
+  className?: string;
+}
+declare function BackendConfig({ status, mcpServers, onAddMcp, onRemoveMcp, onRestart, loading, className }: BackendConfigProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/snapshot-list.d.ts
+interface SnapshotInfo {
+  id: string;
+  createdAt: string;
+  sizeBytes?: number;
+  tags?: string[];
+}
+interface SnapshotListProps {
+  snapshots: SnapshotInfo[];
+  onCreate: (tags?: string[]) => void;
+  onRestore: (snapshotId: string) => void;
+  onSaveAsTemplate?: (snapshotId: string) => void;
+  loading?: boolean;
+  className?: string;
+}
+declare function SnapshotList({ snapshots, onCreate, onRestore, onSaveAsTemplate, loading, className }: SnapshotListProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/promo-banner.d.ts
+interface PromoBannerProps {
+  title: string;
+  description: string;
+  buttonLabel: string;
+  href?: string;
+  onClick?: () => void;
+  icon?: React$1.ReactNode;
+  disabled?: boolean;
+  className?: string;
+}
+declare function PromoBanner({ title, description, buttonLabel, href, onClick, icon, disabled, className }: PromoBannerProps): React$1.JSX.Element;
+//#endregion
+//#region src/dashboard/info-panel.d.ts
+interface InfoPanelProps {
+  label: string;
+  title: string;
+  description: string;
+  className?: string;
+}
+declare function InfoPanel({ label, title, description, className }: InfoPanelProps): React$1.JSX.Element;
+//#endregion
+export { HARNESS_BRAND as $, useSidebar as $t, Variant as A, SidebarProps as An, ActivityItem as At, ProfileComparison as B, ThemeMode as Bn, InsufficientBalance as Bt, GitPanelProps as C, SidebarContentProps as Cn, SandboxCardData as Ct, UsageSummaryProps as D, SidebarPanelHeader as Dn, canAdminSandbox as Dt, UsageSummaryData as E, SidebarPanelContentProps as En, TeamRole as Et, MetricAreaChart as F, SidebarRailHeaderProps as Fn, ResourceMeterProps as Ft, SidebarLayoutFlyoutItem as G, CreditBalanceProps as Gt, ProfileSelector as H, OutOfCreditsModalProps as Ht, MetricAreaChartProps as I, SidebarRailNav as In, ClusterStatusBar as It, DashboardLayout as J, SIDEBAR_RAIL_LABELED_WIDTH as Jt, SidebarLayoutNavItem as K, SIDEBAR_MOBILE_WIDTH as Kt, MetricChartPoint as L, SidebarRailNavProps as Ln, ClusterStatusBarProps as Lt, VariantListProps as M, SidebarRailFooter as Mn, ResourceSnapshotItem as Mt, VariantOutcome as N, SidebarRailFooterProps as Nn, ResourceSnapshotProps as Nt, SystemLogsViewer as O, SidebarPanelHeaderProps as On, ActivityFeed as Ot, VariantStatus as P, SidebarRailHeader as Pn, ResourceMeter as Pt, ProductVariant as Q, SidebarProviderProps as Qt, MetricChartTone as R, SidebarRailProps as Rn, ClusterStatusItem as Rt, GitPanel as S, SidebarContent as Sn, SandboxCard as St, UsageSummary as T, SidebarPanelContent as Tn, SandboxStatus as Tt, ProfileSelectorProps as U, parseInsufficientBalance as Ut, ProfileComparisonProps as V, OutOfCreditsModal as Vt, SidebarLayout as W, CreditBalance as Wt, DashboardUser as X, SIDEBAR_TOTAL_WIDTH as Xt, DashboardLayoutProps as Y, SIDEBAR_RAIL_WIDTH as Yt, NavItem as Z, SidebarProvider as Zt, ProcessListProps as _, RailModeButtonProps as _n, InvoiceTableProps as _t, SnapshotInfo as a, RailButton as an, HarnessPickerProps as at, PortsListProps as b, RailThemeToggle as bn, NewSandboxCard as bt, BackendConfig as c, RailCollapseToggleProps as cn, Backend as ct, McpServer as d, RailExpandableSubItem as dn, PlanCardData as dt, RailTooltip as en, HarnessBrand as et, NetworkConfig as f, RailFlyout as fn, PlanCards as ft, ProcessList as g, RailModeButton as gn, InvoiceTable as gt, ProcessInfo as h, RailHeaderProps as hn, Invoice as ht, PromoBannerProps as i, ProfileAvatarProps as in, HarnessPicker as it, VariantList as j, SidebarRail as jn, ResourceSnapshot as jt, SystemLogsViewerProps as k, SidebarPanelProps as kn, ActivityFeedProps as kt, BackendConfigProps as l, RailExpandable as ln, BackendSelector as lt, NetworkConfigProps as m, RailHeader as mn, PlanFeature as mt, InfoPanelProps as n, AppearanceController as nn, HarnessLogoProps as nt, SnapshotList as o, RailButtonProps as on, HarnessType$1 as ot, NetworkConfigData as p, RailFlyoutProps as pn, PlanCardsProps as pt, SidebarLayoutProps as q, SIDEBAR_PANEL_WIDTH as qt, PromoBanner as r, ProfileAvatar as rn, HARNESS_OPTIONS as rt, SnapshotListProps as s, RailCollapseToggle as sn, chatCapableHarnesses as st, InfoPanel as t, RailTooltipProps as tn, HarnessLogo as tt, BackendStatusData as u, RailExpandableProps as un, BackendSelectorProps as ut, ExposedPort as v, RailSeparator as vn, SandboxTable as vt, GitStatusData as w, SidebarPanel as wn, SandboxCardProps as wt, GitCommitData as x, Sidebar as xn, NewSandboxCardProps as xt, PortsList as y, RailSeparatorProps as yn, SandboxTableProps as yt, Profile as z, SidebarUser as zn, INSUFFICIENT_BALANCE_CODE as zt };