@opengeni/react 0.29.0 → 0.33.1

package/dist/components/copy-button.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+export type CopyButtonProps = {
+    /** Plain text to copy, or a lazy getter (tables / late DOM). */
+    text: string | (() => string);
+    /** Accessible name + tooltip while idle. */
+    label?: string | undefined;
+    className?: string | undefined;
+    /**
+     * `always` — visible control.
+     * `group-hover` — parent must use `group/copy`; fades in on hover/focus.
+     */
+    reveal?: "always" | "group-hover" | undefined;
+};
+/**
+ * Ghost icon copy control — no chrome box, no "Copy code" label.
+ * Copy → check flash. Hover-reveal via `group/copy` on a parent.
+ */
+export declare function CopyButton({ text, label, className, reveal, }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;
+/** Hover-reveal chrome around a message / turn so {@link CopyButton} can fade in. */
+export declare function CopyHoverFrame({ children, className, copyText, label, align, }: {
+    children: ReactNode;
+    className?: string | undefined;
+    copyText: string;
+    label: string;
+    align?: "start" | "end" | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/desktop-viewer.d.ts

@@ -0,0 +1,85 @@
+import type { CapabilityUnavailableReason, DesktopRfbFactory, DesktopStreamCapability } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+import type { DesktopWebSocketFactory } from "../hooks/use-relay-frame-stream";
+export type DesktopViewerProps = {
+    /** The desktop cell of the negotiated capabilities (`capabilities.DesktopStream`). */
+    capability: DesktopStreamCapability | null;
+    /**
+     * Initial control mode. Default false (watch). When the user flips
+     * "Take control" the viewer drives input — but only if `capability.mode`
+     * permits it (server-gated; a read-only deployment disables the toggle).
+     * Pass a value to control it externally; omit to let the viewer own the state.
+     */
+    interactive?: boolean | undefined;
+    /** Render the built-in Watching ⇄ Take control toggle (default true). */
+    showControlToggle?: boolean | undefined;
+    scaleViewport?: boolean | undefined;
+    /** Custom RFB factory (tests / a WebRTC swap). Defaults to lazy @novnc/novnc. */
+    rfbFactory?: DesktopRfbFactory | undefined;
+    /** Custom socket factory for the self-hosted `relay-frames` transport (tests).
+     *  Defaults to `new WebSocket(url)`. Mirrors `rfbFactory`. */
+    webSocketFactory?: DesktopWebSocketFactory | undefined;
+    /**
+     * Consent gate for the un-redacted (and possibly shared) pixel plane. Rendered
+     * BEFORE connecting whenever the desktop requires acknowledgment that hasn't
+     * been given. Call `onAccept` to record consent (the host wires it to
+     * `client.acknowledgeStream` + a re-negotiate). When omitted, a default
+     * banner is shown.
+     */
+    renderConsentGate?: ((onAccept: () => void, shared: boolean) => ReactNode) | undefined;
+    /** Called when the default consent gate's accept button is pressed. */
+    onAcknowledge?: (() => void) | undefined;
+    /**
+     * Whether the host has the viewer attach engaged (i.e. the user has opted into
+     * watching — the parent's `watchDesktop`/`attachDesktop`). Drives the
+     * cold-state behaviour: when watching, a cold-but-warmable lease AUTO-WARMS
+     * (and re-warms when the box drains) instead of dead-ending. When omitted we
+     * infer it from a recorded consent (the default gate's accept), so the
+     * component still self-heals after the first acknowledgment.
+     */
+    watching?: boolean | undefined;
+    /**
+     * Request a (re)warm of the sandbox WITHOUT re-acknowledging (the consent has
+     * already been recorded — only the box drained). The host wires this to
+     * "engage the viewer attach + re-negotiate". Called automatically when a
+     * watched desktop is found cold-but-warmable, and behind the manual retry on
+     * the warming notice. Distinct from `onAcknowledge`, which is the FIRST,
+     * consent-bearing warm.
+     */
+    onWarm?: (() => void) | undefined;
+    /** Shown when transport is null (headless backend / degraded / disabled). */
+    renderUnavailable?: ((reason: CapabilityUnavailableReason | null) => ReactNode) | undefined;
+    /** Shown while the box is cold/warming (no live address yet). */
+    renderWarming?: (() => ReactNode) | undefined;
+    /** Shown when the per-session viewer cap (429) was hit. */
+    renderViewerCap?: (() => ReactNode) | undefined;
+    /** Surface the 429 cap state from `useSessionCapabilities().viewerCapReached`. */
+    viewerCapReached?: boolean | undefined;
+    /**
+     * Connect watchdog (ms): if a live url is present but the RFB hasn't connected
+     * within this window, surface a "Couldn't connect" + Reconnect instead of an
+     * eternal idle scrim. Default 13000. 0 disables the watchdog.
+     */
+    connectTimeoutMs?: number | undefined;
+    className?: string | undefined;
+};
+/**
+ * The desktop surface: a noVNC client connecting to the Channel-B scoped tunnel
+ * URL from the capability doc. Owns the mount `<div ref>`, drives
+ * `useDesktopStream` (SSR-safe lazy RFB), and renders a real
+ * cold → warming → connecting → connected → error state machine with live
+ * feedback (spinners, transitions) — never a dead black box with stale text.
+ *
+ * The read-only vs interactive decision is enforced server-first
+ * (`capability.mode`): when the deployment advertises mode "interactive" the
+ * viewer can TAKE CONTROL and drive the mouse & keyboard into the box's :0; a
+ * "read-only" deployment disables the take-control affordance (graceful, with a
+ * reason).
+ *
+ * Warming: a cold-but-warmable lease (`reason: "lease_cold"`) is NOT a dead end.
+ * When the user is watching (consented), the viewer asks the host to (re)warm
+ * the box (`onWarm`) and shows a "Warming…" spinner; if the box later drains to
+ * cold it re-warms. Genuinely-unavailable surfaces (headless/policy/os/backend)
+ * keep a clear, static unavailable notice.
+ */
+export declare function DesktopViewer({ capability, interactive, showControlToggle, scaleViewport, rfbFactory, webSocketFactory, renderConsentGate, onAcknowledge, watching, onWarm, renderUnavailable, renderWarming, renderViewerCap, viewerCapReached, connectTimeoutMs, className, }: DesktopViewerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/diff-view.d.ts

@@ -0,0 +1,38 @@
+import type { GitFileDiff } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+/**
+ * @deprecated Use {@link PierreDiff} directly. Retained only as a thin,
+ * back-compat alias that renders the Pierre (Shiki) renderer with a plain-text
+ * degrade. The old hand-rolled hunk renderer was removed in Workbench v2 — the
+ * workbench keeps exactly ONE diff renderer. This alias is removed next major.
+ */
+export type DiffTheme = {
+    addBackground?: string;
+    delBackground?: string;
+    contextBackground?: string;
+    metaForeground?: string;
+};
+/**
+ * @deprecated Use {@link PierreDiff}. `theme`/`onSelectFile`/`emptyState` from the
+ * removed hand-rolled renderer are accepted for source compatibility and ignored;
+ * `fallback` still overrides the plain-text degrade.
+ */
+export type DiffViewProps = {
+    diff: GitFileDiff[];
+    fallback?: ReactNode | undefined;
+    layout?: "unified" | "split" | undefined;
+    themeType?: "dark" | "light" | undefined;
+    /** @deprecated line-background theming was part of the removed renderer. */
+    theme?: DiffTheme | undefined;
+    /** @deprecated the alias no longer renders a clickable file header. */
+    onSelectFile?: ((path: string) => void) | undefined;
+    isRepo?: boolean | undefined;
+    emptyState?: ReactNode | undefined;
+    className?: string | undefined;
+};
+/**
+ * @deprecated Use {@link PierreDiff} directly. Thin alias: renders `PierreDiff`
+ * (Shiki-highlighted, unified/split) with a plain-text fallback for a host
+ * without `@pierre/diffs`. Removed next major.
+ */
+export declare function DiffView({ diff, fallback, layout, themeType, isRepo, emptyState, className, }: DiffViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/enrollment-consent.d.ts

@@ -0,0 +1,33 @@
+/** The machine identity surfaced to the approver, from the device-flow start. */
+export type EnrollmentConsentMachine = {
+    /** Human-friendly name (hostname by default). */
+    machineName: string;
+    os: string;
+    arch: string;
+    /** The agent can offer a display (a real screen / Xvfb is available). */
+    canOfferDisplay: boolean;
+    /** The agent requests screen control (computer-use). */
+    requestsScreenControl: boolean;
+};
+/** The phase of the approve page (drives the rendered panel). */
+export type EnrollmentConsentPhase = "review" | "approving" | "approved" | "denied" | "error";
+export type EnrollmentConsentProps = {
+    /** The short code the user typed / scanned (echoed back for confirmation). */
+    userCode: string;
+    machine: EnrollmentConsentMachine;
+    phase?: EnrollmentConsentPhase | undefined;
+    /** Approve with the chosen screen-control consent. */
+    onApprove?: ((allowScreenControl: boolean) => void) | undefined;
+    onDeny?: (() => void) | undefined;
+    /** Error message when phase === "error". */
+    errorMessage?: string | undefined;
+    className?: string | undefined;
+};
+/**
+ * The user-facing APPROVE page for the device-flow enrollment: a LOUD,
+ * un-minimised whole-machine consent. Approving grants the agent FULL access to
+ * this machine — exec, files, terminal — and (when toggled) live screen control.
+ * The danger framing is deliberate (§18 hardening: whole-machine = loud consent),
+ * never buried. Renders review / approving / approved / denied / error phases.
+ */
+export declare function EnrollmentConsent({ userCode, machine, phase, onApprove, onDeny, errorMessage, className, }: EnrollmentConsentProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/enrollment-device-flow.d.ts

@@ -0,0 +1,27 @@
+/** The poll state of an in-flight device-flow enrollment. */
+export type DeviceFlowPhase = "pending" | "authorized" | "denied" | "expired" | "disabled";
+export type EnrollmentDeviceFlowProps = {
+    /** The short user code the agent printed (shown big for the human to confirm). */
+    userCode: string;
+    /** Where the user approves — the same-origin device page. */
+    verificationUri: string;
+    /** The complete URI (code pre-filled) for a one-click / QR open. */
+    verificationUriComplete?: string | undefined;
+    /** The install one-liner the user ran (echoed for context). Optional. */
+    installCommand?: string | undefined;
+    phase?: DeviceFlowPhase | undefined;
+    /** Seconds remaining before the code expires (drives a quiet countdown). */
+    expiresInSeconds?: number | undefined;
+    onCopyCode?: (() => void) | undefined;
+    onCopyInstall?: (() => void) | undefined;
+    onOpenVerification?: (() => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The IN-SESSION device-flow panel: the agent (after the install one-liner) prints
+ * a short `userCode` + a `verificationUri`; this surfaces them so the user can open
+ * the approve page and confirm the code. Polls in the caller; this renders the
+ * pending → authorized/denied/expired progression with a connection pill. This is
+ * the FIRST step of the IA flow (device-flow → Machines list → attach/swap).
+ */
+export declare function EnrollmentDeviceFlow({ userCode, verificationUri, verificationUriComplete, installCommand, phase, expiresInSeconds, onCopyCode, onCopyInstall, onOpenVerification, className, }: EnrollmentDeviceFlowProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/file-browser.d.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from "react";
+import type { FileTreeNode, UseSandboxFilesResult } from "../hooks/use-sandbox-files";
+export type FileBrowserProps = {
+    /** From `useSandboxFiles(...)`. */
+    result: UseSandboxFilesResult;
+    /**
+     * Rendered instead of the built-in tree when the file surface is unavailable
+     * (e.g. a `FileSystem.available === false` capability). Default: a quiet notice.
+     */
+    fallback?: ReactNode | undefined;
+    /** Selection callback for the preview pane. */
+    onSelectFile?: ((path: string) => void) | undefined;
+    selectedPath?: string | undefined;
+    /** Render-prop to theme/replace a row entirely (the Pierre-swap escape hatch). */
+    renderNode?: ((node: FileTreeNode, depth: number, expanded: boolean) => ReactNode) | undefined;
+    /** Shown when the tree is empty (no files / not loaded yet). */
+    emptyState?: ReactNode | undefined;
+    /**
+     * Enable the file-manager affordances (toolbar, context menu, drag-drop move,
+     * inline rename, delete, new file/folder). Defaults to `true` when the hook
+     * exposes the mutation methods; pass `false` for a strictly read-only tree.
+     */
+    editable?: boolean | undefined;
+    /**
+     * Confirm a (recursive) delete before it runs. Return `false` to cancel.
+     * The default is an accessible, non-blocking confirmation dialog. Supply this
+     * callback to delegate confirmation to a host-owned dialog.
+     */
+    confirmDelete?: ((node: FileTreeNode) => boolean | Promise<boolean>) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The file MANAGER, fed by the FileSystem service via `useSandboxFiles`. This is
+ * a first-class editable tree (not a render-only view): lazy-expand with a
+ * spinner on the in-flight node, git-status tinting, full keyboard navigation,
+ * selection, and the mutating affordances wired straight to the hook —
+ *
+ *   • drag-and-drop MOVE  → `moveEntry(from, to)`
+ *   • inline RENAME       → `moveEntry(path, newPath)`  (F2 / double-click / menu)
+ *   • DELETE              → `deleteEntry(path, recursive)`  (Del / menu, confirmed)
+ *   • NEW FILE / FOLDER   → `createFile` / `createDir` (toolbar + menu), then open
+ *   • right-click CONTEXT MENU
+ *
+ * `renderNode` is still honoured as the Pierre-swap escape hatch for the row
+ * chrome; the manager scaffolding (toolbar, dnd, menu, inline inputs) wraps it.
+ */
+export declare function FileBrowser({ result, fallback, onSelectFile, selectedPath, renderNode, emptyState, editable, confirmDelete, className, }: FileBrowserProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/fleet-tile.d.ts

@@ -0,0 +1,18 @@
+import type { Session } from "@opengeni/sdk";
+export type FleetTileProps = {
+    session: Session;
+    /** Overrides the derived title (metadata.title/name, else the initial message). */
+    title?: string | undefined;
+    /** Extra line under the title — e.g. "drift check" or the worker's task. */
+    subtitle?: string | undefined;
+    onOpen?: ((session: Session) => void) | undefined;
+    className?: string | undefined;
+};
+/** Best-effort display title for a session. */
+export declare function sessionDisplayTitle(session: Session): string;
+/**
+ * One session in the fleet/manager view: title, live status, model, and
+ * recency — dense but calm. Running sessions carry a breathing status dot
+ * and a faint accent edge so the live ones read at a glance.
+ */
+export declare function FleetTile({ session, title, subtitle, onOpen, className }: FleetTileProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/human-input-form.d.ts

@@ -0,0 +1,47 @@
+import type { HumanInputAnswer, HumanInputQuestion, SessionHumanInputRequest, SubmitHumanInputResponseRequest } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+export type HumanInputAnswerDraft = {
+    values: string[];
+    other: string;
+    otherSelected: boolean;
+};
+export type HumanInputFormMessages = {
+    title: string;
+    description: string;
+    submit: string;
+    skip: string;
+    submitting: string;
+    other: string;
+    deadlineLabel: string;
+    formatDeadline: (value: string) => string;
+    required: string;
+    minLength: (count: number) => string;
+    maxLength: (count: number) => string;
+    otherRequired: string;
+    minSelections: (count: number) => string;
+    maxSelections: (count: number) => string;
+};
+export declare const defaultHumanInputFormMessages: HumanInputFormMessages;
+export type HumanInputFormProps = {
+    request: Pick<SessionHumanInputRequest, "id" | "questions" | "allowSkip" | "expiresAt">;
+    onSubmit: (response: SubmitHumanInputResponseRequest) => void | Promise<void>;
+    submitting?: boolean | undefined;
+    error?: string | null | undefined;
+    title?: ReactNode;
+    description?: ReactNode;
+    submitLabel?: string | undefined;
+    skipLabel?: string | undefined;
+    messages?: Partial<HumanInputFormMessages> | undefined;
+    autoFocus?: boolean | undefined;
+    className?: string | undefined;
+};
+/**
+ * Styled but host-neutral renderer for one structured request. Hosts can use
+ * the headless `useHumanInputRequests` hook instead, or replace the title and
+ * description while retaining accessible field semantics and validation.
+ */
+export declare function HumanInputForm({ request, onSubmit, submitting, error, title, description, submitLabel, skipLabel, messages: messageOverrides, autoFocus, className, }: HumanInputFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function answersFromDrafts(questions: HumanInputQuestion[], drafts: Record<string, HumanInputAnswerDraft>, messageOverrides?: Partial<HumanInputFormMessages>): {
+    answers: HumanInputAnswer[];
+    errors: Record<string, string>;
+};

package/dist/components/machine-card.d.ts

@@ -0,0 +1,21 @@
+import type { MachineView, MetricSample } from "../types/machines";
+export type MachineCardProps = {
+    machine: MachineView;
+    /** Attach/swap the session's active sandbox to this machine. */
+    onAttach?: ((machine: MachineView) => void) | undefined;
+    /** Whether an attach/swap is currently in flight (disables the affordance). */
+    attaching?: boolean | undefined;
+    /** Short recent history (e.g. 15m) — drives the card's CPU trend + preview. */
+    series?: MetricSample[] | undefined;
+    /** Open the full per-machine telemetry detail. Makes the whole card actionable. */
+    onOpenDetail?: ((machine: MachineView) => void) | undefined;
+    now?: number | undefined;
+    className?: string | undefined;
+};
+/**
+ * One machine in the Machines dashboard: name + kind + OS/arch, the fused HEALTH
+ * verdict, latest resource meters, a CPU trend that previews the history, live
+ * freshness, and attach/swap. The whole card opens the telemetry detail when
+ * `onOpenDetail` is wired. The session's active sandbox carries an accent edge.
+ */
+export declare function MachineCard({ machine, onAttach, attaching, series, onOpenDetail, now, className, }: MachineCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machine-dock-bar.d.ts

@@ -0,0 +1,31 @@
+import type { MachineKind, MachineState } from "../types/machines";
+export type MachineDockBarProps = {
+    /** The active machine's display name. */
+    name: string;
+    kind: MachineKind;
+    state: MachineState;
+    /** Live sessions sharing this whole-machine lease (>1 ⇒ shared disclosure). */
+    sharedSessionCount?: number | undefined;
+    className?: string | undefined;
+};
+/**
+ * A slim bar that surfaces WHICH machine the dock surfaces (Files/Terminal/
+ * Desktop) are bound to + its connection status. Mounted above the dock tabs so
+ * the user always knows whether they are looking at the Modal box or their own
+ * machine, and whether it is online / reconnecting / offline. The surfaces below
+ * render IDENTICALLY regardless of backend — this bar is the only backend-aware
+ * chrome (the dock-parity contract: selfhosted == Modal for the surfaces).
+ */
+export declare function MachineDockBar({ name, kind, state, className }: MachineDockBarProps): import("react/jsx-runtime").JSX.Element;
+export type SharedMachineDisclosureProps = {
+    sharedSessionCount: number;
+    /** Compact (inline strip) vs full (a notice block). */
+    density?: "compact" | "full" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The "shared — another session is on this machine" disclosure. Surfaced in the
+ * dock (and reused on the desktop take-control gate) so the user knows others are
+ * driving the same whole-machine lease. Render when `sharedSessionCount > 1`.
+ */
+export declare function SharedMachineDisclosure({ sharedSessionCount, density, className, }: SharedMachineDisclosureProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machine-health-pill.d.ts

@@ -0,0 +1,9 @@
+import type { MachineState, MetricSample } from "../types/machines";
+export type MachineHealthPillProps = {
+    state: MachineState;
+    metrics: MetricSample | null;
+    now?: number | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+export declare function MachineHealthPill({ state, metrics, now, size, className, }: MachineHealthPillProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machine-metrics.d.ts

@@ -0,0 +1,15 @@
+import type { MetricSample } from "../types/machines";
+export type MachineMetricsProps = {
+    /** The latest metric sample, or null when the machine hasn't reported yet. */
+    metrics: MetricSample | null;
+    /** Compact (dashboard row) vs full (the dock detail). */
+    density?: "compact" | "full" | undefined;
+    className?: string | undefined;
+};
+/**
+ * Per-machine resource meters: CPU%, load average, memory, disk, and GPU when
+ * present. Renders the M2 `machine_metrics_latest` sample. When `metrics` is
+ * null the panel shows a quiet "no samples yet" placeholder (offline / just
+ * enrolled). GPU rows only render when `gpuUtilPct` is non-null.
+ */
+export declare function MachineMetrics({ metrics, density, className }: MachineMetricsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machine-status-pill.d.ts

@@ -0,0 +1,54 @@
+import { type ConnectionStatus, type MachineState } from "../types/machines";
+export type ConnectionStatusMeta = {
+    label: string;
+    dotClassName: string;
+    badgeClassName: string;
+    /** Live/transient states breathe; settled states hold still. */
+    pulse: boolean;
+};
+/** Token-backed meta for the three connection-status pill values. */
+export declare const CONNECTION_STATUS_META: Record<ConnectionStatus, ConnectionStatusMeta>;
+export type MachineStateBadgeMeta = {
+    label: string;
+    badgeClassName: string;
+};
+/**
+ * The non-connection state badges that ride ALONGSIDE the connection pill —
+ * `consent_required` / `display_unavailable` / `enrolling` describe a capability
+ * limitation, not reachability, so they render as their own tinted chip.
+ */
+export declare const MACHINE_STATE_BADGE_META: Partial<Record<MachineState, MachineStateBadgeMeta>>;
+export type ConnectionStatusPillProps = {
+    status: ConnectionStatus;
+    /** Override the label ("Online" -> "Connected", ...). */
+    label?: string | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The connection-status pill (online / reconnecting / offline) surfaced across
+ * the Machines dashboard, the dock header, and the session timeline. Reconnecting
+ * breathes (the resiliency-as-headline blip), online/offline hold still.
+ */
+export declare function ConnectionStatusPill({ status, label, size, className, }: ConnectionStatusPillProps): import("react/jsx-runtime").JSX.Element;
+export type ConnectionDotProps = {
+    status: ConnectionStatus;
+    className?: string | undefined;
+};
+/** Just the dot — for dense rows, the dock header, and timeline notices. */
+export declare function ConnectionDot({ status, className }: ConnectionDotProps): import("react/jsx-runtime").JSX.Element;
+export type MachineStatusPillProps = {
+    /** The machine's full state — drives the connection pill + any state badge. */
+    state: MachineState;
+    /** How many live sessions share this lease (renders a "Shared" chip when >1). */
+    sharedSessionCount?: number | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The composite machine status surface: the connection pill PLUS any
+ * consent/display/enrolling badge PLUS a shared-in-use chip. One component the
+ * dashboard row, the dock header, and the timeline all reuse so the status
+ * language is identical everywhere.
+ */
+export declare function MachineStatusPill({ state, sharedSessionCount, size, className, }: MachineStatusPillProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machines/health.d.ts

@@ -0,0 +1,25 @@
+import type { MachineState, MetricSample } from "../../types/machines";
+export type HealthLevel = "healthy" | "degraded" | "critical" | "offline" | "unknown";
+export type HealthVerdict = {
+    level: HealthLevel;
+    /** Title-case label for the pill ("Healthy", "Under load", "Critical", …). */
+    label: string;
+    /** One short human clause naming the dominant cause ("Memory 94%", "No display"…). */
+    reason: string;
+    /** The latest sample is older than we'd expect from a live agent (~5s cadence). */
+    stale: boolean;
+};
+/** Fold a machine's reachability + latest sample + wall-clock into one verdict. */
+export declare function deriveHealth(state: MachineState, metrics: MetricSample | null, now?: number): HealthVerdict;
+/**
+ * The token color ramp for a health level. Green/amber/red/grey is the
+ * universally-legible traffic model; we reserve it for the HEALTH verdict
+ * specifically (per-resource meters keep their own ramp in `machine-metrics`).
+ */
+export declare const HEALTH_TOKEN: Record<HealthLevel, {
+    text: string;
+    dot: string;
+    soft: string;
+}>;
+/** Live/transient levels breathe; settled levels hold still. */
+export declare function healthPulses(level: HealthLevel): boolean;

package/dist/components/machines/machine-detail.d.ts

@@ -0,0 +1,14 @@
+import type { MachineView, MetricSample } from "../../types/machines";
+import { type MetricWindow } from "./series";
+export type MachineDetailProps = {
+    machine: MachineView;
+    /** Downsampled history for the active window (from `fetchSeries`). */
+    series: MetricSample[];
+    window: MetricWindow;
+    onWindowChange: (w: MetricWindow) => void;
+    loadingSeries?: boolean | undefined;
+    onBack?: (() => void) | undefined;
+    now?: number | undefined;
+    className?: string | undefined;
+};
+export declare function MachineDetail({ machine, series, window, onWindowChange, loadingSeries, onBack, now, className, }: MachineDetailProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machines/metric-history-chart.d.ts

@@ -0,0 +1,24 @@
+export type SeriesPoint = {
+    t: number;
+    v: number | null;
+};
+export type MetricHistoryChartProps = {
+    points: SeriesPoint[];
+    /** Fixed ceiling (100 for %) or "auto" to fit the data with headroom. */
+    yMax?: number | "auto";
+    yMin?: number;
+    /** Format a value for the axis + readout (default: rounded + unit). */
+    format?: (v: number) => string;
+    unit?: string;
+    /** Stroke/fill hue — any CSS color; pass a token var to stay theme-safe. */
+    color?: string;
+    thresholds?: {
+        warn?: number | undefined;
+        crit?: number | undefined;
+    } | undefined;
+    height?: number;
+    /** Human range label for the empty state ("in the last hour"). */
+    rangeLabel?: string | undefined;
+    className?: string | undefined;
+};
+export declare function MetricHistoryChart({ points, yMax, yMin, format, unit, color, thresholds, height, rangeLabel, className, }: MetricHistoryChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machines/metric-sparkline.d.ts

@@ -0,0 +1,9 @@
+import type { SeriesPoint } from "./metric-history-chart";
+export type MetricSparklineProps = {
+    points: SeriesPoint[];
+    color?: string;
+    yMax?: number | "auto";
+    height?: number;
+    className?: string | undefined;
+};
+export declare function MetricSparkline({ points, color, yMax, height, className, }: MetricSparklineProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/machines/series.d.ts

@@ -0,0 +1,24 @@
+import type { MetricSample } from "../../types/machines";
+import type { SeriesPoint } from "./metric-history-chart";
+export type MetricWindow = "15m" | "1h" | "6h" | "24h";
+export declare const METRIC_WINDOWS: MetricWindow[];
+export declare const WINDOW_LABEL: Record<MetricWindow, string>;
+export type MetricKey = "cpu" | "mem" | "disk" | "load" | "gpu";
+export type MetricDef = {
+    key: MetricKey;
+    title: string;
+    unit: string;
+    yMax: number | "auto";
+    color: string;
+    thresholds?: {
+        warn?: number;
+        crit?: number;
+    };
+    pick: (s: MetricSample) => number | null;
+    /** Big current-value string for tiles/badges. */
+    current: (s: MetricSample) => string;
+    /** Optional sub-line under the current value. */
+    sub?: (s: MetricSample) => string | null;
+};
+export declare const METRICS: MetricDef[];
+export declare function pointsFor(def: MetricDef, samples: MetricSample[]): SeriesPoint[];

package/dist/components/machines-dashboard.d.ts

@@ -0,0 +1,30 @@
+import type { MachineView, MetricSample } from "../types/machines";
+export type MachinesDashboardProps = {
+    machines: MachineView[];
+    /** The session's active sandbox id (drives the per-card "Active" marker). */
+    activeSandboxId?: string | null | undefined;
+    loading?: boolean | undefined;
+    error?: Error | null | undefined;
+    /** Attach/swap the session's active sandbox to a machine. */
+    onAttach?: ((machine: MachineView) => void) | undefined;
+    /** The sandbox id currently being attached/swapped to (disables that card). */
+    attachingSandboxId?: string | null | undefined;
+    /** Short recent history per machine (keyed by sandboxId) — drives card sparklines. */
+    seriesByMachine?: Record<string, MetricSample[]> | undefined;
+    /** Open the per-machine telemetry detail (makes each card actionable). */
+    onOpenDetail?: ((machine: MachineView) => void) | undefined;
+    /** Shared clock so freshness/relative times render consistently across cards. */
+    now?: number | undefined;
+    /** Open the enrollment flow (the "Enroll a machine" CTA). */
+    onEnroll?: (() => void) | undefined;
+    onRefresh?: (() => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The workspace Machines dashboard: the fleet of selfhosted enrollments + the
+ * session's managed sandbox, each with its connection-status pill, state badges,
+ * latest metrics, and an attach/swap affordance. Renders the empty state (no
+ * machines → enroll CTA), a load error, and the populated grid. The component
+ * is purely presentational — feed it `MachinesResponse` data via `useMachines`.
+ */
+export declare function MachinesDashboard({ machines, activeSandboxId, loading, error, onAttach, attachingSandboxId, seriesByMachine, onOpenDetail, now, onEnroll, onRefresh, className, }: MachinesDashboardProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/markdown.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The default renderer for chat message bodies in {@link MessageTimeline}.
+ *
+ * Agent (and user) messages arrive as GitHub-flavored markdown. This turns the
+ * raw text into styled HTML using `react-markdown` + `remark-gfm`, themed to the
+ * package's `og-*` design tokens so it reads as one cohesive dark surface — no
+ * stock Tailwind colors leak in.
+ *
+ * It re-parses on every render, which is exactly right for streaming: a body
+ * that is still arriving (an unterminated `**`, a half-open code fence, a table
+ * mid-row) renders as best-effort markdown and resolves cleanly as the rest of
+ * the tokens land. Consumers who want a different renderer can still pass
+ * `renderMessageText` to `MessageTimeline` to override this entirely.
+ */
+export type MarkdownProps = {
+    children: string;
+    className?: string | undefined;
+    /**
+     * While true, newly arrived source fades in through tip ink (`.og-stream-ink`):
+     * an age window over each append batch — fast streams keep a large soft band,
+     * slow streams a tight tip. Paint-only: the DOM always holds the full truthful
+     * text. Once streaming ends and trailing ink settles, the body re-renders as
+     * plain markdown with a short local settle breath (no page-wide view
+     * transition — that blinked the whole document).
+     */
+    streaming?: boolean | undefined;
+};
+declare function MarkdownImpl({ children, className, streaming }: MarkdownProps): import("react/jsx-runtime").JSX.Element;
+/** Memoized so streaming re-renders of the parent don't re-parse settled bodies. */
+export declare const Markdown: import("react").MemoExoticComponent<typeof MarkdownImpl>;
+export {};