@invana/ui 0.0.29 → 0.0.31

package/dist/index.d.cts

@@ -25,6 +25,24 @@ import * as TogglePrimitive from '@radix-ui/react-toggle';
 import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
 import { LucideIcon } from 'lucide-react';
 
+/**
+ * `clsx` + `tailwind-merge`, and nothing else.
+ *
+ * This used to be an `extendTailwindMerge` that registered one class group.
+ * `text-*` is ambiguous — it is both the font-size scale and the text-colour
+ * scale — so tailwind-merge decides which group a class belongs to by matching
+ * its value against Tailwind's built-in size names. `meta` was not one of them,
+ * so `text-meta` was read as a *colour* and silently dropped whatever colour
+ * class came before it:
+ *
+ *   cn("text-[var(--badge-ink)]", "text-meta")  →  "text-meta"   // colour lost
+ *
+ * The type ladder is now `base · sm · xs` (`@invana/styling`), every one of
+ * them a Tailwind built-in, so there is nothing left to register and the
+ * footgun is gone with the token that caused it. If a future `--text-*` token
+ * invents a name Tailwind does not know, bring the `extend` back in the same
+ * breath — it will eat colours at a distance and the cause will not be obvious.
+ */
 declare function cn(...inputs: ClassValue[]): string;
 
 declare const Accordion: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
@@ -302,6 +320,63 @@ declare function ItemFooter({ className, ...props }: React$1.ComponentProps<"div
 declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): React$1.JSX.Element;
 declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
 
+/**
+ * `variant` is how loudly the link asks to be clicked.
+ *
+ * Three, because three is what the product actually uses and a fourth would be
+ * a decision nobody could state:
+ *
+ * - `default` — a link inside a sentence. Accent-coloured, underlined on hover.
+ *   The colour is what marks it as a link while reading; the underline confirms
+ *   it under the cursor.
+ * - `underlined` — always underlined, accent-coloured. For a link that has to
+ *   read as a link **before** the cursor arrives: terms and conditions under a
+ *   sign-in button, a citation, anything legal or referential.
+ * - `quiet` — muted, brightening to the foreground on hover. A footer link, a
+ *   row that happens to be navigable. It is not shouting, and it is not
+ *   pretending to be body copy either: the hover is the affordance.
+ *
+ * Deliberately **not** a `Button` variant. A button performs an act on this
+ * page; a link goes somewhere, which is a different promise, a different
+ * element and a different set of things a browser will do for you (middle
+ * click, copy address, open in a tab). A `<button>` styled as a link takes all
+ * of that away, and `Button asChild` around an `<a>` is the escape hatch for
+ * the genuinely button-shaped case.
+ *
+ * No size axis. A link takes the size of the text it sits in — that is what
+ * makes it a link *in a sentence* rather than a control dropped into one.
+ */
+declare const linkVariants: (props?: ({
+    variant?: "default" | "underlined" | "quiet" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface LinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement>, VariantProps<typeof linkVariants> {
+    /**
+     * The destination is outside this app: opens in a new tab, and carries
+     * `rel="noreferrer noopener"` so the opened page cannot reach back through
+     * `window.opener`.
+     *
+     * A flag rather than asking every call site to remember `target` and `rel`
+     * together — the pair is the thing that is correct, and half of it is a
+     * security bug nobody notices.
+     */
+    external?: boolean;
+}
+/**
+ * A link. An `<a>` with the kit's colours, and the two behaviours an external
+ * one needs.
+ *
+ * It exists because every surface was writing its own — `text-primary
+ * hover:underline` here, `text-muted-foreground hover:underline` there — which
+ * is four spellings of one object and a colour that drifts the day the accent
+ * moves.
+ *
+ * Routing is the consumer's: this renders an `<a>`, and a router's own `Link`
+ * wraps it (`<RouterLink asChild>`) or takes these classes. The kit does not
+ * depend on a router, because a component that did could only ever be used with
+ * that one.
+ */
+declare const Link: React$1.ForwardRefExoticComponent<LinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+
 declare function MenubarMenu({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Menu>): React$1.JSX.Element;
 declare function MenubarGroup({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Group>): React$1.JSX.Element;
 declare function MenubarPortal({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Portal>): React$1.JSX.Element;
@@ -387,13 +462,53 @@ 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>>;
 declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
 declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const sheetVariants: (props?: ({
-    side?: "bottom" | "left" | "right" | "top" | null | undefined;
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
 }
@@ -564,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.
  *
@@ -573,7 +720,12 @@ declare const ToggleGroupItem: React$1.ForwardRefExoticComponent<Omit<ToggleGrou
  * is an event, and collapsing them loses *the bound was there and nothing ever
  * tested it*.
  */
-type AddressTone = "allowed" | "denied" | "refused" | "untouched";
+type KnownAddressTone = "allowed" | "denied" | "refused" | "untouched";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type AddressTone = KnownAddressTone | (string & {});
 /**
  * Split an address so the **participant survives truncation**.
  *
@@ -668,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.
  *
@@ -770,19 +1004,38 @@ interface BarChartVProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "c
 declare const BarChartV: React$1.ForwardRefExoticComponent<BarChartVProps & React$1.RefAttributes<HTMLDivElement>>;
 
 /**
- * The closed set of capabilities a callable may spend.
+ * The capabilities Invana ships today — **suggestions, not a limit.**
+ *
+ * These are what {@link Bound} autocompletes to. They bind nothing: a product
+ * that adds a `vector_write` bound as it grows passes `"vector_write"` and the
+ * chip draws it. The catalogue groups by these and an envelope ceilings them,
+ * but that is the *runtime's* vocabulary to police — a chip that refused to
+ * render an unknown bound would make the design kit a release blocker for
+ * every new capability.
+ */
+type KnownBound = "none" | "network" | "graph_read" | "graph_write" | "schema_write" | "ingest" | "llm" | "plan_write" | "work_write";
+/**
+ * What a callable may spend — any identifier at all.
  *
- * Nine values, fixed. The catalogue is grouped by these and an envelope
- * ceilings them, so this is a vocabulary rather than a list that grows.
+ * `(string & {})` keeps the known set autocompleting while accepting anything
+ * else without a cast. See {@link KnownBound}.
  */
-type Bound = "none" | "network" | "graph_read" | "graph_write" | "schema_write" | "ingest" | "llm" | "plan_write" | "work_write";
+type Bound = KnownBound | (string & {});
 /**
- * One hue per bound, fixed — colour follows the bound, never its position in a
- * list. Five come from the status tokens because they already mean the right
- * thing; the other four take data-palette slots, which are chosen for being
- * distinguishable from each other rather than for meaning anything.
+ * What each bound is painted with — **the kit ships no hues.**
+ *
+ * Which colour means `schema_write` is a product's decision. Four of the nine
+ * were only ever data-palette slots picked for being distinguishable from one
+ * another, which is exactly the kind of choice a component should not be
+ * making on a consumer's behalf; and holding the map forced every consumer
+ * onto a stylesheet that defines those slots, which is how `bg-data-*` came to
+ * be dead in the precompiled `@invana/ui/styles.css` without anyone noticing.
+ *
+ * Values are class strings, so a surface spends whatever its own Tailwind
+ * build has — a data-palette token, a status token, a brand colour. A bound
+ * left out draws in the neutral.
  */
-declare const SWATCH$1: Record<Bound, string>;
+type BoundPalette = Partial<Record<Bound, string>>;
 interface BoundChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
     bound: Bound;
     /**
@@ -790,6 +1043,19 @@ interface BoundChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "
      * it. Use sparingly — see the note on colour below.
      */
     swatchOnly?: boolean;
+    /** What to call it, when the identifier is not what this surface says. */
+    label?: React$1.ReactNode;
+    /**
+     * This chip's swatch class, given directly — `bg-data-7`, `bg-violet-500`.
+     * The shortest path when a call site draws one chip and knows its bound.
+     * Wins over {@link BoundChipProps.palette}.
+     */
+    swatch?: string;
+    /**
+     * What the bounds are painted with, when a caller draws several and would
+     * rather state the map once. Only this chip's own bound is read.
+     */
+    palette?: BoundPalette;
 }
 /**
  * What a task is allowed to spend, as a swatch and a name.
@@ -841,30 +1107,87 @@ interface CannotAnswerCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
 declare const CannotAnswerCard: React$1.ForwardRefExoticComponent<CannotAnswerCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
 /**
- * The five governed classes of participant, plus the spine.
+ * The classes of participant Invana ships today — **suggestions, not a limit.**
  *
- * Fixed — a Graph does not add a layer. `agent` is the **spine**: the runtime
- * itself, which does the participating rather than being a participant, and is
- * never governed. It is addressed and drawn like the rest so the ledger has one
- * shape.
+ * These are what {@link Layer} autocompletes to. They bind nothing: a product
+ * that grows a `vector_store` layer next week passes `"vector_store"` and every
+ * component here draws it, because a component that had to be edited before a
+ * developer could name a new layer is a component that owns the product's
+ * vocabulary.
+ *
+ * `agent` is the **spine**: the runtime itself, which does the participating
+ * rather than being a participant, and is never governed. Nothing in this file
+ * knows that — a band says so with `spine`, see `LayerStrip`.
  */
-type Layer = "graph_data" | "llm" | "third_party" | "cache" | "human" | "agent";
-/** What a reader calls the layer. The address segment is not the label. */
-declare const LABEL: Record<Layer, string>;
+type KnownLayer = "graph_data" | "llm" | "third_party" | "cache" | "human" | "agent";
 /**
- * One hue per layer, fixed — colour follows the layer, never its position.
+ * What a participant **is** — any identifier at all.
  *
- * Four are the data-palette slots `BoundChip` left free, so the two can sit in
- * one row on A2 without sharing a hue between different vocabularies. Two are
- * deliberate:
+ * `(string & {})` is what keeps both halves: the known set still autocompletes
+ * and still documents itself, while an unknown string is accepted without a
+ * cast. Widening this to plain `string` would silently drop the suggestions;
+ * narrowing it back to the union would make the kit the gatekeeper of a
+ * vocabulary it does not own.
+ */
+type Layer = KnownLayer | (string & {});
+/**
+ * What a reader calls the layer: the identifier with its underscores opened up.
  *
- * - `llm` takes `data-7`, the slot `BoundChip` gives the `llm` **bound**. Same
- *   concept, same hue; two hues for one idea is the confusion worth avoiding.
- * - `agent` is `muted-foreground`, because the spine is never governed and must
- *   not read as a bound somebody could set. `BoundChip` spends the same token on
- *   `none` for the same reason — *nothing to set here*.
+ * Derived rather than looked up — a table would have to be edited for every
+ * layer a product adds, and for all six Invana ships today the table said
+ * exactly this anyway (`graph_data` → `graph data`). A layer that wants
+ * something else passes `label`.
+ */
+declare const layerLabel: (layer: Layer) => string;
+/**
+ * How one layer is painted. **The kit ships no hues** — a consumer supplies
+ * these, because which colour means `llm` is a product's decision and not a
+ * component's.
+ *
+ * Both are class strings rather than colours, so a surface spends whatever
+ * palette its own Tailwind build already has: `bg-data-7` from
+ * `@invana/styling`, a brand token, a plain `bg-violet-500`. A component that
+ * held the map would force every consumer onto the kit's palette *and* onto a
+ * stylesheet that defines it — which is how `bg-data-*` came to be dead in the
+ * precompiled `@invana/ui/styles.css` without anyone noticing.
+ *
+ * It is passed to the component that draws, as a prop, every time — never
+ * installed once for a tree. A caller restating its palette at four call sites
+ * is the honest cost: the alternative hides *which* colours a drawing is using
+ * behind a provider somebody else mounted.
+ *
+ * - `swatch` is the **solid mark**: the dot beside a name, the rail down a bar.
+ * - `tint` is the **wash**: a bar's ground and edge together. Keep it faint —
+ *   it sits *behind* text, so a hue dark enough to label in is a hue too dark
+ *   to wash with.
+ * - `text` is the hue **as type**: a participant address written in its layer's
+ *   colour, so `model/Orders@v2` and the `graph data` dot above it are visibly
+ *   the same thing. This is the one that has to clear a contrast floor, which
+ *   is why it is yours to choose and separate from `swatch` — the token that
+ *   makes a legible 6px dot is often not the one that makes legible 13px mono.
  */
-declare const SWATCH: Record<Layer, string>;
+interface LayerPaint {
+    /** The solid mark — `bg-data-7`. */
+    swatch?: string;
+    /** The wash, ground and edge — `border-data-7/35 bg-data-7/10`. */
+    tint?: string;
+    /** The hue as type, for an address that should read as its layer — `text-data-7`. */
+    text?: string;
+}
+/**
+ * What each layer is painted with. Partial on purpose: a layer left out falls
+ * back to the neutral, which is a legible answer rather than a blank one.
+ */
+type LayerPalette = Partial<Record<Layer, LayerPaint>>;
+/**
+ * One layer's paint, with the neutral filled in for anything unsaid — so a
+ * caller never branches on `undefined` to draw a dot.
+ *
+ * There is no provider and no context. Colour arrives as the `palette` prop on
+ * the component that draws, every time: a chip painted from somewhere up the
+ * tree is a chip whose colour you cannot find by reading its call site.
+ */
+declare const layerPaint: (palette: LayerPalette | undefined, layer: Layer) => Required<LayerPaint>;
 interface LayerChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
     layer: Layer;
     /**
@@ -873,12 +1196,25 @@ interface LayerChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "
      * *nothing is configured* reads differently from *nothing matched*.
      */
     count?: number;
+    /** What to call it, when {@link layerLabel} is not what this surface says. */
+    label?: React$1.ReactNode;
     /**
      * The layer is closed, empty or out of view: the swatch drops to the muted
      * token and the label goes with it. The chip stays legible — this is *not
      * in play*, never *not there*.
      */
     dim?: boolean;
+    /**
+     * This chip's swatch class, given directly — `bg-data-7`, `bg-violet-500`.
+     * The shortest path when a call site draws one chip and knows its layer.
+     * Wins over {@link LayerChipProps.palette}.
+     */
+    swatch?: string;
+    /**
+     * What the layers are painted with, when a caller draws several and would
+     * rather state the map once. Only this chip's own layer is read.
+     */
+    palette?: LayerPalette;
 }
 /**
  * One class of participant, as a swatch and a name.
@@ -938,6 +1274,11 @@ interface LensRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "chi
     usage?: LensUsage;
     selected?: boolean;
     onSelect?: (name: string) => void;
+    /**
+     * What the layers of a `closes` narrowing are painted with. Omitted, those
+     * chips draw in the neutral.
+     */
+    palette?: LayerPalette;
 }
 /**
  * One world in the Worlds drawer: its name, what it narrows, and how used it is.
@@ -1488,7 +1829,12 @@ interface DiagnosisCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
  */
 declare const DiagnosisCard: React$1.ForwardRefExoticComponent<DiagnosisCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
-type DiffOp = "add" | "remove" | "change";
+type KnownDiffOp = "add" | "remove" | "change";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type DiffOp = KnownDiffOp | (string & {});
 interface DiffRowProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "children"> {
     op?: DiffOp;
     /** What kind of thing changed — `node`, `edge`, `property`. */
@@ -1698,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
@@ -1721,7 +2105,7 @@ interface EyebrowProps extends React$1.HTMLAttributes<HTMLDivElement> {
  * a {@link SectionHeader}, so several can sit in one scrolling column and still
  * read as subordinate to the panel's own title.
  *
- * Uppercase at `text-meta` with tracking, because at this size caps are what
+ * Uppercase at `text-sm` with tracking, because at this size caps are what
  * separate a label from the sentence under it; lowercase at 11px reads as body
  * copy set small. That is also why it is a component rather than four utility
  * classes: the treatment was being retyped, and a label that drifts a weight or
@@ -1751,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.
@@ -1822,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;
     /**
@@ -1838,6 +2264,11 @@ interface LayerSectionProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
     children?: React$1.ReactNode;
     /** How many participants the layer holds, shown on the chip. */
     count?: number;
+    /**
+     * What the layer is painted with — only this band's own layer is read.
+     * Omitted, the chip draws in the neutral.
+     */
+    palette?: LayerPalette;
     /** The layer is out of view for this lens: the whole band dims. */
     dim?: boolean;
 }
@@ -1863,72 +2294,311 @@ interface LayerSectionProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
 declare const LayerSection: React$1.ForwardRefExoticComponent<LayerSectionProps & React$1.RefAttributes<HTMLDivElement>>;
 
 /**
- * What a run did at one participant, in one step.
+ * What an item is doing where it sits — the two tenses in one vocabulary.
+ *
+ * `declared` is the plan tense: this is what the playbook **will** engage.
+ * `out` · `in` · `refused` · `skipped` are the run tense: what it did engage,
+ * what a bound stopped, and what it never reached for. Refused and skipped stay
+ * two different facts, and both are drawn — a drawing that showed only what
+ * happened would answer *what did this run do* and not *what was it stopped
+ * from doing*, and the second is the question the strip exists for.
+ */
+type KnownLayerItemState = "declared" | "out" | "in" | "refused" | "skipped";
+/**
+ * What an item is doing — **suggestions, not a limit.** A run that grows a
+ * `deferred` or a `retried` passes it and the bar draws: the neutral edge, and
+ * the state's own name under the label. Only the states above carry special
+ * drawing, because only they have a meaning defined here to draw.
+ */
+type LayerItemState = KnownLayerItemState | (string & {});
+/** The run half of {@link LayerItemState}, as the ledger's `direction` column. */
+type TouchDirection = Exclude<KnownLayerItemState, "declared"> | (string & {});
+/**
+ * One participant under a band — the row a task actually lands on.
  *
- * `refused` and `skipped` are two different facts and both are drawn: refused
- * means a bound stopped it, skipped means the plan never reached for it. A
- * drawing that showed only what happened would answer *what did this run do*
- * and not *what was it stopped from doing*, and the second is the question the
- * strip exists for.
+ * A band says *llm*; a part says **which** llm, or which role a caller may
+ * re-cast: `role: decide`, `model/Orders@v2`, `third_party/app/email`. Reading
+ * a plan is reading its parts, because that is the list a world is checked
+ * against.
  */
-type TouchDirection = "out" | "in" | "refused" | "skipped";
-interface Band {
+interface LayerPart {
+    id: string;
+    /** The participant address, or the role — `model/Orders@v2`, `role: decide`. */
+    label: string;
+    /** What the caller still owes, or what the crossing is — `egress: the note`. */
+    note?: string;
+}
+interface LayerBand {
     layer: Layer;
-    /** Overrides the layer's own name — `graph data · 4 models`. */
+    /** Overrides the layer's own name. */
     label?: React$1.ReactNode;
+    /** Right of the name — `declared · 1`, `nothing declared`, `2 roles`. */
+    note?: string;
+    /** The participants under it, each its own row. */
+    parts?: LayerPart[];
+    /**
+     * This band is the **spine** — the runtime's own dispatches, which the other
+     * bands are timed against and which is never governed. Its wire runs the
+     * whole axis and it is never drawn as unspent.
+     *
+     * The band says so rather than the component recognising a layer by name:
+     * `agent` is Invana's spine, but the layer vocabulary is a product's to grow
+     * and a strip that hard-coded one of its values would be a strip that had to
+     * be edited before anyone could rename it.
+     */
+    spine?: boolean;
 }
-interface StepTouch {
+/**
+ * One task, where it sits and how long it takes.
+ *
+ * `start` and `end` are in the axis's own unit — a step ordinal under `seq`, a
+ * millisecond under `elapsed`. A task with no `end` is an instant and is drawn
+ * at the minimum width.
+ */
+interface LayerItem {
+    id: string;
+    /** The task. This is the only place a task name is written. */
+    label: string;
     layer: Layer;
-    direction: TouchDirection;
-    /** The participant engaged, for the title and the drill-in. */
-    address?: string;
+    /** The {@link LayerPart} it lands on. Omitted, it sits on the band itself. */
+    part?: string;
+    start: number;
+    end?: number;
+    state?: LayerItemState;
+    /** Under the name — `decide`, `${supplier_id}`, `form: human`. */
+    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 {
+    id: string;
+    start: number;
+    end: number;
+    label: string;
 }
-interface Step {
+/**
+ * A **seam** — a moment on the axis where everything stops at once.
+ *
+ * A gate belongs to no band. It is not dispatched, it holds no slot and it has
+ * no participant, so it cannot be a bar: it is a condition on the way into a
+ * step, and it stops every layer together. That makes it a **position on the
+ * axis**, drawn as a rule the bands are crossed by — which is also the only
+ * drawing left once task names stop being the axis, because there are no
+ * columns for it to sit between.
+ *
+ * **Which side of the line the label sits on is the price of saying no.**
+ * `before` means nothing has been spent yet; `after` means the work up to here
+ * is already paid for. A reader gets what declining costs from where the mark
+ * sits, before reading a word of it.
+ */
+interface LayerSeam {
     id: string;
-    /** What the step is — short, it heads a column. */
+    /**
+     * Where it sits, in the axis's own unit. **Omitted, it has no position** —
+     * it can be raised at any dispatch, and it is drawn across the whole axis
+     * rather than at a point. Placing such a gate on one moment would be a guess.
+     */
+    at?: number;
+    /** What it is — `approval · before dispatch`, `verdict · after the pass`. */
     label: string;
-    /** The ledger's own `seq`, so the drawing and the stream agree. */
-    seq?: number;
-    touches: StepTouch[];
+    /** Which side of the line the cost falls on. Defaults to `before`. */
+    edge?: "before" | "after";
+    /**
+     * It is not on the plan: it resolves at dispatch, so the same plan is gated
+     * 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;
 }
+/** What the axis counts. */
+type LayerScale = "seq" | "elapsed";
 interface LayerStripProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> {
-    bands: Band[];
-    steps: Step[];
-    onSelectStep?: (stepId: string) => void;
-    selectedStep?: string;
+    bands: LayerBand[];
+    items: LayerItem[];
+    /**
+     * `seq` is a plan's time — what happens before what, one unit per step.
+     * `elapsed` is a run's, in milliseconds from the run opening.
+     */
+    scale?: LayerScale;
+    /** The axis extent. Defaults to the items' own. */
+    domain?: [number, number];
+    /** Tick positions in axis units. Defaults to integers (`seq`) or five (`elapsed`). */
+    ticks?: number[];
+    formatTick?: (value: number) => string;
+    brackets?: LayerBracket[];
+    /**
+     * The gates — the moments the whole drawing stops at. They get a row of their
+     * own above the bands *and* a rule down the track, because a gate has to read
+     * both as a thing with a name and as something every band is stopped by.
+     */
+    seams?: LayerSeam[];
+    onSelectItem?: (itemId: string) => void;
+    selectedItem?: string;
+    /**
+     * The bands whose participants are folded away, uncontrolled. Their tasks do
+     * not disappear with them: they drop onto the band's own line, which is the
+     * whole point of shutting one.
+     */
+    defaultCollapsed?: Layer[];
+    /** The same, controlled. Pass it with `onCollapsedChange`. */
+    collapsed?: Layer[];
+    onCollapsedChange?: (layers: Layer[]) => void;
     /**
-     * Keep the band labels in place while the steps scroll. On by default: a run
-     * with forty steps scrolls, and a band you cannot name is a row of marks.
+     * Offer the disclosures at all. Off, the bands render as given and a caller
+     * that wants an overview passes the bands it wants shut in `collapsed`.
+     */
+    collapsible?: boolean;
+    /**
+     * A hover card on each task, saying what the bar cannot fit: the participant
+     * it spends, when it runs and for how long, and the rule that refused it. On
+     * by default; off falls back to the native `title`.
+     */
+    hoverDetail?: boolean;
+    /** What that card says, when the default is not what this surface owes. */
+    itemDetail?: (item: LayerItem) => React$1.ReactNode;
+    /**
+     * Keep the band labels in place while time scrolls. On by default: a run with
+     * forty steps scrolls, and a band you cannot name is a row of marks.
      */
     frozenLabels?: boolean;
+    /**
+     * The label column, in `rem`. The default fits a layer name at the root size
+     * beside its note — `human` and `3 rounds · 6m 01s` on one line.
+     */
+    labelWidth?: number;
+    /** The narrowest the track is drawn before it scrolls, in `rem`. */
+    minTrackWidth?: number;
+    /**
+     * The narrowest one tick may be squeezed to, in `rem`. Past that the strip
+     * scrolls rather than shrinking: a bar too narrow to carry its task's name
+     * has stopped being a drawing of that task.
+     */
+    minSlotWidth?: number;
+    /**
+     * What the layers are painted with. The same map reaches the band chips and
+     * the bars, so a strip never disagrees with its own labels; a layer left out
+     * draws in the neutral.
+     */
+    palette?: LayerPalette;
 }
-declare const MARK_LABEL: Record<TouchDirection, string>;
+/** An unknown state is still a state: it says its own name. */
+declare const stateLabel: (state: LayerItemState) => string;
 /**
- * A run as six bands and one column per step — what it engaged, in `seq` order.
- *
- * Layers are the bands and steps are the columns, so a reader answers *what did
- * this run touch, and when* by scanning across one band, and *what did this
- * step do* by scanning down one column. The two questions the run dashboard is
- * asked, in one drawing.
+ * A plan or a run as layer bands over a time axis — a gantt, not a matrix.
+ *
+ * **Time is the x axis, in whichever tense the drawing is in.** A plan's time
+ * is its order (`seq` — what happens before what); a run's is the wall clock
+ * (`elapsed`). Task names are not an axis: a task is a bar, written once where
+ * it sits, so a reader answers *what does this engage, and for how long* by
+ * scanning across, and *what spends this participant* by scanning down.
+ *
+ * **A band opens into its participants.** `llm` is a band; `role: decide` and
+ * `role: extract` are the rows under it, and the task sits on the row it
+ * actually spends. The band alone cannot say which model a step will reach, and
+ * that is the list a world is checked against.
+ *
+ * **A band folds its participants away without losing its tasks.** Shut, the
+ * rows go and every task the layer spends drops onto the band's own line —
+ * which is the overview: six lines, every task placed in time, *what was this
+ * layer busy with* answered without reading twelve rows. Open, the same tasks
+ * sit on the participant that spends them. `collapse all` in the header does it
+ * to every band that has participants to fold, and nothing is hidden either
+ * way: folding moves a task up a row, it never drops it.
+ *
+ * **A bar says what it is; hovering it says what it cannot fit.** The card
+ * carries the participant the row truncates or folding took away, when the task
+ * runs and for how long, and the rule that refused it — so a bar can stay a bar
+ * rather than growing a second line for every fact somebody might want.
  *
  * **Refusals are struck in place, not removed.** A refused engagement keeps its
- * cell and takes a struck mark, because the empty cell it would otherwise leave
- * is indistinguishable from a step that never reached for that layer. *The
- * bound bit here* is the most important thing the drawing can say, and removing
- * the mark is the one edit that makes it unsayable.
- *
- * **The spine band is always drawn**, even when a lens governs nothing in it:
- * the runtime's own dispatches are what the other bands are timed against.
- *
- * DOM over a fixed grid, not canvas: it binds to no canvas store, it lives in
+ * bar and takes a struck label, because the gap it would otherwise leave is
+ * indistinguishable from a stretch of time that never reached for that layer.
+ *
+ * **A row nothing spent is drawn muted, never dropped.** A band no task
+ * touched takes the muted ground **across its whole width** — label column and
+ * track together — and so does a participant row under an open band:
+ * `role: extract` declared and never reached reads as *this run did not get
+ * that far*, not as an ordinary empty row. A dropped row would say nothing at
+ * all, and *this plan never reaches for a cache* is a finding.
+ *
+ * The ground is the carrier, not the type colour. A row is unspent because it
+ * is *empty*, and an empty row has no text to mute past its own name — greying
+ * the chip while the row keeps the card ground says *this label is quiet* when
+ * the fact is *nothing spends this layer*.
+ *
+ * **A bar wears its layer, and its state is the edge.** The hue tints the bar's
+ * ground and border and runs down its rail; dashed says the task never ran, and
+ * the destructive token says a rule refused it — the one fact that outranks
+ * whose bar it is. The label itself stays on a text token: the data palette is
+ * a surface palette here, which keeps `cache` as legible as `human`.
+ *
+ * **Refused is not unspent.** A row whose only task was refused keeps its full
+ * weight: being stopped from reaching a participant and never reaching for one
+ * are the two facts this drawing exists to separate.
+ *
+ * **A gate is a seam, not a row.** Nothing is dispatched at a gate, so it has
+ * no participant and cannot be a bar; it stops every band at once, so it is a
+ * position on the axis and the bands are crossed by it. Which side of the line
+ * its label hangs on is what saying no costs — `before` and nothing is spent,
+ * `after` and the pass is already paid for. A gate that can be raised at any
+ * dispatch has no position and draws across the whole axis instead.
+ *
+ * **The spine band is always drawn**, with its wire running the whole axis: the
+ * runtime's own dispatches are what the other bands are timed against, and it
+ * is never governed. A band declares itself the spine with `spine` — the strip
+ * recognises no layer by name. A spine that has dispatched nothing recedes like
+ * any other empty row: the wire still says *this is the clock*, and the muted
+ * ground says *it has not run yet*, which are two different facts.
+ *
+ * DOM over a fixed track, not canvas: it binds to no canvas store, it lives in
  * `mainSection` where no canvas exists, and frozen row labels plus text
  * selection are free here and expensive there.
  */
 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
@@ -1994,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;
@@ -2055,7 +2753,12 @@ declare const MenuItem: React$1.FC<MenuItemProps>;
  * Omit it for an ordinary measurement. A grid where every tile is coloured
  * carries no signal, and a number that is merely large is not a warning.
  */
-type MetricTone = "running" | "success" | "warning" | "error" | "info";
+type KnownMetricTone = "running" | "success" | "warning" | "error" | "info";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type MetricTone = KnownMetricTone | (string & {});
 interface MetricTileProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** What is being measured — `accepted`, `served (plan.verified)`, `hit rate`. */
     label: React$1.ReactNode;
@@ -2724,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
@@ -2866,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;
@@ -3091,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.
@@ -3421,6 +4283,10 @@ interface TaskNodeProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "ch
     taskKey: React$1.ReactNode;
     /** What it may spend. */
     bound: Bound;
+    /** The bound's swatch class, given directly — `bg-data-7`. */
+    boundSwatch?: string;
+    /** The bounds' palette, when a caller would rather state the map once. */
+    boundPalette?: BoundPalette;
     /**
      * How it went, when this node is painting a **run**. Omit when the node is
      * painting a plan or a draft, which have no status of their own.
@@ -3434,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`. */
@@ -3503,7 +4378,12 @@ type TerminalLineKind = "prompt" | "output" | "comment";
  * command you typed, what it printed, a comment. A run's log has no prompts and
  * no comments; every line is output, and what varies is how loud it is.
  */
-type TerminalLevel = "info" | "warn" | "error" | "debug";
+type KnownTerminalLevel = "info" | "warn" | "error" | "debug";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type TerminalLevel = KnownTerminalLevel | (string & {});
 interface TerminalLineProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
     kind?: TerminalLineKind;
     /**
@@ -3611,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.
@@ -3714,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;
@@ -3895,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, type Band, BarChartH, type BarChartHProps, BarChartV, type BarChartVProps, type BarDatum, type BaseNavProps, type Bound, BoundChip, type BoundChipProps, 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 Layer, LayerChip, type LayerChipProps, LayerSection, type LayerSectionProps, LayerStrip, type LayerStripProps, Legend, LegendItem, type LegendItemProps, type LegendProps, type LegendSwatchKind, LensChip, type LensChipProps, LensRow, type LensRowProps, type LensUsage, 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 Step, type StepTouch, 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, SWATCH$1 as boundSwatch, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, describeSlice, LABEL as layerLabel, SWATCH as layerSwatch, navigationMenuTriggerStyle, split as splitAddress, statusDotVariants, toggleVariants, MARK_LABEL as touchLabel, 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 };