@invana/ui 0.0.30 → 0.0.31

package/dist/index.d.cts

@@ -462,6 +462,46 @@ declare const ResizableHandle: ({ withHandle, className, ...props }: React.Compo
 declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
+interface SegmentedOption {
+    /** What the caller gets back. */
+    value: string;
+    label: React$1.ReactNode;
+    disabled?: boolean;
+}
+interface SegmentedControlProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
+    options: SegmentedOption[];
+    /** Controlled. Pass it with {@link onValueChange}. */
+    value?: string;
+    /** Uncontrolled starting option. Defaults to the first. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** `xs` is 22px — a pagehead slot. `sm` is 26px, for a panel header. */
+    size?: "xs" | "sm";
+    /** Fill the width given, each option an equal share of it. */
+    stretch?: boolean;
+}
+/**
+ * One page, read another way.
+ *
+ * A run has four readings and a step has three — *In order · Layers · Flow ·
+ * Lens*, *Overview · Touched · Log* — and each of them is the **same record**
+ * drawn differently. That is what this control says and a tab strip does not:
+ * tabs own a panel and imply separate content underneath, so four tabs over one
+ * trace read as four pages that happen to share a header. A segmented control
+ * sits in the pagehead's action slot, beside the chips that describe the record,
+ * and says *this is a switch on what you are already looking at*.
+ *
+ * It is also not `ToggleGroup`. That is a set of independent toggles which may
+ * all be off; a reading is never off, so the control is a radio group and is
+ * announced as one. Arrow keys move between options, which is what a reader who
+ * never leaves the keyboard expects of a radio group.
+ *
+ * **The frame is the control.** One border around the whole thing, the active
+ * option filled with the primary tint and the rest plain — never a border per
+ * option, which draws three controls where there is one.
+ */
+declare const SegmentedControl: React$1.ForwardRefExoticComponent<SegmentedControlProps & React$1.RefAttributes<HTMLDivElement>>;
+
 declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
 declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
 declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
@@ -639,6 +679,38 @@ declare const ToggleGroupItem: React$1.ForwardRefExoticComponent<Omit<ToggleGrou
     size?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
 
+/**
+ * Why a band is not drawn — **and these are three different facts.**
+ *
+ * - `unrecorded` — nobody wrote this document. A step in flight has no
+ *   `result.json` because the interpreter writes it when the row settles.
+ * - `purged` — it was written, and retention removed it. The counts and the
+ *   outcome stay; the input, the output and the log do not.
+ * - `declared-none` — the step declares no such output at all: a `notify` step
+ *   returns nothing, and a read under `read_only: true` writes nothing.
+ *
+ * Collapsing them into one *empty* is the thing this component exists to stop.
+ * An empty table claims a step returned an empty result; *purged* claims it
+ * returned nothing. Both are lies about a different record.
+ */
+type AbsenceReason = "unrecorded" | "purged" | "declared-none";
+interface AbsenceNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    reason: AbsenceReason;
+    /** Overrides the word. The engine's own term is better where there is one — `read_only: true`. */
+    label?: React$1.ReactNode;
+    /** Why, in the record's terms. One or two sentences, and it is not optional in spirit. */
+    children?: React$1.ReactNode;
+}
+/**
+ * A band with nothing in it, saying which kind of nothing.
+ *
+ * It is not `EmptyState`: that invites an action — *load a dataset*, *ask a
+ * question* — and there is no action here. A step that recorded nothing is a
+ * finished fact about a finished record, and the only thing owed to the reader
+ * is which fact it is.
+ */
+declare const AbsenceNote: React$1.ForwardRefExoticComponent<AbsenceNoteProps & React$1.RefAttributes<HTMLDivElement>>;
+
 /**
  * How this address stood in the run, or in the rule being read.
  *
@@ -748,6 +820,88 @@ interface AppStatusBarProps extends React$1.HTMLAttributes<HTMLDivElement>, Vari
  */
 declare const AppStatusBar: React$1.ForwardRefExoticComponent<AppStatusBarProps & React$1.RefAttributes<HTMLDivElement>>;
 
+interface Artifact {
+    /** The file's name as the step wrote it — `rows-1284.csv`. */
+    name: React$1.ReactNode;
+    /** What produced it — `interpreter`, `export`, `rejects`, `input`. */
+    kind?: React$1.ReactNode;
+    size?: React$1.ReactNode;
+    /**
+     * **The address.** The same bytes produced twice are one artifact, so the
+     * digest — eight characters, mono — is what a reader quotes, not the name.
+     */
+    digest?: React$1.ReactNode;
+    /** When it landed, on the run's own clock — `+76.8s`. */
+    written?: React$1.ReactNode;
+    /**
+     * Retention has taken the bytes. The row stays and is struck: *this file
+     * existed and is gone* is a different fact from *no file was written*.
+     */
+    gone?: boolean;
+}
+interface ArtifactTableProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    files: Artifact[];
+    onOpen?: (file: Artifact, index: number) => void;
+    onDownload?: (file: Artifact, index: number) => void;
+    /** Anything else a row offers. Replaces the two defaults when given. */
+    renderActions?: (file: Artifact, index: number) => React$1.ReactNode;
+}
+/**
+ * The files a step left behind.
+ *
+ * A file is the one thing a step produces that outlives the reading of it, and
+ * it is **addressed by digest** — which is why the digest is drawn beside the
+ * name rather than hidden behind a tooltip: a file that outlives its run is
+ * still reachable, and two runs that produced the same bytes produced one
+ * artifact.
+ *
+ * Rejected records are a file like any other. That is what makes `18 rejected`
+ * something a person can open instead of a dead count.
+ *
+ * **A step that left nothing draws no table.** Absence is the caller's to
+ * render — see `AbsenceNote` — because an empty table here would claim the step
+ * wrote an empty file.
+ */
+declare const ArtifactTable: React$1.ForwardRefExoticComponent<ArtifactTableProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface AttemptRow {
+    /** `queued` · `attempt 1` · `attempt 2` · `settled`. */
+    label: React$1.ReactNode;
+    /** When it started, on the run's own clock — `+44.5s`. */
+    started?: React$1.ReactNode;
+    /** How long it took — `30.0s`, or `4.2s…` while it is still running. */
+    took?: React$1.ReactNode;
+    /** What happened, in one line. */
+    what?: React$1.ReactNode;
+    tone?: "muted" | "info" | "success" | "warning" | "destructive";
+    /** It ran and it did not stick. **Struck, never dropped.** */
+    struck?: boolean;
+}
+interface AttemptClockProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    rows: AttemptRow[];
+    /**
+     * What the two numbers are — `elapsed 32.4s · working 2.3s · the gap is the
+     * attempt that timed out`.
+     *
+     * **Stated, never left as arithmetic.** A reader who has to subtract two
+     * durations to find a 30-second timeout has been handed a sum instead of an
+     * answer.
+     */
+    summary?: React$1.ReactNode;
+}
+/**
+ * A step's clock, attempt by attempt.
+ *
+ * One duration cannot say what happened to a step that timed out once and then
+ * returned: `2.1s` is what it *did*, `32.4s` is what a reader waited, and the
+ * gap between them **is** the first attempt. So the clock is a row per attempt
+ * — queued, each try, settled — and the try that failed keeps its place, struck.
+ *
+ * Nothing new is recorded for this: it is the `timing` and `attempt` fields the
+ * interpreter already writes, read as a list instead of as a total.
+ */
+declare const AttemptClock: React$1.ForwardRefExoticComponent<AttemptClockProps & React$1.RefAttributes<HTMLDivElement>>;
+
 /**
  * TODO — provisional. Built ahead of its design review.
  *
@@ -1890,6 +2044,44 @@ declare class ErrorBoundary extends Component<{
     render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
 }
 
+interface ExchangeOption {
+    label: React$1.ReactNode;
+    /** The one that was taken. */
+    chosen?: boolean;
+}
+interface ExchangeRecordProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Who asked — `the agent asks`. */
+    asker?: React$1.ReactNode;
+    question: React$1.ReactNode;
+    /** Why it had to ask — `parse_intent found two readings and was told not to guess`. */
+    why?: React$1.ReactNode;
+    /** What it offered. Every option, with the taken one marked. */
+    options?: ExchangeOption[];
+    /** Who answered — `ravi answers`. */
+    answerer?: React$1.ReactNode;
+    answer?: React$1.ReactNode;
+    /** What the answer cost and what happened next — `after 41.2s · the run resumed on round 2`. */
+    answerNote?: React$1.ReactNode;
+}
+/**
+ * A question a run asked a person, after it was answered.
+ *
+ * `ClarifyCard` is the **live** ask — it has controls, and the run is waiting on
+ * them. This is the same exchange once it is a record: the question, every
+ * option it offered with the one taken marked, who answered and how long the
+ * run stood still. Nothing here is pickable, because the choice was made and a
+ * trace is never rewritten.
+ *
+ * **The options that were not taken stay.** *It chose by promise date* is a
+ * different fact from *it was offered two readings and chose by promise date* —
+ * the second is the one that explains the round that follows.
+ *
+ * The rails mark the **act**, not the participant: asking is an interruption,
+ * answering is what let the run continue. Which colour means `human` is a
+ * palette decision and belongs to the layer components.
+ */
+declare const ExchangeRecord: React$1.ForwardRefExoticComponent<ExchangeRecordProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface EyebrowProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /**
      * Right-aligned trailing text — a count, a position, a state. Kept separate
@@ -1943,6 +2135,18 @@ interface FilterChipProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonEl
     value?: React$1.ReactNode;
     /** Marks the chip as narrowing the list, so an active filter is visible while scrolling. */
     active?: boolean;
+    /**
+     * Clear this one filter, without opening its menu.
+     *
+     * Only for a chip that **is** set: an unset chip has nothing to clear, and an
+     * × on it would offer to undo something nobody did. With it, the chip is a
+     * pair of controls rather than one — the label opens the picker, the × drops
+     * the value — so both are reachable by keyboard and the × carries its own
+     * name.
+     */
+    onRemove?: () => void;
+    /** What the × is called, for a screen reader. Defaults to `Clear <label>`. */
+    removeLabel?: string;
 }
 /**
  * The row above a list that narrows it.
@@ -2014,6 +2218,36 @@ interface HeatStripProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "c
  */
 declare const HeatStrip: React$1.ForwardRefExoticComponent<HeatStripProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * The kinds of run Invana opens today — **suggestions, not a limit.**
+ *
+ * A product that grows a `simulate` kind passes `"simulate"` and the chip draws
+ * it. The journal is one list with one filter over it ([SR7]), so the kind is a
+ * *column value*, never a panel of its own — and a component that refused an
+ * unknown value would make the kit a release blocker for every new one.
+ */
+type KnownRunKind = "ask" | "import" | "bulk" | "stitch" | "enrich" | "schedule";
+/** What a run is, as an identifier — any string at all. See {@link KnownRunKind}. */
+type RunKind = KnownRunKind | (string & {});
+interface KindChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
+    kind: RunKind;
+    /** Not in play — a kind the current filter excludes. */
+    dim?: boolean;
+}
+/**
+ * What kind of run this row is: `ask` · `import` · `bulk` · `stitch` · `enrich`.
+ *
+ * **Neutral on purpose.** A kind is not a status and not a layer: it says which
+ * shape of work opened the run, and every kind is equally ordinary. Painting
+ * them would put five more hues on a row that already carries a status dot and
+ * a layer, and would invite a reader to think `import` is worse than `ask`.
+ *
+ * Mono, because the value is the engine's own (`kind in (import, bulk)` is a
+ * filter a person types), and small, because it sits inside a row that is
+ * already carrying an address and a summary.
+ */
+declare const KindChip: React$1.ForwardRefExoticComponent<KindChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
 interface LayerSectionProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
     layer: Layer;
     /**
@@ -2135,6 +2369,29 @@ interface LayerItem {
     note?: string;
     /** The rule that refused it, when one did. */
     ruleMatched?: string;
+    /** What this task usually takes — see {@link LayerForecast}. */
+    forecast?: LayerForecast;
+}
+/**
+ * What this task usually costs, drawn **on** the bar that says what it cost
+ * this time.
+ *
+ * `p50` is a **duration in the axis's own unit**, not a position: the median is
+ * a length of time a step takes, and placing it as an absolute moment would
+ * make the same forecast wrong for every run that started the step a second
+ * later. The strip turns it into a mark at `start + p50`, so the overrun is the
+ * gap between the mark and the bar's end — visible, rather than two numbers a
+ * reader has to subtract.
+ *
+ * Drawn for a task that came in **under** its median too. *Faster than usual*
+ * is a finding, and a forecast that only ever showed overruns would be a
+ * warning light rather than a comparison.
+ */
+interface LayerForecast {
+    /** The median, as a duration in the axis's unit. */
+    p50: number;
+    /** The gap in the caller's words — `+11%`, `−33%`, `inside p95`. */
+    note?: React$1.ReactNode;
 }
 /** A bounded repetition over a stretch of the axis — `loop · max 3`. */
 interface LayerBracket {
@@ -2175,6 +2432,17 @@ interface LayerSeam {
      * for one caller and not another. Drawn dashed — *this may appear*.
      */
     conditional?: boolean;
+    /**
+     * **Nothing can forecast this one.** How long a person takes to say yes is
+     * not in the record, so a gate marked this way is drawn dashed like a
+     * conditional one and its note carries the actual instead of a comparison.
+     *
+     * It exists as its own flag rather than as a caller's choice of words because
+     * *there is no estimate* and *the estimate was met* must not look alike on a
+     * drawing whose whole subject is forecast against actual. Drawing a guess
+     * here would be the one dishonest mark on the strip.
+     */
+    noEstimate?: boolean;
     /** Under the label — `nothing spent · finance-approvers · 4h`. */
     note?: string;
 }
@@ -2324,7 +2592,13 @@ declare const stateLabel: (state: LayerItemState) => string;
  */
 declare const LayerStrip: React$1.ForwardRefExoticComponent<LayerStripProps & React$1.RefAttributes<HTMLDivElement>>;
 
-type LegendSwatchKind = "dot" | "line" | "dashed" | "arrow" | "ring";
+type LegendSwatchKind = "dot" | "line" | "dashed" | "arrow" | "ring"
+/** The rail down a row — how a trace says which layer a step spent. */
+ | "stripe"
+/** A box around what it holds — a bounded repetition, drawn by containment. */
+ | "bracket"
+/** A line the drawing is crossed by, with the mark that names it — a gate. */
+ | "rule";
 interface LegendItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "color"> {
     /**
      * What the mark looks like on the canvas. A legend that draws a dot for
@@ -2390,6 +2664,34 @@ interface LensChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "c
  */
 declare const LensChip: React$1.ForwardRefExoticComponent<LensChipProps & React$1.RefAttributes<HTMLSpanElement>>;
 
+/** What the mark means, as a tone. The same seven `StatusDot` uses, less the dot. */
+type MarkTone = "muted" | "info" | "success" | "warning" | "destructive";
+interface MarkChipProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    tone?: MarkTone;
+    /** `↺ 2 of 3`, `⏸ 1 of 3`, `live`, `↳ delegates`. */
+    children?: React$1.ReactNode;
+}
+/**
+ * What happened to this row that its own columns cannot say.
+ *
+ * A run's trace row already carries a name, a description, a layer, a role and
+ * a duration. What it does *not* carry is the exception: this step took two
+ * attempts, this one is painting right now, this one asked a person, this one
+ * delegated a run of its own. Those are marks — they appear on a handful of
+ * rows and they are the rows a reader is looking for.
+ *
+ * **Outlined, never filled.** A filled chip competes with the row's own name at
+ * the same size; an outline reads as an annotation on the name, which is what it
+ * is. Mono, because most marks are counts against a bound (`2 of 3`) and the
+ * bound is the engine's number.
+ *
+ * Distinct from `BoundChip`, and the distinction is the point: a bound is what a
+ * callable **may** spend, declared before anything ran. A mark is what a run
+ * **did** — it exists only in the record, and it is usually the reason a reader
+ * opened the trace at all.
+ */
+declare const MarkChip: React$1.ForwardRefExoticComponent<MarkChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
 interface MatchCandidate {
     address: string;
     matched: boolean;
@@ -3125,6 +3427,52 @@ interface PanelStackProps {
  */
 declare function PanelStack({ sections, stackRef, onCollapsedChange, headerHeight, withHandle, className, headerClassName, bodyClassName, }: PanelStackProps): React$1.JSX.Element;
 
+/**
+ * What a run did with a participant it was allowed — **suggestions, not a
+ * limit.** A product with a seventh verdict passes it and the row draws it in
+ * the neutral.
+ */
+type KnownParticipantVerdict = "touched" | "never touched" | "refused" | "miss" | "denied";
+type ParticipantVerdict = KnownParticipantVerdict | (string & {});
+interface ParticipantRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The participant, as the world addresses it — `model/Routes@v4`. */
+    address: string;
+    verdict: ParticipantVerdict;
+    /** What happened — `1,284 rows · step 7`, `allowed, and nothing asked for it`. */
+    note?: React$1.ReactNode;
+    /**
+     * The tone the verdict is read in. Defaults: `touched` succeeds, `refused`
+     * and `denied` are destructive, everything else is muted — *allowed and never
+     * reached for* is not a failure, it is an invitation to narrow.
+     */
+    tone?: "success" | "muted" | "warning" | "destructive";
+    /**
+     * How the **address** is drawn. Derived from the verdict — `refused` strikes
+     * it in place, `never touched` mutes it — and overridable for a vocabulary
+     * the kit has not seen.
+     *
+     * Striking is `AddressChip`'s job and not this row's: the address is struck
+     * everywhere a refusal is shown, and two components deciding that
+     * independently is how one surface comes to strike and another to hide.
+     */
+    addressTone?: AddressTone;
+}
+/**
+ * One participant a run could have spent, and what it actually did with it.
+ *
+ * The Lens reading of a run is a list of these under their layers: every
+ * address the world allowed, each marked `touched` · `never touched` ·
+ * `refused`. **Nothing is filtered out**, because the list is not an inventory
+ * of what ran — it is the gap between *declared* and *did*, and each kind of
+ * gap names a different act. Three allowed and never touched is an invitation
+ * to narrow the world; a refusal is an invitation to widen it, or to accept
+ * that the graph cannot answer inside it.
+ *
+ * It is not `RuleRow`: a rule is a sentence about what *may* happen, written
+ * before anything ran. This is a fact about one execution.
+ */
+declare const ParticipantRow: React$1.ForwardRefExoticComponent<ParticipantRowProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface PropertyListProps extends React$1.HTMLAttributes<HTMLDListElement> {
     /**
      * Width of the label column. One value for the whole list, so every value
@@ -3267,6 +3615,32 @@ interface RecordHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
  */
 declare const RecordHeader: React$1.ForwardRefExoticComponent<RecordHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
 
+interface RecordPagerProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Where the reader is — `step 7 of 9`. */
+    position?: React$1.ReactNode;
+    onPrevious?: () => void;
+    onNext?: () => void;
+    /** What the two controls are called. The defaults name the *record*, not the direction. */
+    previousLabel?: string;
+    nextLabel?: string;
+}
+/**
+ * The record before this one, and the one after.
+ *
+ * A step opened from a run's trace is one of nine, and the reader almost always
+ * wants the next one — so walking the run costs two keystrokes rather than a
+ * return to the list and a second drill-in.
+ *
+ * **Both controls carry a name.** An icon-only button with no accessible name
+ * is a control a screen reader announces as "button", which is the one thing a
+ * pager must not be; `previousLabel` and `nextLabel` name the record, so it
+ * reads *previous step* rather than *left*.
+ *
+ * At either end the control is **disabled, not hidden**: a pager that loses a
+ * button at the edges moves the other one under the reader's cursor.
+ */
+declare const RecordPager: React$1.ForwardRefExoticComponent<RecordPagerProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface RepairNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** What was wrong — `unknown property Theme.velocity5d`. */
     from: React$1.ReactNode;
@@ -3492,6 +3866,93 @@ interface RuleRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "chi
  */
 declare const RuleRow: React$1.ForwardRefExoticComponent<RuleRowProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * How a run or a step ended, as the engine writes it — **suggestions, not a
+ * limit.** An unknown status still renders: it says its own name, in the
+ * neutral.
+ */
+type KnownRunStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled" | "cannot_answer" | "awaiting_approval" | "skipped" | "held" | "purged";
+type RunStatus = KnownRunStatus | (string & {});
+/**
+ * Which tone each status is read in.
+ *
+ * The kit owns this map where it does **not** own a layer's or a bound's
+ * colour, and the difference is real: a layer is a product's vocabulary, while
+ * *finished · finished but look at it · failed · not started* is the same small
+ * set of states every surface in the system already draws with `StatusDot`. Two
+ * maps for one idea is how a journal row and its own pagehead come to disagree.
+ *
+ * **`succeeded` and `cannot_answer` are deliberately different tones.** The
+ * machinery succeeded; the reading is that the graph cannot answer inside this
+ * world. A run that says both in one green word would be hiding the only fact
+ * the reader needs ([SR53]).
+ */
+declare const TONE: Record<string, StatusDotProps["tone"]>;
+interface RunStatusTextProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
+    status: RunStatus;
+    /** Overrides the tone {@link RunStatus} resolves to. */
+    tone?: StatusDotProps["tone"];
+    /** Draw the dot before the word. Off in a table cell, on in a row. */
+    dot?: boolean;
+    /** What to call it, when the engine's own word is not what this surface says. */
+    label?: React$1.ReactNode;
+}
+/**
+ * A run's outcome, in its tone and in the engine's own word.
+ *
+ * `succeeded` · `running` · `cannot_answer` · `awaiting_approval` — written as
+ * the record writes them, underscores and all, because these are the values a
+ * reader filters on and quotes into a support thread. Prettifying them here
+ * would mean the word on screen is not the word in the API.
+ *
+ * The word is always present, so colour is never the only carrier of the state.
+ */
+declare const RunStatusText: React$1.ForwardRefExoticComponent<RunStatusTextProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+interface RunRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title" | "onSelect"> {
+    status: RunStatus;
+    /** Overrides the tone the status resolves to. */
+    tone?: StatusDotProps["tone"];
+    kind?: RunKind;
+    /**
+     * The run's address — the last eight characters of its uuid, mono.
+     *
+     * **First on the row, before anything measured.** A row a reader cannot
+     * quote into a log line, a support thread or `GET …/runs/{id}` has made them
+     * drill in to find out what they are looking at.
+     */
+    address?: React$1.ReactNode;
+    /** What it was about — the question asked, the dataset loaded, the stitch run. */
+    title: React$1.ReactNode;
+    /** Under it — `2m 51s · 21.4k · 9/9 · 4 mins ago`. */
+    meta?: React$1.ReactNode;
+    /** Hard right — a badge, a count, an outcome. */
+    aside?: React$1.ReactNode;
+    /** A child run sits under the step that spawned it, indented — never a sibling. */
+    depth?: number;
+    selected?: boolean;
+    onSelect?: () => void;
+}
+/**
+ * One run in the journal.
+ *
+ * Every execution in a Graph is one of these — a question answered, a dataset
+ * loaded, a stitch committed, an enrichment gated on a person — because they
+ * are one record walked by one interpreter. **There is no row type per kind**
+ * and no panel per kind: the kind is a chip and a filter value, which is what
+ * keeps one journal from becoming four lists that drift apart.
+ *
+ * The order on the row is addressed, then described, then measured: the id, the
+ * kind, what it was about, and the numbers underneath. A reader scanning for
+ * *the run I was just looking at* finds it by id; a reader scanning for *what
+ * has this system been doing* reads the line under it.
+ *
+ * With `onSelect` the whole row is one button, so the accessible name is the
+ * whole row — the id, the kind and the summary in one string, which is exactly
+ * what a reader driving this from the keyboard needs to hear.
+ */
+declare const RunRow: React$1.ForwardRefExoticComponent<RunRowProps & React$1.RefAttributes<HTMLDivElement>>;
+
 /**
  * `sm` (26px) is the application field — a search box docked in a panel header,
  * beside a 30px tab strip. `default` (40px) stays the page size.
@@ -3839,6 +4300,15 @@ interface TaskNodeProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "ch
      * (`p50 3.4s · 14/14`). One rendering, three readings.
      */
     meta?: React$1.ReactNode;
+    /**
+     * The drawing is a **record**, not a draft: a picked node gets the ring and
+     * **no handles**.
+     *
+     * Handles are an offer to move something. A run paints status onto the plan
+     * it ran and nothing on it is editable, so a handle there is a control that
+     * does nothing — the one thing worse on a trace than a missing affordance.
+     */
+    readOnly?: boolean;
     /** Picked — draws the ring and four corner handles. */
     selected?: boolean;
     /** Needs an approval before it writes. Rings it in `warning`. */
@@ -4021,6 +4491,37 @@ declare const TimelineFooter: React$1.ForwardRefExoticComponent<TimelineFooterPr
 
 declare const Toolbar: React__default.FC;
 
+interface TouchItem {
+    layer: Layer;
+    /** What it amounts to — `3 calls`, `1,284 rows`, `miss`, `asked + approved`. */
+    note?: React$1.ReactNode;
+    /** What to call it, when {@link layerLabel} is not what this surface says. */
+    label?: React$1.ReactNode;
+    /** A guardrail said no. Struck in place, never dropped. */
+    refused?: boolean;
+    /** Allowed, and nothing reached for it. Present, and visibly not in play. */
+    dim?: boolean;
+}
+interface TouchStripProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    items: TouchItem[];
+    palette?: LayerPalette;
+}
+/**
+ * What a run touched at all — one cell per layer, on one line.
+ *
+ * This is a **summary**, and the whole reason it is a strip and not an axis.
+ * *What did this touch* is answered once for the whole run, so it costs one
+ * line above the list; drawn as a band per layer down a trace it would be a
+ * matrix one sixth full, because a step spends exactly one layer.
+ *
+ * **Refused is struck in place and never touched is dimmed, and neither is
+ * hidden.** The gap between what a world allowed and what the run reached for
+ * is the finding: three layers allowed and never touched is an invitation to
+ * narrow, and a refusal is an invitation to widen or to accept that the graph
+ * cannot answer. A strip that showed only what was spent could say neither.
+ */
+declare const TouchStrip: React$1.ForwardRefExoticComponent<TouchStripProps & React$1.RefAttributes<HTMLDivElement>>;
+
 /**
  * A single clickable/displayed reference shown in a step's
  * "REFERENCED COMPONENTS" row.
@@ -4124,6 +4625,106 @@ interface TourProps {
  */
 declare function Tour({ controller, steps, onExit, onComplete, badgeLabel, prevLabel, nextLabel, finishLabel, exitLabel, showExit, showCounter, showProgressBar, position, className, }: TourProps): React$1.JSX.Element | null;
 
+interface TraceListProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    children?: React$1.ReactNode;
+}
+/**
+ * A run, in the order it happened.
+ *
+ * The default reading of a trace, because *what happened, and then what* is the
+ * cheapest honest answer to a reader opening a run. Its rows are
+ * {@link TraceStep}s; a bounded repetition **contains** its rounds
+ * ({@link TraceLoop}) and a gate lies **between** rows ({@link TraceGate}).
+ *
+ * Nothing here is an axis. The layer a step spent is a column on its row, so a
+ * list nests for free and a second round is simply another row inside the box
+ * that holds it. The clock reading of the same trace is `LayerStrip`.
+ */
+declare const TraceList: React$1.ForwardRefExoticComponent<TraceListProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TraceStepProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect" | "role"> {
+    /** Where it sits in the run — the sequence number. */
+    seq?: React$1.ReactNode;
+    /** The step's key — `execute_query`. Mono, because it is the plan's own word. */
+    name: React$1.ReactNode;
+    /** One line: what it did, in the graph's terms. */
+    description?: React$1.ReactNode;
+    /** The participant class it spent. A step spends exactly one. */
+    layer?: Layer;
+    /** What it spent it on — `extract`, `decide`, `read_only`, `schema`. */
+    role?: React$1.ReactNode;
+    /** How long it took, or `—` when it never ran. */
+    duration?: React$1.ReactNode;
+    /** Under the duration — `ok`, `round 2`, `1,284 rows`, `skipped`. */
+    note?: React$1.ReactNode;
+    /** The exception this row carries — a `MarkChip`. */
+    mark?: React$1.ReactNode;
+    palette?: LayerPalette;
+    /** A delegated run's steps sit under the step that spawned them. */
+    depth?: number;
+    /** Dispatched to nobody: queued, held, or never reached. Present, not in play. */
+    dim?: boolean;
+    /** It ran and it failed, or it was refused. The name is struck, in the destructive tone. */
+    struck?: boolean;
+    selected?: boolean;
+    onSelect?: () => void;
+}
+/**
+ * One event of a run: a step, and everything that is true of it.
+ *
+ * **The stripe is the layer.** A step touches exactly one participant class, so
+ * the layer is a 3px rail down the row rather than a column of its own — which
+ * leaves the row's width for the two things a reader is actually scanning, the
+ * step's key and what it did.
+ *
+ * A row keeps its place in every state. A step that is painting right now, one
+ * that was skipped because the step above it failed, one that was refused: all
+ * three stay where they sit in the order, dimmed or struck. A list that dropped
+ * them would be a list that cannot say *nothing below the failure was
+ * dispatched*.
+ */
+declare const TraceStep: React$1.ForwardRefExoticComponent<TraceStepProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TraceLoopProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** What bounded it — `↻ 2 of 3 rounds — understood on round 2`. */
+    label: React$1.ReactNode;
+    /** Hard right — `3 events · 42.8s`. */
+    summary?: React$1.ReactNode;
+    /** The rail and wash it is drawn in. Defaults to the warning token. */
+    tone?: "warning" | "info" | "muted";
+    children?: React$1.ReactNode;
+}
+/**
+ * A bounded repetition, drawn by containment.
+ *
+ * The rounds are **inside** it, so a second round is one more row in the box
+ * and a list nests for free. Drawing a loop as a marker beside its rows would
+ * make a reader reconstruct which rows it held; drawing it as a bracket down the
+ * side is the clock reading's job, where the axis is time and rows are bands.
+ */
+declare const TraceLoop: React$1.ForwardRefExoticComponent<TraceLoopProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TraceGateProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** What it is — `approval — approved by ravi`. */
+    label: React$1.ReactNode;
+    /** What it cost — `waited 2m 04s · nothing was spent while it waited`. */
+    note?: React$1.ReactNode;
+    /** Defaults to the destructive token, which is what a stop is drawn in. */
+    tone?: "destructive" | "warning" | "muted";
+    /**
+     * Which side of the line the cost falls on. `before` — nothing has been spent
+     * yet; `after` — the work up to here is already paid for.
+     */
+    edge?: "before" | "after";
+}
+/**
+ * A gate — a rule across the list, never a row in it.
+ *
+ * It is dispatched by nobody, holds no slot and spends no participant, so it is
+ * not a step: it is a **condition on the way into one**. Drawn as a full-width
+ * rule with its chip hung off the side the cost falls on, *above this, nothing
+ * has been spent* becomes something the drawing says rather than something a
+ * legend has to claim.
+ */
+declare const TraceGate: React$1.ForwardRefExoticComponent<TraceGateProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface TreeViewProps {
     style?: React$1.CSSProperties;
     className?: string;
@@ -4305,4 +4906,4 @@ interface UseOverflowItemsResult {
  */
 declare function useOverflowItems({ count, enabled, pinnedIndex, reserve, }: UseOverflowItemsOptions): UseOverflowItemsResult;
 
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, AddressChip, type AddressChipProps, type AddressTone, AgentChip, type AgentChipProps, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AppStatusBar, type AppStatusBarProps, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, BarChartH, type BarChartHProps, BarChartV, type BarChartVProps, type BarDatum, type BaseNavProps, type Bound, BoundChip, type BoundChipProps, type BoundPalette, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, ButtonGroupSeparator, ButtonGroupText, type ButtonProps, ButtonWithTooltip, type ButtonWithTooltipProps, CAST_ROLES, CannotAnswerCard, type CannotAnswerCardProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CardWithHeader, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type CastResolution, type CastRole, type CastSource, CastTable, type CastTableProps, ChatSession, ChatSessionActivityRow, type ChatSessionActivityRowProps, type ChatSessionActivityStatus, ChatSessionActivitySubLine, type ChatSessionActivitySubLineProps, ChatSessionComposer, type ChatSessionComposerProps, ChatSessionContextChip, type ChatSessionContextChipProps, ChatSessionDisclosure, type ChatSessionDisclosureProps, ChatSessionMessage, type ChatSessionMessageAction, ChatSessionMessageOptions, type ChatSessionMessageOptionsProps, type ChatSessionMessageProps, type ChatSessionMessageRole, type ChatSessionMessageStatus, ChatSessionProgressLine, type ChatSessionProgressLineProps, ChatSessionPromptRow, type ChatSessionPromptRowProps, type ChatSessionProps, ChatSessionStatusBar, type ChatSessionStatusBarProps, ChatSessionTaskGroup, type ChatSessionTaskGroupProps, ChatSessionTaskRow, type ChatSessionTaskRowProps, type ChatSessionTaskStatus, CitationList, type CitationListProps, CitationMarker, CitationRow, type CitationRowProps, ClampedText, type ClampedTextProps, ClarifyCard, type ClarifyCardProps, type ClarifyOption, type ColumnDatum, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextBar, type ContextBarProps, type DeclaredAxes, DiagnosisCard, type DiagnosisCardProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiffList, type DiffListProps, type DiffOp, DiffRow, type DiffRowProps, DivergingBar, type DivergingBarProps, type DivergingDatum, DotRating, type DotRatingProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type EgressClass, EgressList, type EgressListProps, EmissionCard, type EmissionCardProps, EmissionHeader, type EmissionHeaderProps, type EmissionKind, EmptyState, EmptyStateLock, type EmptyStateLockProps, type EmptyStateProps, ErrorBoundary, Eyebrow, type EyebrowProps, FilterBar, type FilterBarProps, FilterChip, type FilterChipProps, type HeatCell, type HeatState, HeatStrip, type HeatStripProps, HoverCard, HoverCardContent, HoverCardTrigger, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, Kbd, KbdGroup, type KnownAddressTone, type KnownBound, type KnownDiffOp, type KnownLayer, type KnownLayerItemState, type KnownMetricTone, type KnownTerminalLevel, type Layer, type LayerBand, type LayerBracket, LayerChip, type LayerChipProps, type LayerItem, type LayerItemState, type LayerPaint, type LayerPalette, type LayerPart, type LayerScale, type LayerSeam, LayerSection, type LayerSectionProps, LayerStrip, type LayerStripProps, Legend, LegendItem, type LegendItemProps, type LegendProps, type LegendSwatchKind, LensChip, type LensChipProps, LensRow, type LensRowProps, type LensUsage, Link, type LinkProps, type MatchCandidate, MatchPreview, type MatchPreviewProps, MenuItem, type MenuItemProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, MetricGrid, type MetricGridProps, MetricTile, type MetricTileProps, type MetricTone, type Narrowing, NavBase, NavHorizontal, type NavHorizontalItem, NavHorizontalItems, type NavHorizontalItemsProps, type NavHorizontalProps, type NavItemConfig, NavItems, type NavItemsProps, type NavItemsVariant, type NavMenuItem, type NavSection, NavVertical, type NavVerticalItem, NavVerticalItems, type NavVerticalItemsProps, type NavVerticalProps, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, NestedMenu, type NestedMenuProps, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, PanelBox, type PanelBoxProps, PanelContent, type PanelContentProps, PanelStack, type PanelStackHandle, type PanelStackProps, type PanelStackSection, Popover, PopoverContent, PopoverTrigger, Progress, PropertyList, type PropertyListProps, PropertyRow, type PropertyRowProps, ProposalCard, type ProposalCardProps, RatingControl, type RatingControlProps, RecordHeader, type RecordHeaderProps, RepairNote, type RepairNoteProps, ResizableHandle, ResizablePanel, ResizablePanelGroup, RetryNote, type RetryNoteProps, RichSelect, type RichSelectOption, type RichSelectProps, type RuleEgress, type RuleProperties, RuleRow, type RuleRowProps, type RuleSelect, ScrollArea, ScrollBar, SearchInput, type SearchInputProps, type SearchInputSize, SectionHeader, type SectionHeaderProps, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, type SliceLine, SliceSummary, type SliceSummaryProps, Sparkline, type SparklineProps, Spinner, StatusDot, type StatusDotProps, type TabConfig, TabbedPanel, type TabbedPanelProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, TaskGantt, TaskGanttDetailCard, type TaskGanttDetailCardProps, type TaskGanttDetailProps, type TaskGanttInstant, type TaskGanttProps, type TaskGanttSegment, type TaskGanttStatus, type TaskGanttTask, TaskNode, type TaskNodeProps, type TaskNodeTag, type TemplateOption, TemplatePicker, type TemplatePickerProps, Terminal, type TerminalLevel, TerminalLine, type TerminalLineKind, type TerminalLineProps, type TerminalProps, TimelineEntry, type TimelineEntryProps, TimelineFooter, type TimelineFooterProps, TimelineList, type TimelineListProps, type TimelineVariant, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Toolbar, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TouchDirection, Tour, type TourController, type TourProps, type TourReference, type TourStep, TreeItem, TreeView, type TreeViewProps, Typography, TypographyBlockquote, type TypographyBlockquoteProps, TypographyH1, type TypographyH1Props, TypographyH2, type TypographyH2Props, TypographyH3, type TypographyH3Props, TypographyH4, type TypographyH4Props, TypographyH5, type TypographyH5Props, TypographyH6, type TypographyH6Props, TypographyInlineCode, type TypographyInlineCodeProps, TypographyLarge, type TypographyLargeProps, TypographyLead, type TypographyLeadProps, TypographyList, type TypographyListProps, TypographyMuted, type TypographyMutedProps, TypographyP, type TypographyPProps, TypographyPre, type TypographyPreProps, TypographySmall, type TypographySmallProps, UnderDevelopment, type UnderDevelopmentProps, type UseOverflowItemsOptions, type UseOverflowItemsResult, type UseTourOptions, type Verdict, agentChipVariants, badgeVariants, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, describeSlice, stateLabel as layerItemLabel, layerLabel, layerPaint, linkVariants, navigationMenuTriggerStyle, split as splitAddress, statusDotVariants, toggleVariants, useOverflowItems, useSidebar, useTour };
+export { AbsenceNote, type AbsenceNoteProps, type AbsenceReason, Accordion, AccordionContent, AccordionItem, AccordionTrigger, AddressChip, type AddressChipProps, type AddressTone, AgentChip, type AgentChipProps, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AppStatusBar, type AppStatusBarProps, type Artifact, ArtifactTable, type ArtifactTableProps, AttemptClock, type AttemptClockProps, type AttemptRow, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, BarChartH, type BarChartHProps, BarChartV, type BarChartVProps, type BarDatum, type BaseNavProps, type Bound, BoundChip, type BoundChipProps, type BoundPalette, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, ButtonGroupSeparator, ButtonGroupText, type ButtonProps, ButtonWithTooltip, type ButtonWithTooltipProps, CAST_ROLES, CannotAnswerCard, type CannotAnswerCardProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CardWithHeader, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type CastResolution, type CastRole, type CastSource, CastTable, type CastTableProps, ChatSession, ChatSessionActivityRow, type ChatSessionActivityRowProps, type ChatSessionActivityStatus, ChatSessionActivitySubLine, type ChatSessionActivitySubLineProps, ChatSessionComposer, type ChatSessionComposerProps, ChatSessionContextChip, type ChatSessionContextChipProps, ChatSessionDisclosure, type ChatSessionDisclosureProps, ChatSessionMessage, type ChatSessionMessageAction, ChatSessionMessageOptions, type ChatSessionMessageOptionsProps, type ChatSessionMessageProps, type ChatSessionMessageRole, type ChatSessionMessageStatus, ChatSessionProgressLine, type ChatSessionProgressLineProps, ChatSessionPromptRow, type ChatSessionPromptRowProps, type ChatSessionProps, ChatSessionStatusBar, type ChatSessionStatusBarProps, ChatSessionTaskGroup, type ChatSessionTaskGroupProps, ChatSessionTaskRow, type ChatSessionTaskRowProps, type ChatSessionTaskStatus, CitationList, type CitationListProps, CitationMarker, CitationRow, type CitationRowProps, ClampedText, type ClampedTextProps, ClarifyCard, type ClarifyCardProps, type ClarifyOption, type ColumnDatum, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextBar, type ContextBarProps, type DeclaredAxes, DiagnosisCard, type DiagnosisCardProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiffList, type DiffListProps, type DiffOp, DiffRow, type DiffRowProps, DivergingBar, type DivergingBarProps, type DivergingDatum, DotRating, type DotRatingProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type EgressClass, EgressList, type EgressListProps, EmissionCard, type EmissionCardProps, EmissionHeader, type EmissionHeaderProps, type EmissionKind, EmptyState, EmptyStateLock, type EmptyStateLockProps, type EmptyStateProps, ErrorBoundary, type ExchangeOption, ExchangeRecord, type ExchangeRecordProps, Eyebrow, type EyebrowProps, FilterBar, type FilterBarProps, FilterChip, type FilterChipProps, type HeatCell, type HeatState, HeatStrip, type HeatStripProps, HoverCard, HoverCardContent, HoverCardTrigger, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, Kbd, KbdGroup, KindChip, type KindChipProps, type KnownAddressTone, type KnownBound, type KnownDiffOp, type KnownLayer, type KnownLayerItemState, type KnownMetricTone, type KnownParticipantVerdict, type KnownRunKind, type KnownRunStatus, type KnownTerminalLevel, type Layer, type LayerBand, type LayerBracket, LayerChip, type LayerChipProps, type LayerForecast, type LayerItem, type LayerItemState, type LayerPaint, type LayerPalette, type LayerPart, type LayerScale, type LayerSeam, LayerSection, type LayerSectionProps, LayerStrip, type LayerStripProps, Legend, LegendItem, type LegendItemProps, type LegendProps, type LegendSwatchKind, LensChip, type LensChipProps, LensRow, type LensRowProps, type LensUsage, Link, type LinkProps, MarkChip, type MarkChipProps, type MarkTone, type MatchCandidate, MatchPreview, type MatchPreviewProps, MenuItem, type MenuItemProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, MetricGrid, type MetricGridProps, MetricTile, type MetricTileProps, type MetricTone, type Narrowing, NavBase, NavHorizontal, type NavHorizontalItem, NavHorizontalItems, type NavHorizontalItemsProps, type NavHorizontalProps, type NavItemConfig, NavItems, type NavItemsProps, type NavItemsVariant, type NavMenuItem, type NavSection, NavVertical, type NavVerticalItem, NavVerticalItems, type NavVerticalItemsProps, type NavVerticalProps, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, NestedMenu, type NestedMenuProps, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, PanelBox, type PanelBoxProps, PanelContent, type PanelContentProps, PanelStack, type PanelStackHandle, type PanelStackProps, type PanelStackSection, ParticipantRow, type ParticipantRowProps, type ParticipantVerdict, Popover, PopoverContent, PopoverTrigger, Progress, PropertyList, type PropertyListProps, PropertyRow, type PropertyRowProps, ProposalCard, type ProposalCardProps, RatingControl, type RatingControlProps, RecordHeader, type RecordHeaderProps, RecordPager, type RecordPagerProps, RepairNote, type RepairNoteProps, ResizableHandle, ResizablePanel, ResizablePanelGroup, RetryNote, type RetryNoteProps, RichSelect, type RichSelectOption, type RichSelectProps, type RuleEgress, type RuleProperties, RuleRow, type RuleRowProps, type RuleSelect, type RunKind, RunRow, type RunRowProps, type RunStatus, RunStatusText, type RunStatusTextProps, ScrollArea, ScrollBar, SearchInput, type SearchInputProps, type SearchInputSize, SectionHeader, type SectionHeaderProps, SegmentedControl, type SegmentedControlProps, type SegmentedOption, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, type SliceLine, SliceSummary, type SliceSummaryProps, Sparkline, type SparklineProps, Spinner, StatusDot, type StatusDotProps, type TabConfig, TabbedPanel, type TabbedPanelProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, TaskGantt, TaskGanttDetailCard, type TaskGanttDetailCardProps, type TaskGanttDetailProps, type TaskGanttInstant, type TaskGanttProps, type TaskGanttSegment, type TaskGanttStatus, type TaskGanttTask, TaskNode, type TaskNodeProps, type TaskNodeTag, type TemplateOption, TemplatePicker, type TemplatePickerProps, Terminal, type TerminalLevel, TerminalLine, type TerminalLineKind, type TerminalLineProps, type TerminalProps, TimelineEntry, type TimelineEntryProps, TimelineFooter, type TimelineFooterProps, TimelineList, type TimelineListProps, type TimelineVariant, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Toolbar, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TouchDirection, type TouchItem, TouchStrip, type TouchStripProps, Tour, type TourController, type TourProps, type TourReference, type TourStep, TraceGate, type TraceGateProps, TraceList, type TraceListProps, TraceLoop, type TraceLoopProps, TraceStep, type TraceStepProps, TreeItem, TreeView, type TreeViewProps, Typography, TypographyBlockquote, type TypographyBlockquoteProps, TypographyH1, type TypographyH1Props, TypographyH2, type TypographyH2Props, TypographyH3, type TypographyH3Props, TypographyH4, type TypographyH4Props, TypographyH5, type TypographyH5Props, TypographyH6, type TypographyH6Props, TypographyInlineCode, type TypographyInlineCodeProps, TypographyLarge, type TypographyLargeProps, TypographyLead, type TypographyLeadProps, TypographyList, type TypographyListProps, TypographyMuted, type TypographyMutedProps, TypographyP, type TypographyPProps, TypographyPre, type TypographyPreProps, TypographySmall, type TypographySmallProps, UnderDevelopment, type UnderDevelopmentProps, type UseOverflowItemsOptions, type UseOverflowItemsResult, type UseTourOptions, type Verdict, agentChipVariants, badgeVariants, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, describeSlice, stateLabel as layerItemLabel, layerLabel, layerPaint, linkVariants, navigationMenuTriggerStyle, TONE as runStatusTones, split as splitAddress, statusDotVariants, toggleVariants, useOverflowItems, useSidebar, useTour };