@tangle-network/sandbox-ui 0.113.6 → 0.114.0

package/dist/index-DiyLLZuJ.d.ts

@@ -0,0 +1,230 @@
+import * as React$1 from "react";
+import { AgentTimeline, AgentTimelineArtifactItem, AgentTimelineCustomItem, AgentTimelineItem, AgentTimelineMessageItem, AgentTimelineProps, AgentTimelineStatusItem, AgentTimelineTone, AgentTimelineToolGroupItem, AgentTimelineToolItem, ChatContainer as ChatContainer$1, ChatContainerProps as ChatContainerProps$1, ChatMessage as ChatMessage$1, ChatMessageProps, MessageList, MessageListProps, MessageRole, MessageRole as MessageRole$1, ThinkingIndicator, ThinkingIndicatorProps, UserMessage, UserMessageProps } from "@tangle-network/ui/chat";
+import { HarnessType, ReasoningEffort, modelProvider, snapHarnessToModel } from "@tangle-network/agent-interface";
+import * as DropdownMenu from "@radix-ui/react-dropdown-menu";
+//#region src/chat/reasoning-level-picker.d.ts
+/**
+ * A reasoning selection: `auto` is a UI-only sentinel ("let the harness/model default decide",
+ * sends no explicit override); every other value is the canonical `ReasoningEffort` from
+ * `@tangle-network/agent-interface` (the single source of truth — `none` … `ultracode`). The picker
+ * shows only the levels the chosen harness/model supports — see `reasoningEffortsFor` + the
+ * `available` prop — so unsupported levels (such as Kimi's mid-range) never appear rather than being
+ * silently degraded.
+ */
+type ReasoningLevel = "auto" | ReasoningEffort;
+interface ReasoningLevelOption {
+  value: ReasoningLevel;
+  label: string;
+  description: string;
+}
+interface ReasoningLevelPickerProps {
+  value: ReasoningLevel;
+  onChange: (value: ReasoningLevel) => void;
+  disabled?: boolean;
+  className?: string;
+  triggerClassName?: string;
+  options?: ReadonlyArray<ReasoningLevelOption>;
+  /**
+   * Capability filter — the reasoning efforts the currently-selected harness/model supports, from
+   * `reasoningEffortsFor(harness, model)`. When provided, the picker shows ONLY these (plus the
+   * `auto` sentinel), so a harness never offers a level it cannot express.
+   * Omit to show every option.
+   */
+  available?: ReadonlyArray<ReasoningEffort>;
+  /** Side the menu opens toward. Defaults to Radix's "bottom". */
+  side?: DropdownMenu.DropdownMenuContentProps["side"];
+  /**
+   * Let Radix flip the menu to the opposite side when it would overflow the
+   * viewport. Defaults to `true` (Radix default). Pass `false` to pin the menu
+   * to `side` — e.g. a composer floating in open space that should always open
+   * downward rather than flipping up over the heading.
+   */
+  avoidCollisions?: boolean;
+}
+declare const DEFAULT_REASONING_LEVEL_OPTIONS: ReadonlyArray<ReasoningLevelOption>;
+/**
+ * Per-harness option overrides for harnesses whose real control isn't a depth scale, so the generic
+ * ladder's labels would mislead. A harness with no entry uses {@link DEFAULT_REASONING_LEVEL_OPTIONS};
+ * either way the picker still intersects the chosen options with the harness/model `available` set, so
+ * only supported values render.
+ *
+ * `kimi-code` is a BINARY thinking toggle, not a gradient: its `--thinking` flag is simply off or on.
+ * `none` emits `--no-thinking` (off) and `high` maps to thinking-on, so the
+ * menu reads Auto / No thinking / Thinking rather than a misleading five-step scale.
+ */
+declare const HARNESS_REASONING_OPTIONS: Partial<Record<HarnessType, ReadonlyArray<ReasoningLevelOption>>>;
+declare function ReasoningLevelPicker({ value, onChange, disabled, className, triggerClassName, options, available, side, avoidCollisions }: ReasoningLevelPickerProps): React$1.JSX.Element;
+//#endregion
+//#region src/chat/agent-profile-picker.d.ts
+/**
+ * An agent profile: a named bundle of toolset + persona layered over the same
+ * model and session. `builtin` profiles are the product's shipped modes (e.g.
+ * Studio / Assistant); the rest are user-saved custom agents. The concept is
+ * backend-agnostic — it applies to a router-backed agent and a sandbox-backed
+ * one alike, which is why it lives beside the model control rather than under
+ * the harness.
+ */
+interface AgentProfileOption {
+  id: string;
+  name: string;
+  /** Builtin: a one-line description. Custom: derived "N tools" if omitted. */
+  description?: string;
+  /** Capability/tool-group ids this profile enables. */
+  capabilities?: ReadonlyArray<string>;
+  /** Persona / extra system instructions. */
+  instructions?: string;
+  /** A shipped mode vs a user-saved custom agent. */
+  builtin?: boolean;
+}
+/** A selectable tool group offered by the create/edit form. */
+interface AgentProfileCapability {
+  id: string;
+  label: string;
+  description?: string;
+}
+/** The editable shape the create/edit form emits. */
+interface AgentProfileDraft {
+  id?: string;
+  name: string;
+  capabilities: string[];
+  instructions: string;
+}
+interface AgentProfilePickerProps {
+  /** Selected profile id. */
+  value: string;
+  onChange: (id: string) => void;
+  profiles: ReadonlyArray<AgentProfileOption>;
+  /**
+   * Tool catalog for the create/edit form. Provide together with at least one
+   * write callback to enable authoring custom agents; omit for a
+   * selection-only picker (the New / edit / delete affordances stay hidden).
+   */
+  capabilities?: ReadonlyArray<AgentProfileCapability>;
+  onCreate?: (draft: AgentProfileDraft) => void | Promise<void>;
+  onUpdate?: (id: string, draft: AgentProfileDraft) => void | Promise<void>;
+  onDelete?: (id: string) => void | Promise<void>;
+  disabled?: boolean;
+  /** Keep the pinned profile visible while preventing profile selection. */
+  locked?: boolean;
+  /** Tooltip shown on the locked trigger when no `onNewChat` is provided. */
+  lockReason?: string;
+  /** Offer a fresh chat from the informative lock popover. */
+  onNewChat?: () => void;
+  className?: string;
+  /** Additional classes for the picker trigger. */
+  triggerClassName?: string;
+  /** Additional classes for the profile popover. */
+  popoverClassName?: string;
+  /** Side the menu opens toward. Defaults to up (composer-anchored). */
+  side?: "top" | "bottom";
+}
+/**
+ * Agent / mode switcher styled to match the chat control strip's pills
+ * (harness, model, effort). The pill shows the active profile; the menu lists
+ * builtin modes and saved custom agents. When a capability catalog and a write
+ * callback are supplied it also authors agents inline (name + tool toggles +
+ * persona) — a self-contained click-outside popover rather than a Radix menu,
+ * because the inline form needs its own focus and typing without the menu
+ * stealing keystrokes.
+ */
+declare function AgentProfilePicker({ value, onChange, profiles, capabilities, onCreate, onUpdate, onDelete, disabled, locked, lockReason, onNewChat, className, triggerClassName, popoverClassName, side }: AgentProfilePickerProps): React$1.JSX.Element;
+//#endregion
+//#region src/chat/artifact-agent-dock.d.ts
+type ArtifactKind = string;
+interface ArtifactScope {
+  kind: ArtifactKind;
+  key: string;
+  /** Short label shown in the dock header. Defaults to a generated one from kind/key. */
+  label?: string;
+}
+interface ArtifactDockMessage {
+  id: string;
+  role: MessageRole;
+  content: string;
+  createdAt?: Date;
+}
+type ArtifactDockStreamEvent = {
+  type: "delta";
+  text: string;
+} | {
+  type: "error";
+  message: string;
+};
+/**
+ * Consumer-supplied adapter. Keeps the dock decoupled from any specific app's
+ * API surface — every consumer wires its own thread-ensure, message-load, and
+ * NDJSON stream-send.
+ */
+interface ArtifactAgentDockTransport {
+  /** Get-or-create the canonical thread for this scope. */
+  ensureThread(scope: ArtifactScope): Promise<{
+    id: string;
+  }>;
+  /** Load prior messages, in chronological order. Optional — returns []. */
+  loadMessages?(threadId: string): Promise<ArtifactDockMessage[]>;
+  /** Stream a user turn. Yield delta events; the dock concatenates them. */
+  sendStream(args: {
+    threadId: string;
+    content: string;
+    signal: AbortSignal;
+  }): AsyncIterable<ArtifactDockStreamEvent>;
+  /** Stop the server-side run for a thread. Optional — when present, the dock
+   *  calls it on cancel/scope-switch BEFORE aborting the local fetch, so the
+   *  agent run is actually stopped (not orphaned, still billing) rather than
+   *  the client merely closing its reader. */
+  cancel?(args: {
+    threadId: string;
+  }): Promise<void> | void;
+}
+interface ArtifactAgentDockProps {
+  scope: ArtifactScope;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  transport: ArtifactAgentDockTransport;
+  defaultPrompt?: string;
+  /** Toast handler for non-fatal errors. Falls back to console.error. */
+  onError?: (message: string) => void;
+  className?: string;
+}
+/**
+ * ArtifactAgentDock — slide-in right-rail chat scoped to a single artifact.
+ *
+ * Renders a persistent, per-artifact conversation surface that streams via a
+ * consumer-supplied transport. Mount alongside any artifact view (file editor,
+ * sequence editor, asset preview) to give every artifact its own dedicated
+ * agent conversation without forking the chat UI per app.
+ *
+ * Behavior:
+ * - On open, calls `transport.ensureThread(scope)` to get the canonical thread
+ *   id and `transport.loadMessages(threadId)` to populate prior turns.
+ * - On submit, calls `transport.sendStream(...)` and concatenates delta events
+ *   into a single streaming assistant message; renders inline.
+ * - Composer: Enter sends, Shift+Enter newline, Cancel during stream supported.
+ * - Accessibility: scope `aria-label` on the panel, `aria-pressed` is the
+ *   consumer's job on whatever button toggles `open`.
+ */
+declare function ArtifactAgentDock({ scope, open, onOpenChange, transport, defaultPrompt, onError, className }: ArtifactAgentDockProps): React$1.JSX.Element | null;
+/**
+ * Build a transport that hits the Tangle product convention: POST
+ * /api/threads with body.scope = ArtifactScope to ensure the canonical
+ * thread; GET /api/threads/:id/messages to load history; POST /api/chat
+ * with body = {workspaceId, threadId, content} and an NDJSON event stream
+ * to send. Most consumers can use this as-is; advanced ones can supply
+ * their own transport object.
+ *
+ * The expected NDJSON event shape:
+ *   { type: "message.part.updated", data: { delta: string, part?: {type} } }  // assistant chunk
+ *   { type: "error", data: { message: string, ... } }        // surface error
+ *
+ * Other event types are ignored — consumers that need tool-call rendering
+ * or other event semantics should ship a richer transport.
+ */
+declare function createFetchTransport(opts: {
+  workspaceId: string;
+  threadsUrl?: string;
+  chatUrl?: string;
+  /** Optional fetch override (auth headers, baseURL, etc.). */
+  fetchImpl?: typeof fetch;
+}): ArtifactAgentDockTransport;
+//#endregion
+export { modelProvider as A, ReasoningLevelOption as B, ArtifactAgentDockProps as C, ArtifactKind as D, ArtifactDockStreamEvent as E, AgentProfilePicker as F, ReasoningLevelPickerProps as H, AgentProfilePickerProps as I, DEFAULT_REASONING_LEVEL_OPTIONS as L, AgentProfileCapability as M, AgentProfileDraft as N, ArtifactScope as O, AgentProfileOption as P, HARNESS_REASONING_OPTIONS as R, ArtifactAgentDock as S, ArtifactDockMessage as T, ReasoningLevelPicker as V, MessageRole$1 as _, AgentTimelineMessageItem as a, UserMessage as b, AgentTimelineTone as c, ChatContainer$1 as d, ChatContainerProps$1 as f, MessageListProps as g, MessageList as h, AgentTimelineItem as i, snapHarnessToModel as j, createFetchTransport as k, AgentTimelineToolGroupItem as l, ChatMessageProps as m, AgentTimelineArtifactItem as n, AgentTimelineProps as o, ChatMessage$1 as p, AgentTimelineCustomItem as r, AgentTimelineStatusItem as s, AgentTimeline as t, AgentTimelineToolItem as u, ThinkingIndicator as v, ArtifactAgentDockTransport as w, UserMessageProps as x, ThinkingIndicatorProps as y, ReasoningLevel as z };

package/dist/index-DvmZLMT1.d.ts

@@ -0,0 +1,30 @@
+import { ButtonProps } from "@tangle-network/ui/primitives";
+import * as React$1 from "react";
+import { AuthHeader, AuthHeaderProps, GitHubLoginButton, GitHubLoginButtonProps, LoginLayout, LoginLayoutProps, SessionUser, UserMenu, UserMenuProps } from "@tangle-network/ui/auth";
+//#region src/auth/tangle-login-button.d.ts
+interface TangleLoginButtonProps extends Omit<ButtonProps, "onClick"> {
+  /**
+   * Consumer-app endpoint that starts the cross-site SSO flow. The
+   * consumer's server is expected to redirect this request to the
+   * platform's `/cross-site/authorize` URL (built via
+   * `PlatformAuthClient.authorizeUrl` from
+   * `@tangle-network/agent-runtime/platform`). Defaults to
+   * `/auth/tangle`.
+   */
+  authUrl?: string;
+  /** Product variant for styling. */
+  variant?: "sandbox" | "default" | "outline";
+}
+/**
+ * "Login with Tangle" button — kicks off the cross-site SSO bridge.
+ * Server-side, the consumer app should:
+ *   1. Generate a `state` for CSRF.
+ *   2. Persist `state` in a session cookie or signed JWT.
+ *   3. 302-redirect to `PlatformAuthClient.authorizeUrl({ state, redirectUri })`.
+ *
+ * This component itself only triggers the redirect to `authUrl`; the
+ * server owns the platform URL construction.
+ */
+declare function TangleLoginButton({ authUrl, variant, className, children, ...props }: TangleLoginButtonProps): React$1.JSX.Element;
+//#endregion
+export { LoginLayout as a, UserMenu as c, TangleLoginButtonProps as d, GitHubLoginButtonProps as i, UserMenuProps as l, AuthHeaderProps as n, LoginLayoutProps as o, GitHubLoginButton as r, SessionUser as s, AuthHeader as t, TangleLoginButton as u };

package/dist/index-I8ZLVtHd.d.ts

@@ -0,0 +1,330 @@
+import { v as ExposedPort } from "./index-DPePq7c8.js";
+import { _ as RichFileTreeGitStatus, g as RichFileTreeGitEntry } from "./index-CXX5IpH2.js";
+import * as React$1 from "react";
+import { CSSProperties } from "react";
+//#region src/workbench/types.d.ts
+/** Which surface the artifact pane is currently showing. */
+type ArtifactView = "code" | "diff" | "preview" | "ports" | "terminal";
+/**
+ * A single artifact rendered by the pane. `content` is the working copy;
+ * when `baselineContent` differs from it, the Diff view becomes available
+ * and renders a word-level unified diff of baseline → content.
+ */
+interface SandboxArtifact {
+  id: string;
+  /** Canonical path inside the sandbox, e.g. `src/lib/retry.ts`. */
+  path: string;
+  /** Display name for the active file (usually the last path segment). */
+  filename: string;
+  /** Working-copy contents of the file. */
+  content: string;
+  /** Prior contents the working copy is diffed against. */
+  baselineContent?: string;
+  /** Explicit syntax language id (overrides extension inference). */
+  language?: string;
+  mimeType?: string;
+}
+/**
+ * Live PTY terminal binding. Maps straight onto `TerminalView` — both
+ * `apiUrl` and `token` are required to open a session against the sidecar.
+ */
+interface SandboxArtifactTerminal {
+  apiUrl: string;
+  token: string;
+  /** Stable id so the same PTY is restored across remounts. */
+  connectionId?: string;
+  title?: string;
+  subtitle?: string;
+}
+interface SandboxArtifactPaneProps {
+  /** The active artifact shown in the Code / Diff surfaces. */
+  artifact: SandboxArtifact;
+  /**
+   * Flat list of canonical paths for the file-tree rail in the Code view.
+   * Defaults to `[artifact.path]` when omitted (single-file tree).
+   */
+  paths?: ReadonlyArray<string>;
+  /** Per-path git-status decorations for the file tree. */
+  gitStatus?: ReadonlyArray<RichFileTreeGitEntry>;
+  /** Show the Code view's file-tree rail. Off for single-file embeds where the host owns navigation/tabs. */
+  showTree?: boolean;
+  /** Exposed ports; presence enables the Ports tab. */
+  ports?: ExposedPort[];
+  /** Live preview origin; presence enables the Preview tab. */
+  previewUrl?: string;
+  /** Live terminal binding; presence enables the Terminal tab. */
+  terminal?: SandboxArtifactTerminal;
+  /** Controlled active view. Pair with `onViewChange`. */
+  activeView?: ArtifactView;
+  /** Initial view when uncontrolled. Defaults to the first available view. */
+  defaultView?: ArtifactView;
+  onViewChange?: (view: ArtifactView) => void;
+  /** Fired when a different file is chosen in the tree (host swaps artifact). */
+  onFileSelect?: (path: string) => void;
+  /** Forwarded to the Ports view. */
+  onExposePort?: (port: number) => void;
+  onRemovePort?: (port: number) => void;
+  className?: string;
+  style?: CSSProperties;
+}
+/**
+ * One entry of the sandbox's git working tree, as the Changes pane lists it.
+ * `additions` / `deletions` are the numstat counts the sidecar's
+ * `GET /git/diff` reports per file.
+ *
+ * `baseline` / `current` are the file contents the diff is drawn from and are
+ * absent until the consumer resolves them for the selected file. Which of the
+ * two counts as "resolved" follows the status: an added or untracked file has
+ * no baseline and diffs against the empty string once `current` is present; a
+ * deleted file has no working copy and diffs against the empty string once
+ * `baseline` is present; every other status waits for both.
+ */
+interface ChangedFile {
+  path: string;
+  status: RichFileTreeGitStatus;
+  additions: number;
+  deletions: number;
+  /** Present once the consumer has resolved contents for the selected file. */
+  baseline?: string;
+  current?: string;
+  /**
+   * Why the sides could not be resolved. Shown under the file's header in
+   * place of the loading line, so a failed read never looks like a slow one.
+   */
+  loadError?: string;
+}
+interface ChangesPaneProps {
+  /** Current branch; `null` when the tree has no commits yet or is not a repository. */
+  branch: string | null;
+  ahead?: number;
+  behind?: number;
+  files: ChangedFile[];
+  selectedPath?: string;
+  onSelectFile?: (path: string) => void;
+  loading?: boolean;
+  error?: string | null;
+  onRefresh?: () => void;
+  /** Stage everything and commit. Resolve on success; reject with an Error the pane shows inline. */
+  onCommit?: (message: string) => Promise<void>;
+  onPush?: () => Promise<void>;
+  /** Which action is in flight; the pane disables the other and shows a spinner on this one. */
+  busy?: "commit" | "push" | null;
+  /** Open the file as a workbench artifact (the product wires this to its artifact opener). */
+  onOpenFile?: (path: string) => void;
+  className?: string;
+}
+//#endregion
+//#region src/workbench/sandbox-artifact-pane.d.ts
+/**
+ * Blueprint-grade artifact workbench. Composes the sandbox-ui substrate
+ * (`RichFileTree`, `PortsList`, `TerminalView`, `@pierre/diffs`) behind a
+ * single pill-tab view switcher: Code · Diff · Preview · Ports · Terminal.
+ * Tabs appear only when their data is present (Diff requires a differing
+ * baseline; Preview a url; Ports a port list; Terminal a live binding), so the
+ * chrome never shows a dead surface.
+ */
+declare function SandboxArtifactPane({ artifact, paths, gitStatus, showTree, ports, previewUrl, terminal, activeView, defaultView, onViewChange, onFileSelect, onExposePort, onRemovePort, className, style }: SandboxArtifactPaneProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/changes-pane.d.ts
+/**
+ * The sandbox's git working tree as a review surface: every changed file with
+ * its line counts, the selected file's word-level diff beneath, and a commit
+ * box in the footer. Data in, callbacks out — the pane never fetches; the
+ * consumer feeds it the sidecar's `/git/status` + `/git/diff` and resolves
+ * `baseline` / `current` for the file it is told was selected.
+ *
+ * The list is capped at 40% of the pane and scrolls, so the diff keeps its
+ * room however many files changed. The row's own chrome is compact: the
+ * workspace shell already gives its right pane the 56px `WorkspacePaneHeader`,
+ * so this header nests beneath it at `PanelHeader` rhythm rather than adding a
+ * second tall bar.
+ */
+declare function ChangesPane({ branch, ahead, behind, files, selectedPath, onSelectFile, loading, error, onRefresh, onCommit, onPush, busy, onOpenFile, className }: ChangesPaneProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/pill-tabs.d.ts
+interface PillTabItem<T extends string> {
+  value: T;
+  label: string;
+  icon?: React$1.ReactNode;
+}
+interface PillTabsProps<T extends string> {
+  items: ReadonlyArray<PillTabItem<T>>;
+  value: T;
+  onChange: (value: T) => void;
+  className?: string;
+  "aria-label"?: string;
+  /** Stable IDs supplied by the parent when it renders the associated panel. */
+  idPrefix?: string;
+  panelId?: string;
+}
+/**
+ * Sliding-pill segmented control. Reimplemented from blueprint-agent's
+ * framer-motion `PillTabs` with a measured CSS transform instead — no motion
+ * dependency. A `ResizeObserver` re-measures on container resize and font
+ * load so the indicator tracks the active tab exactly. Token-swapped onto the
+ * sandbox-ui surface ladder.
+ */
+declare function PillTabs<T extends string>({ items, value, onChange, className, "aria-label": ariaLabel, idPrefix, panelId }: PillTabsProps<T>): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/diff-utils.d.ts
+interface DiffStats {
+  added: number;
+  removed: number;
+}
+/**
+ * Count added / removed lines between two file revisions.
+ *
+ * Ported from blueprint-agent's `computeDiffStats`: normalize CRLF, short-
+ * circuit on equality, then `diffLines` with `ignoreWhitespace` so pure
+ * reindentation does not inflate the counts. `newlineIsToken:false` keeps a
+ * line (not its trailing newline) as the unit, matching the +/- a reader
+ * counts by eye.
+ */
+declare function computeDiffStats(original: string, current: string): DiffStats;
+/**
+ * Build a single-file unified patch (baseline → current) for `@pierre/diffs`'
+ * `PatchDiff`. `context: Infinity` would print the whole file; the default
+ * 4-line context keeps hunks compact while preserving locality. Equal inputs
+ * yield an empty string so callers can treat "" as "no diff".
+ */
+declare function buildUnifiedPatch(filename: string, baseline: string, current: string): string;
+//#endregion
+//#region src/workbench/panel-header.d.ts
+declare function GitStatusBadge({ status }: {
+  status: RichFileTreeGitStatus;
+}): React$1.JSX.Element;
+/** `+added −removed` line counts in mono; the same pair the Changes list prints per file. */
+declare function DiffStatsBadge({ stats, className }: {
+  stats: DiffStats;
+  className?: string;
+}): React$1.JSX.Element;
+interface PanelHeaderProps {
+  filename: string;
+  gitStatus?: RichFileTreeGitStatus;
+  /** Added/removed line counts; rendered only when provided (Diff view). */
+  stats?: DiffStats;
+  /** Enables the copy-to-clipboard action when set. */
+  copyText?: string;
+  /** Extra content rendered at the right edge, before the copy button. */
+  children?: React$1.ReactNode;
+  className?: string;
+}
+/**
+ * Thin bordered chrome bar above the artifact body — filename, git-status
+ * badge, optional diff counts, and a copy action. Ported in spirit from
+ * blueprint-agent's `PanelHeader` (min-h, hairline bottom border, dense
+ * horizontal rhythm), retoned to the sandbox-ui surface ladder.
+ */
+declare function PanelHeader({ filename, gitStatus, stats, copyText, children, className }: PanelHeaderProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/file-breadcrumb.d.ts
+interface FileBreadcrumbProps {
+  /** Canonical path, e.g. `src/lib/retry.ts`. */
+  path: string;
+  className?: string;
+}
+/**
+ * Slim path breadcrumb for the code panel. Reimplemented (not ported) from
+ * blueprint-agent's `FileBreadcrumb` — that one nests a `FileTree` dropdown per
+ * segment and couples to the workbench store + framer-motion. Here the rail
+ * already owns navigation, so this is a read-only trail: caret-separated parent
+ * segments with a file-icon leaf.
+ */
+declare function FileBreadcrumb({ path, className }: FileBreadcrumbProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/code-view.d.ts
+interface CodeViewProps {
+  path: string;
+  filename: string;
+  content: string;
+  language?: string;
+  /** Flat list of paths for the rail; defaults to `[path]`. */
+  paths?: ReadonlyArray<string>;
+  gitStatus?: ReadonlyArray<RichFileTreeGitEntry>;
+  onFileSelect?: (path: string) => void;
+  /** Show the file-tree rail. Off for single-file embeds where the host owns navigation. */
+  showTree?: boolean;
+  className?: string;
+}
+/**
+ * Code surface: a fixed-width `RichFileTree` rail (with git-status
+ * decorations) beside a breadcrumb-topped, syntax-highlighted read-only file
+ * view. The rail owns navigation; selecting a path fans out to `onFileSelect`
+ * so the host can swap the active artifact.
+ */
+declare function CodeView({ path, filename, content, language, paths, gitStatus, onFileSelect, showTree, className }: CodeViewProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/diff-view.d.ts
+interface DiffViewProps {
+  filename: string;
+  baseline: string;
+  current: string;
+  /** Hide when the surrounding PanelHeader already identifies the file. */
+  showFileHeader?: boolean;
+  /** Start wrapped so narrow review panes never conceal the end of a line. */
+  defaultWrap?: boolean;
+  className?: string;
+}
+/**
+ * Keep the maintained renderer for hunking, word diffs and highlighting. A new
+ * custom element per effect survives StrictMode remounts without hydrating stale
+ * shadow content. Wrapping is a renderer option, not a CSS patch into its shadow
+ * root; the plain patch disclosure is the accessible, engine-independent view.
+ */
+declare function DiffView({ filename, baseline, current, showFileHeader, defaultWrap, className }: DiffViewProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/preview-policy.d.ts
+type PreviewReadiness = {
+  state: "unknown";
+} | {
+  state: "checking";
+} | {
+  state: "ready";
+  checkedAt: string;
+  statusCode: number;
+} | {
+  state: "failed";
+  checkedAt: string;
+  message: string;
+};
+type PreviewAccess = {
+  state: "unknown";
+} | {
+  state: "public" | "authenticated";
+  source: "enforced-policy";
+  expiresAt?: string;
+};
+//#endregion
+//#region src/workbench/preview-view.d.ts
+interface PreviewViewProps {
+  /** A product-authorized preview URL. Relative navigation stays on its origin. */
+  url: string;
+  allowedOrigins?: readonly string[];
+  /** Supply only metadata obtained from the enforcing service, never a UI guess. */
+  access?: PreviewAccess;
+  readiness?: PreviewReadiness;
+  onCheckReadiness?: () => void;
+  onNavigate?: (url: string) => void;
+  className?: string;
+}
+declare function PreviewView({ url, allowedOrigins, access, readiness, onCheckReadiness, onNavigate, className }: PreviewViewProps): React$1.JSX.Element;
+//#endregion
+//#region src/workbench/syntax.d.ts
+/** Resolve a Prism language id from an explicit hint or the filename. */
+declare function resolveLanguage(filename: string, explicit?: string): string;
+declare const BRAND_PRISM_THEME: Record<string, CSSProperties>;
+interface CodeSurfaceProps {
+  code: string;
+  filename: string;
+  language?: string;
+  showLineNumbers?: boolean;
+  className?: string;
+}
+/**
+ * Read-only, brand-themed code renderer. Wrapped in a scroll container so the
+ * highlighter itself never grows the layout; line numbers sit in a muted,
+ * tabular column.
+ */
+declare function CodeSurface({ code, filename, language, showLineNumbers, className }: CodeSurfaceProps): React$1.JSX.Element;
+//#endregion
+export { SandboxArtifactTerminal as A, ChangesPane as C, ChangesPaneProps as D, ChangedFile as E, SandboxArtifact as O, PillTabsProps as S, ArtifactView as T, DiffStats as _, PreviewView as a, PillTabItem as b, DiffViewProps as c, FileBreadcrumb as d, FileBreadcrumbProps as f, PanelHeaderProps as g, PanelHeader as h, resolveLanguage as i, SandboxArtifactPaneProps as k, CodeView as l, GitStatusBadge as m, CodeSurface as n, PreviewViewProps as o, DiffStatsBadge as p, CodeSurfaceProps as r, DiffView as s, BRAND_PRISM_THEME as t, CodeViewProps as u, buildUnifiedPatch as v, SandboxArtifactPane as w, PillTabs as x, computeDiffStats as y };