@invana/ui 0.0.30 → 0.0.32

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { ClassValue } from 'clsx';
 import * as React$1 from 'react';
-import React__default, { Component, ReactNode } from 'react';
+import React__default, { Component, ReactNode, ErrorInfo, ElementType, CSSProperties } from 'react';
 import * as AccordionPrimitive from '@radix-ui/react-accordion';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
@@ -16,6 +16,7 @@ import * as MenubarPrimitive from '@radix-ui/react-menubar';
 import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
 import * as ProgressPrimitive from '@radix-ui/react-progress';
+import { Questionnaire as Questionnaire$1 } from '@shadcn/react/questionnaire';
 import { Separator as Separator$1, Panel, Group } from 'react-resizable-panels';
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
@@ -25,24 +26,6 @@ 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>>;
@@ -52,6 +35,7 @@ declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<Accordion
 
 declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
     variant?: "default" | "destructive" | null | undefined;
+    tone?: "destructive" | "info" | "success" | "warning" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLDivElement>>;
 declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
 declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
@@ -74,9 +58,31 @@ declare const AlertDialogDescription: React$1.ForwardRefExoticComponent<Omit<Ale
 declare const AlertDialogAction: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+/**
+ * Sizes are the control scale, so an avatar sits in a row of controls at the
+ * row's height: `xs` 22 · `sm` 26 · `md` 32 · `lg` 40px at a 13px root. `lg`
+ * is the default — the size it always had. Its initials step down with it.
+ */
+declare const avatarVariants: (props?: ({
+    size?: "xs" | "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AvatarProps extends React$1.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
+}
+declare const Avatar: React$1.ForwardRefExoticComponent<AvatarProps & React$1.RefAttributes<HTMLSpanElement>>;
 declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
 declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+interface AvatarGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Show this many and fold the rest into a `+n` avatar. */
+    max?: number;
+    /** The size of the `+n` avatar — the same as the avatars it follows. */
+    size?: AvatarProps["size"];
+}
+/**
+ * Avatars overlapping in a row — who is on a run, a thread, a review — each
+ * ringed in the background so the overlap reads as edges. Past `max`, the rest
+ * are one `+n`.
+ */
+declare const AvatarGroup: React$1.ForwardRefExoticComponent<AvatarGroupProps & React$1.RefAttributes<HTMLDivElement>>;
 
 /**
  * `variant` is the treatment, `tone` is the meaning.
@@ -88,15 +94,15 @@ declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimi
  * recolours `default`, `outline` and `soft`, and leaves `secondary` and
  * `destructive` alone — those are already a colour decision.
  *
- * No pill. A badge is structure, so it takes the structure radius, 0 (see
- * `@invana/styling` › border radius, decided 01-09-2026). Where round *is* the
- * object — a count bubble on a nav item, a state marker — that is `StatusDot`
- * or an explicit `rounded-full`, never a badge variant.
+ * No pill. A badge sits at control height beside buttons, so it takes the
+ * control radius, `rounded-control` (see `@invana/styling` › border radius).
+ * Where round *is* the object — a count bubble on a nav item, a state marker —
+ * that is `StatusDot` or an explicit `rounded-full`, never a badge variant.
  */
 declare const badgeVariants: (props?: ({
     variant?: "default" | "destructive" | "outline" | "secondary" | "soft" | null | undefined;
-    tone?: "primary" | "success" | "warning" | "info" | "muted" | null | undefined;
-    size?: "default" | "xs" | "sm" | null | undefined;
+    tone?: "destructive" | "info" | "success" | "warning" | "primary" | "muted" | null | undefined;
+    size?: "xs" | "sm" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }
@@ -122,7 +128,7 @@ declare const BreadcrumbEllipsis: {
 
 declare const buttonVariants: (props?: ({
     variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | "soft" | null | undefined;
-    size?: "default" | "xs" | "sm" | "lg" | "icon-xs" | "icon" | "nav-icon" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon-xs" | "icon-sm" | "icon" | "nav-icon" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
@@ -302,8 +308,10 @@ declare const itemVariants: (props?: ({
     variant?: "default" | "outline" | "muted" | null | undefined;
     size?: "default" | "xs" | "sm" | null | undefined;
     selected?: boolean | null | undefined;
+    dim?: boolean | null | undefined;
+    struck?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Item({ className, variant, size, selected, asChild, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof itemVariants> & {
+declare function Item({ className, variant, size, selected, dim, struck, asChild, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof itemVariants> & {
     asChild?: boolean;
 }): React$1.JSX.Element;
 declare const itemMediaVariants: (props?: ({
@@ -453,6 +461,75 @@ declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive
     size?: ProgressSize;
 } & React$1.RefAttributes<HTMLDivElement>>;
 
+type NavProps = Pick<ButtonProps, "size" | "variant">;
+declare function Questionnaire({ className, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Root>): React$1.JSX.Element;
+/**
+ * The progress line on its own — a label and a bar filled to `value` (0–1).
+ * `QuestionnaireProgress` draws it from the questionnaire's position; a step
+ * outside the items, such as a review before submitting, draws it directly.
+ */
+declare function QuestionnaireProgressBar({ label, value, className, ...props }: React$1.ComponentProps<"div"> & {
+    label?: React$1.ReactNode;
+    value: number;
+}): React$1.JSX.Element;
+/**
+ * `1 of 3` and a bar that fills as the steps are answered. Pass children to
+ * replace the count's words; the bar stays.
+ */
+declare function QuestionnaireProgress({ className, children, ...props }: Omit<React$1.ComponentProps<typeof Questionnaire$1.Progress>, "render">): React$1.JSX.Element;
+declare function QuestionnaireItem({ className, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Item>): React$1.JSX.Element;
+declare function QuestionnaireTitle({ className, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Title>): React$1.JSX.Element;
+declare function QuestionnaireDescription({ className, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Description>): React$1.JSX.Element;
+declare function QuestionnaireChoices({ className, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Choices>): React$1.JSX.Element;
+interface QuestionnaireChoiceProps extends React$1.ComponentProps<typeof Questionnaire$1.Choice> {
+    /**
+     * Where the choice comes from, on the right in mono — `142 open POs`,
+     * `pnl.total`. What makes an option read as something the data holds.
+     */
+    detail?: React$1.ReactNode;
+    /**
+     * A settled answer: the choice is shown, not offered. Unlike `disabled` it
+     * keeps full strength, so the answer still reads.
+     */
+    readOnly?: boolean;
+    /**
+     * A short tag or an icon in a box before the choice — `BV`, a store. What
+     * the choice is, read before its name.
+     */
+    lead?: React$1.ReactNode;
+    /**
+     * A figure on the right, in place of `detail` — the value over its unit,
+     * `2,480` over `kg/ha`. What the choice would give, read before picking it.
+     */
+    figure?: QuestionnaireChoiceFigure;
+}
+/**
+ * The tones the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders in the foreground.
+ */
+type QuestionnaireFigureTone = "success" | "warning" | "error" | (string & {});
+interface QuestionnaireChoiceFigure {
+    value: React$1.ReactNode;
+    unit?: React$1.ReactNode;
+    tone?: QuestionnaireFigureTone;
+}
+declare function QuestionnaireChoice({ children, className, detail, readOnly, disabled, lead, figure, ...props }: QuestionnaireChoiceProps): React$1.JSX.Element;
+/** The choice itself — `Delegation`. Sits above an optional description. */
+declare function QuestionnaireChoiceTitle({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+/** What the choice means — `Show how work moves to a specialist.` */
+declare function QuestionnaireChoiceDescription({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+interface QuestionnaireInputProps extends React$1.ComponentProps<typeof Questionnaire$1.Input> {
+    /** The unit, on the right in mono — `%`, `kg/ha`. Open vocabulary. */
+    unit?: React$1.ReactNode;
+}
+declare function QuestionnaireInput({ className, unit, ...props }: QuestionnaireInputProps): React$1.JSX.Element;
+declare function QuestionnaireError({ className, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Error>): React$1.JSX.Element;
+declare function QuestionnaireActions({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function QuestionnairePrevious({ children, className, size, variant, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Previous> & NavProps): React$1.JSX.Element;
+declare function QuestionnaireSkip({ children, className, size, variant, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Skip> & NavProps): React$1.JSX.Element;
+declare function QuestionnaireNext({ children, className, size, variant, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Next> & NavProps): React$1.JSX.Element;
+declare function QuestionnaireSubmit({ children, className, size, variant, ...props }: React$1.ComponentProps<typeof Questionnaire$1.Submit> & NavProps): React$1.JSX.Element;
+
 declare const ResizablePanelGroup: (props: React.ComponentProps<typeof Group>) => React$1.JSX.Element;
 declare const ResizablePanel: typeof Panel;
 declare const ResizableHandle: ({ withHandle, className, ...props }: React.ComponentProps<typeof Separator$1> & {
@@ -462,13 +539,74 @@ 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;
+    /** A second line under the label, smaller and muted — `±1.4 pp`. */
+    sub?: React$1.ReactNode;
+    disabled?: boolean;
+}
+interface SegmentedControlProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
+    options: SegmentedOption[];
+    /** Controlled. Pass it with {@link onValueChange}; `null` is no pick. */
+    value?: string | null;
+    /**
+     * Uncontrolled starting option. Defaults to the first, because a reading is
+     * never off. `null` starts with none picked — a question not yet answered,
+     * where picking the first for the reader would answer it for them.
+     */
+    defaultValue?: string | null;
+    onValueChange?: (value: string) => void;
+    /**
+     * The control scale: `xs` (22px) inside a row, `sm` (26px) beside a search
+     * or filter chips, `md` (32px, the default — as for every control) in a
+     * standalone form.
+     */
+    size?: "xs" | "sm" | "md";
+    /** Fill the width given, each option an equal share of it. */
+    stretch?: boolean;
+    /**
+     * `tint` marks the active option with the primary tint — a reading of the
+     * page. `solid` fills it with primary and rules the options apart — an
+     * answer to a question, where the pick is the thing being read.
+     */
+    variant?: "tint" | "solid";
+    /**
+     * A settled answer: the pick is shown, not offered. Unlike disabling every
+     * option it keeps full strength, so the answer still reads.
+     */
+    readOnly?: 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?: "top" | "right" | "bottom" | "left" | null | undefined;
+    side?: "bottom" | "left" | "right" | "top" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
 }
@@ -558,6 +696,26 @@ declare const Toaster: ({ ...props }: ToasterProps) => React$1.JSX.Element;
 
 declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): React$1.JSX.Element;
 
+/**
+ * Things laid out one after another, a set gap apart: a column (the default)
+ * or a row. The layout every screen and story otherwise writes by hand as
+ * `flex flex-col gap-4` — so the gaps come from one short scale, in `rem`, and
+ * follow the root as the type does.
+ *
+ * `gap` is the space between, never around: a stack draws no padding, border
+ * or background, so it can sit inside anything without changing its frame.
+ */
+declare const stackVariants: (props?: ({
+    direction?: "row" | "column" | null | undefined;
+    gap?: "none" | "xs" | "sm" | "lg" | "md" | "xl" | null | undefined;
+    align?: "end" | "start" | "center" | "stretch" | "baseline" | null | undefined;
+    justify?: "end" | "start" | "center" | "between" | null | undefined;
+    wrap?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StackProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stackVariants> {
+}
+declare const Stack: React$1.ForwardRefExoticComponent<StackProps & React$1.RefAttributes<HTMLDivElement>>;
+
 /**
  * The state of one thing, as a dot.
  *
@@ -577,7 +735,7 @@ declare function Spinner({ className, ...props }: React.ComponentProps<"svg">):
  * `motion-reduce` variant below honours by design.
  */
 declare const statusDotVariants: (props?: ({
-    tone?: "success" | "warning" | "info" | "muted" | "error" | "running" | "queued" | null | undefined;
+    tone?: "info" | "success" | "warning" | "muted" | "error" | "running" | "queued" | null | undefined;
     size?: "xs" | "sm" | "lg" | "md" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface StatusDotProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children">, VariantProps<typeof statusDotVariants> {
@@ -591,8 +749,51 @@ interface StatusDotProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "
 }
 declare const StatusDot: React$1.ForwardRefExoticComponent<StatusDotProps & React$1.RefAttributes<HTMLSpanElement>>;
 
+declare const statusIconVariants: (props?: ({
+    state?: "alert" | "success" | "error" | "waiting" | "running" | "queued" | "question" | "cancelled" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type StatusIconState = "success" | "error" | "running" | "queued" | "waiting" | "question" | "alert" | "cancelled";
+interface StatusIconProps extends Omit<React$1.SVGAttributes<SVGSVGElement>, "children">, VariantProps<typeof statusIconVariants> {
+    state: StatusIconState;
+    /**
+     * What this state is called — the accessible name and the tooltip.
+     *
+     * Pass it whenever the glyph stands alone, which is the reason to use one.
+     */
+    label?: string;
+}
+declare const StatusIcon: React$1.ForwardRefExoticComponent<StatusIconProps & React$1.RefAttributes<SVGSVGElement>>;
+
+/**
+ * How much room a row gets. The type size never moves — a row is the root size
+ * at every density — only the height and the cell padding do.
+ *
+ * - `compact` — the control scale's `sm`, 26px: a journal, a trace, a
+ *   step's output, a log.
+ * - `default` — `md`, 32px: a list in an application.
+ * - `comfortable` — `lg`, 40px: a table standing alone on a page, a settings
+ *   list.
+ *
+ * The px are at a 13px root. Every density is a ratio of the root, like the
+ * type, so a site that sets a 16px root gets proportionally roomier rows.
+ */
+type TableDensity = "compact" | "default" | "comfortable";
 declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & {
-    density?: "default" | "compact";
+    density?: TableDensity;
+    /**
+     * No box, and nothing wasted on its outside: only the rules between rows
+     * are drawn, and the first and last columns sit flush with the text around
+     * the table. For a table inside a card, a panel or an answer, whose edge
+     * already frames it — a second border a few pixels in reads as a box
+     * inside a box.
+     */
+    seamless?: boolean;
+    /**
+     * Draw the box. Off for a wrapper that draws the box itself, as `DataTable`
+     * does. `seamless` draws no box either way.
+     */
+    bordered?: boolean;
 } & React$1.RefAttributes<HTMLTableElement>>;
 declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
 declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
@@ -639,6 +840,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.
  *
@@ -722,6 +955,168 @@ interface AgentChipProps extends React$1.HTMLAttributes<HTMLSpanElement>, Varian
  */
 declare const AgentChip: React$1.ForwardRefExoticComponent<AgentChipProps & React$1.RefAttributes<HTMLSpanElement>>;
 
+/** One published model, and what this session may do with it. */
+interface DataReachModel {
+    id: string;
+    /** `Accounts`, `Funding rounds`. */
+    name: string;
+    /**
+     * Records this session can see, after its slice — not the model's size.
+     * `null` or left out while the count is on its way.
+     */
+    records?: number | null;
+    /**
+     * What it may do — `["read"]`, `["read", "write"]` — or `"denied"`. An open
+     * vocabulary: a product that adds `export` passes it and it is written out.
+     */
+    access: string[] | "denied";
+    /** What the session's view of it is narrowed to — `time 2019 → now · axis announced_at`. */
+    slice?: React$1.ReactNode;
+}
+/** What a session can reach, summed: the models it may read and the records in them. */
+declare function summarizeReach(models: DataReachModel[]): {
+    readable: number;
+    total: number;
+    records: number;
+    counting: boolean;
+};
+/** `1.2M`, `84K` — how a record count is written where room is short. */
+declare const formatRecords: (n: number) => string;
+interface DataReachProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    models: DataReachModel[];
+    /**
+     * Ask for the denied models. Shown only when some are denied; it receives
+     * their ids. What a request does is the host's.
+     */
+    onRequestAccess?: (models: string[]) => void;
+}
+/**
+ * The data a session can reach: every published model, the records it can see
+ * in each, what it may do with them, and what its view is narrowed to.
+ *
+ * **Denied models are listed, muted, never left out.** What a session cannot
+ * see is what a bigger question would need, and a list of only what is open
+ * would make the agent look more capable than it is. A count still on its way
+ * says so (`counting…`) rather than drawing a zero.
+ *
+ * Counts are what *this session* sees after its slice — a model's full size
+ * would overstate what the agent can answer from.
+ */
+declare const DataReach: React$1.ForwardRefExoticComponent<DataReachProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * What of the Graph's data may accompany a call across the boundary.
+ *
+ * A **closed** set, because an open one is a list nobody can audit: a reader
+ * has to know that what is not named cannot be sent, and that only holds if the
+ * vocabulary is fixed.
+ */
+type EgressClass = "type_names" | "property_names" | "the_question" | "property_values" | "record_ids" | "aggregates" | "everything";
+interface EgressListProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The destination this governs — `llm/anthropic-prod/claude-opus-5`. */
+    to: string;
+    /** What may be sent. **Empty is the default and means nothing may.** */
+    classes?: EgressClass[];
+    /**
+     * What was actually withheld on a real crossing. Absent reads as a **rule**
+     * at rest; present reads as an **event** — see the note below.
+     */
+    cut?: EgressClass[];
+}
+/**
+ * Per destination: what may be sent, and what was cut.
+ *
+ * **Egress is declared per destination, on the rule that matched it.** A
+ * run-wide setting would have to be the strictest of its destinations, which is
+ * the least useful one — so this component is always about *one* address, and a
+ * surface showing several renders several.
+ *
+ * **Reading a thing and sending it are different permissions.** A query may
+ * filter on `Deal.revenue` while the value never enters a prompt — used to
+ * **compute**, not to **reason**. That is the distinction this list exists to
+ * make visible, and it is why `property_values` being absent is worth as much
+ * screen as the classes that are present.
+ *
+ * **`cut` is what makes it evidence rather than configuration.** The same
+ * component states the bound before a run and what the bound actually withheld
+ * after one; without `cut`, a reader cannot tell a rule that did work from a
+ * rule that never bit.
+ *
+ * An empty `classes` is drawn in words, because the lens default is `[]` and a
+ * blank row would read as *not configured* rather than *nothing may leave*.
+ */
+declare const EgressList: React$1.ForwardRefExoticComponent<EgressListProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface AgentHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** What the session is — its name, or a switcher that lists the others. */
+    title: React$1.ReactNode;
+    /** Who is answering — `Analyst`, `v2`, `sonnet-5.5`. */
+    agent?: {
+        name: string;
+        version?: string;
+        model?: string;
+    };
+    /** Where the session is — `running…`, `needs input (1)`, `idle`. `short` is said under 420px. */
+    status?: {
+        tone: NonNullable<StatusDotProps["tone"]>;
+        label: string;
+        short?: string;
+    };
+    /** At the end of the first line — a menu of the session's actions, a close. */
+    actions?: React$1.ReactNode;
+    /** The data the session can reach: the whole world it opened on, or an access group's share. */
+    access?: {
+        kind: "world" | "group";
+        label: string;
+        models?: DataReachModel[];
+    };
+    /** The lens the session reads through — `Funding watch`. */
+    lens?: string;
+    /** Tokens spent of the session's budget. Tokens, never money. */
+    budget?: {
+        used: number;
+        limit: number;
+    };
+    /** The rules it runs under: the strictest as the badge, every one in its popover. */
+    governance?: {
+        summary: string;
+        rules?: {
+            label: string;
+            value: string;
+        }[];
+        egress?: {
+            to: string;
+            classes?: EgressClass[];
+        }[];
+    };
+    /** The marks before the access, the lens and the governance badge. The kit ships no icons. */
+    icons?: {
+        world?: React$1.ReactNode;
+        group?: React$1.ReactNode;
+        lens?: React$1.ReactNode;
+        governance?: React$1.ReactNode;
+    };
+    /** Ask for the denied models — their ids. Shown in the data reach when some are denied. */
+    onRequestAccess?: (models: string[]) => void;
+    /** The host's settings, at a section — `data`, `governance`. Shown as a link in each popover. */
+    onOpenSettings?: (section: "data" | "governance") => void;
+}
+/**
+ * The header of an agent's session: who is answering and where it stands,
+ * then what it can reach and the rules it runs under.
+ *
+ * Line one is the session, the agent and its status, and the host's actions.
+ * Line two — drawn when any of it is given — is the data reach (opens every
+ * model, the records this session sees in each, and what it may do), the
+ * lens, the token budget and the governance badge (opens the rules and what
+ * may leave, per destination). Under 420px of its own width the second line
+ * keeps its marks and counts and drops the words.
+ *
+ * Plain props, no conversation: pass it as a `ChatSession`'s `header`, or
+ * over a run view or a board that shows the same session.
+ */
+declare const AgentHeader: React$1.ForwardRefExoticComponent<AgentHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+
 declare const stateVariants: (props?: ({
     tone?: "active" | "error" | "running" | "draft" | "review" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -734,7 +1129,7 @@ interface AppStatusBarProps extends React$1.HTMLAttributes<HTMLDivElement>, Vari
     end?: React$1.ReactNode;
 }
 /**
- * The 25px line at the bottom of the window.
+ * The `sm` line at the bottom of the window — a control's height.
  *
  * It describes the **session**, not the screen: what is loaded, what state it
  * is in, which build is running. That is why it barely changes as you navigate
@@ -748,106 +1143,70 @@ interface AppStatusBarProps extends React$1.HTMLAttributes<HTMLDivElement>, Vari
  */
 declare const AppStatusBar: React$1.ForwardRefExoticComponent<AppStatusBarProps & React$1.RefAttributes<HTMLDivElement>>;
 
-/**
- * TODO — provisional. Built ahead of its design review.
- *
- * The chart set was deliberately deferred while the rest of the kit was built,
- * because charts are the one group with a real design question in them rather
- * than a markup question: which forms this product actually needs, at what
- * sizes, and how much a 330px drawer can carry. This component satisfies the
- * dataviz rules and the validated palette, but the *form inventory* has not been
- * agreed — treat the API as unsettled until a board screen uses it in anger.
- */
-
-interface BarDatum {
-    label: React$1.ReactNode;
-    value: number;
+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;
     /**
-     * Overrides the series colour for this bar. Use a data-palette token
-     * (`var(--color-data-3)`) when the bar's identity is an entity — a node type,
-     * a theme — so it matches that entity everywhere else it appears.
+     * **The address.** The same bytes produced twice are one artifact, so the
+     * digest — eight characters, mono — is what a reader quotes, not the name.
      */
-    color?: string;
-    /** What the tip should read, if not the raw value. */
-    display?: React$1.ReactNode;
+    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;
+    /** A glyph before the name, in `list` — the file's type. Passed in: the kit ships no icon set. */
+    icon?: React$1.ReactNode;
 }
-interface BarChartHProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
-    data: BarDatum[];
-    /** Fixes the scale. Defaults to the largest value present. */
-    max?: number;
-    /** Width of the label column, so bars start on the same x. */
-    labelWidth?: number;
-    /** Series colour when a datum does not override it. */
-    color?: string;
-    /** Names what is plotted. A single series needs no legend when this is set. */
-    caption?: React$1.ReactNode;
+interface ArtifactTableProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    files: Artifact[];
+    /**
+     * `table` (default) — the step's full record: header, kind, written, and an
+     * Open / Download per row. `list` — name, size and digest in bare rows, for
+     * the files an answer hands over, where the header and buttons would
+     * outweigh two or three names.
+     */
+    variant?: "table" | "list";
+    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;
 }
 /**
- * Magnitude across a handful of named things.
+ * The files a step left behind.
  *
- * Horizontal because the labels are words — a stock, a pattern, a theme — and
- * words read badly rotated under a column. Bars grow from a single baseline on
- * the left, so length is the only thing carrying the value.
+ * 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.
  *
- * One series, so there is no legend: `caption` names what is plotted. Every bar
- * is directly labelled at its tip, which is also what discharges the light-mode
- * contrast obligation on the data palette — identity and value are never
- * carried by hue alone.
- */
-declare const BarChartH: React$1.ForwardRefExoticComponent<BarChartHProps & React$1.RefAttributes<HTMLDivElement>>;
-
-/**
- * TODO — provisional. Built ahead of its design review.
+ * Rejected records are a file like any other. That is what makes `18 rejected`
+ * something a person can open instead of a dead count.
  *
- * The chart set was deliberately deferred while the rest of the kit was built,
- * because charts are the one group with a real design question in them rather
- * than a markup question: which forms this product actually needs, at what
- * sizes, and how much a 330px drawer can carry. This component satisfies the
- * dataviz rules and the validated palette, but the *form inventory* has not been
- * agreed — treat the API as unsettled until a board screen uses it in anger.
+ * **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.
  */
-
-interface ColumnDatum {
-    /** The period — `wk 36`. */
-    label: React$1.ReactNode;
-    /** A second line under the label — `1–5 Sep`. */
-    sublabel?: React$1.ReactNode;
-    value: number;
-    display?: React$1.ReactNode;
-}
-interface BarChartVProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
-    data: ColumnDatum[];
-    /** Fixes the scale. Defaults to the largest value present. */
-    max?: number;
-    /** Values to draw a hairline at — `[50, 75, 100]`. */
-    gridlines?: number[];
-    height?: number;
-    color?: string;
-    /** Colour for the column the story is about. Defaults to `color`. */
-    highlightColor?: string;
-    /** Which column carries the emphasis — usually the most recent. */
-    highlightIndex?: number;
-    /**
-     * Which columns get a value on the cap.
-     *
-     * `last` by default. A number on every column stops being a label and becomes
-     * texture; the gridlines carry the rest.
-     */
-    labelMode?: "last" | "all" | "none";
-    caption?: React$1.ReactNode;
+declare const ArtifactTable: React$1.ForwardRefExoticComponent<ArtifactTableProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ArtifactCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    file: Artifact;
+    /** The line under the name — `48 KB · kept for 7 days`, `412 rows · missing store code`. */
+    note?: React$1.ReactNode;
+    /** At the right — a `Download` button, or a tag saying what the file is. */
+    aside?: React$1.ReactNode;
 }
 /**
- * One measure over a few periods.
- *
- * Vertical because the x-axis is time and time reads left to right. Columns are
- * capped at 24px and separated by real gaps, so the band's leftover is air
- * rather than a fatter bar.
- *
- * `labelMode` defaults to `last`: the current period is the one being asked
- * about, and the gridlines carry the others. One series, so no legend —
- * `caption` says what is plotted.
+ * One file, as the whole of what an answer hands over: its type, its name,
+ * what it holds and what to do with it. Several files are an `ArtifactTable`.
  */
-declare const BarChartV: React$1.ForwardRefExoticComponent<BarChartVProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ArtifactCard: React$1.ForwardRefExoticComponent<ArtifactCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
 /**
  * The capabilities Invana ships today — **suggestions, not a limit.**
@@ -938,6 +1297,11 @@ interface CannotAnswerCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
     remedy?: React$1.ReactNode;
     /** Overrides the label. Defaults to `cannot answer`. */
     label?: React$1.ReactNode;
+    /**
+     * `info` for an answer given in part: the card says which part the data
+     * does not hold, above the answer that covers the rest.
+     */
+    tone?: "default" | "info";
 }
 /**
  * The graph does not hold what was asked.
@@ -963,7 +1327,7 @@ declare const CannotAnswerCard: React$1.ForwardRefExoticComponent<CannotAnswerCa
  *
  * `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`.
+ * knows that — the surface that draws the layers says so.
  */
 type KnownLayer = "graph_data" | "llm" | "third_party" | "cache" | "human" | "agent";
 /**
@@ -1065,7 +1429,7 @@ interface LayerChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "
 /**
  * One class of participant, as a swatch and a name.
  *
- * It heads a `LayerSection`, bands a run's `LayerStrip`, and counts a layer in
+ * It heads a `LayerSection`, names a layer's row in a run's `Gantt`, and counts a layer in
  * the Worlds drawer — everywhere a reader has to know *what kind of thing this
  * is* before reading which one.
  *
@@ -1171,6 +1535,8 @@ interface CastTableProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "c
      */
     resolved?: CastResolution[];
     readOnly?: boolean;
+    /** Passed to the table: no box, outer columns flush — for a cast inside a panel. */
+    seamless?: boolean;
 }
 /**
  * `role → resolves to → why this one`, four fixed rows.
@@ -1193,6 +1559,30 @@ interface CastTableProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "c
  */
 declare const CastTable: React$1.ForwardRefExoticComponent<CastTableProps & React$1.RefAttributes<HTMLDivElement>>;
 
+interface CaveatNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** The kind of caveat, one word — `indicative`, `association`, `simulation`. */
+    label: React$1.ReactNode;
+    /** What was excluded, imputed or assumed, and how far to trust the figure. */
+    children?: React$1.ReactNode;
+    /**
+     * `warning` (the default) qualifies the figure. `info` says what was filled
+     * in rather than measured; `destructive` says the data itself is wrong or late.
+     */
+    tone?: "warning" | "info" | "destructive";
+    /** A link after the text, to what the caveat is about — `Show the 4 stores`. */
+    action?: React$1.ReactNode;
+    onAction?: () => void;
+}
+/**
+ * How far to trust the figure above it.
+ *
+ * What was excluded, imputed or assumed, said beside the answer rather than
+ * in a footnote, and labelled with its kind so a reader scanning several
+ * answers can tell an association from a simulation at a glance. Tinted, not
+ * bordered: it qualifies the answer, it is not an error.
+ */
+declare const CaveatNote: React$1.ForwardRefExoticComponent<CaveatNoteProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface ChatSessionProps {
     /** The message list — typically `<ChatSessionMessage />` nodes. */
     children?: React$1.ReactNode;
@@ -1221,6 +1611,8 @@ interface ChatSessionProps {
  * ResizeObserver watches the message column), but only while the user is already
  * near the bottom — scroll up to read history and the view stays put. Layout and
  * scroll behaviour only; it owns no session state.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSession({ children, footer, emptyState, autoScrollKey, followThreshold, className, bodyClassName, }: ChatSessionProps): React$1.JSX.Element;
 
@@ -1258,6 +1650,8 @@ interface ChatSessionMessageProps {
  *
  * Presentational only — no data fetching or state — so it composes over any
  * backend.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionMessage({ role, children, status, icon, meta, actions, footer, className, }: ChatSessionMessageProps): React$1.JSX.Element;
 
@@ -1293,6 +1687,8 @@ interface ChatSessionMessageOptionsProps {
  *
  * Purely presentational and icon-agnostic: you supply the icons and handlers, so
  * it slots into any backend.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionMessageOptions({ actions, className, }: ChatSessionMessageOptionsProps): React$1.JSX.Element;
 
@@ -1333,6 +1729,8 @@ interface ChatSessionComposerProps {
  * Deliberately dependency-free — no query-language editor or provider selects
  * are baked in. Drop your own controls into `toolbarStart` / `toolbarEnd` (and
  * a QL editor into a custom layout if you need one).
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionComposer({ value, onChange, onSend, onStop, isRunning, disabled, placeholder, toolbarStart, toolbarEnd, attachments, sendIcon, stopIcon, sendDisabled, className, textareaClassName, }: ChatSessionComposerProps): React$1.JSX.Element;
 
@@ -1341,6 +1739,8 @@ declare function ChatSessionComposer({ value, onChange, onSend, onStop, isRunnin
  * status dot, prompt caret, spinner — occupies this fixed-width column so all
  * body text starts on one left edge ({@link ChatSessionPromptRow},
  * {@link ChatSessionProgressLine} and this row all use it).
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare const chatSessionGutterClass = "w-3.5 shrink-0 flex justify-center";
 /**
@@ -1372,6 +1772,8 @@ interface ChatSessionActivityRowProps {
  * `actions` for the re-run / view-query / copy / vote toolbar.
  *
  * Presentational only — no data fetching or state.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionActivityRow({ status, marker, children, actions, meta, footer, className, }: ChatSessionActivityRowProps): React$1.JSX.Element;
 interface ChatSessionActivitySubLineProps {
@@ -1384,6 +1786,8 @@ interface ChatSessionActivitySubLineProps {
  * An indented detail line under an activity row — "└ Backgrounded agent
  * (↓ to manage)", an interruption note, a one-line result. Render inside the
  * row's `footer` (or directly after the body in `children`).
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionActivitySubLine({ elbow, children, className, }: ChatSessionActivitySubLineProps): React$1.JSX.Element;
 
@@ -1404,6 +1808,8 @@ interface ChatSessionPromptRowProps {
  * Full bleed assumes the default `ChatSession` body padding (`p-3`) — the
  * negative margins here cancel it. If you override `bodyClassName` with a
  * different horizontal padding, pass matching `-mx-*`/`px-*` via `className`.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionPromptRow({ children, caret, meta, className, }: ChatSessionPromptRowProps): React$1.JSX.Element;
 
@@ -1420,6 +1826,8 @@ interface ChatSessionProgressLineProps {
  * A transient "work in flight" line in the transcript — spinner in the shared
  * gutter, label, and an optional right-aligned elapsed readout. Replace it with
  * a settled {@link ChatSessionActivityRow} when the run finishes.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionProgressLine({ children, spinner, elapsed, className, }: ChatSessionProgressLineProps): React$1.JSX.Element;
 
@@ -1435,6 +1843,13 @@ interface ChatSessionDisclosureProps {
     /** Uncontrolled initial state. Defaults to closed. */
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
+    /**
+     * `card` (default) is a bordered block under an activity row. `inline` is a
+     * bare line inside an answer — `▸ method` with its meta at the right in mono —
+     * that opens onto a preformatted code block when its content is text, or onto
+     * the content as given — code, the facts under it, a list of steps — when not.
+     */
+    variant?: "card" | "inline";
     /** Custom chevron node; the default "▸" rotates when open. */
     chevron?: React$1.ReactNode;
     className?: string;
@@ -1448,8 +1863,30 @@ interface ChatSessionDisclosureProps {
  * `overflow-x-auto` body, matching the transcript's nested-detail grammar.
  *
  * Controlled (`open` + `onOpenChange`) or uncontrolled (`defaultOpen`).
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
+ */
+declare function ChatSessionDisclosure({ label, meta, children, open, defaultOpen, onOpenChange, variant, chevron, className, contentClassName, }: ChatSessionDisclosureProps): React$1.JSX.Element;
+/**
+ * The code an inline disclosure opens onto, when it opens onto more than code:
+ * a query, a formula, a model. `<strong>` inside marks its keywords.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
+ */
+declare function ChatSessionDisclosureCode({ className, ...props }: React$1.HTMLAttributes<HTMLPreElement>): React$1.JSX.Element;
+interface ChatSessionDisclosureStepsProps extends React$1.OlHTMLAttributes<HTMLOListElement> {
+    /** Each step in the order it ran, with its count or time at the right. */
+    steps: {
+        label: React$1.ReactNode;
+        detail?: React$1.ReactNode;
+    }[];
+}
+/**
+ * A method of several steps, numbered in the order they ran.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
-declare function ChatSessionDisclosure({ label, meta, children, open, defaultOpen, onOpenChange, chevron, className, contentClassName, }: ChatSessionDisclosureProps): React$1.JSX.Element;
+declare function ChatSessionDisclosureSteps({ steps, className, ...props }: ChatSessionDisclosureStepsProps): React$1.JSX.Element;
 
 /**
  * Lifecycle of a background task / session. Mapped to the status tokens from
@@ -1475,7 +1912,9 @@ interface ChatSessionTaskRowProps {
 /**
  * One background task / agent / session: status dot, bold name, truncating
  * description, right-aligned meta. Used both in the pinned strip under a
- * transcript and in the grouped task dashboard ({@link ChatSessionTaskGroup}).
+ * transcript and in the grouped task board ({@link ChatSessionTaskGroup}).
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionTaskRow({ status, indicator, name, description, meta, onClick, className, }: ChatSessionTaskRowProps): React$1.JSX.Element;
 interface ChatSessionTaskGroupProps {
@@ -1487,7 +1926,9 @@ interface ChatSessionTaskGroupProps {
 }
 /**
  * A titled section of task rows — the "Needs input" / "Completed" groups of a
- * session dashboard.
+ * session board.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionTaskGroup({ heading, children, className, }: ChatSessionTaskGroupProps): React$1.JSX.Element;
 
@@ -1502,6 +1943,8 @@ interface ChatSessionStatusBarProps {
  * The slim bar under a chat session's composer — mode indicator, view
  * switches, agent counts, keyboard hints. Two slots, muted by default; put
  * interactive elements (buttons, toggles) straight into the slots.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionStatusBar({ start, end, className, }: ChatSessionStatusBarProps): React$1.JSX.Element;
 
@@ -1525,19 +1968,46 @@ interface ChatSessionContextChipProps extends React$1.HTMLAttributes<HTMLDivElem
  *
  * It states the binding in words. A highlight on the canvas alone would leave
  * the reader guessing what scope their question has.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare function ChatSessionContextChip({ icon, onDismiss, dismissLabel, className, children, ...props }: ChatSessionContextChipProps): React$1.JSX.Element;
 
+/**
+ * The cursor at the end of text that is still being written. A block, not a
+ * bar: it reads as the place the next word lands.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
+ */
+declare function ChatSessionCaret({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
+
 interface CitationRowProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "children"> {
     /** What kind of record this is — `Article`, `Bar`, `Event`. */
-    kind: React$1.ReactNode;
+    kind?: React$1.ReactNode;
+    /**
+     * The number an answer cites it by — `1` renders as `[1]`. Numbered rows are
+     * how an answer's markers are resolved, so the number leads the row.
+     */
+    marker?: React$1.ReactNode;
     /** The record itself, in the words it was stored with. */
     children?: React$1.ReactNode;
     /** Where it came from — the dataset, the publisher, the timestamp. */
     source?: React$1.ReactNode;
+    /** How many records it contributed — `3,406`, `5 days`. Mono, at the right. */
+    count?: React$1.ReactNode;
+    /** A second line under the record — what kind of source it is and how fresh: `table · loaded 28 Sep`. */
+    detail?: React$1.ReactNode;
+    /** The row the reader is on — the one a lit marker in the prose points to. */
+    active?: boolean;
 }
 interface CitationListProps extends React$1.HTMLAttributes<HTMLUListElement> {
     children?: React$1.ReactNode;
+    /**
+     * A line under the sources. `warning` when it says the answer rests on no
+     * records — which is said out loud, never left for the zeros to imply.
+     */
+    note?: React$1.ReactNode;
+    noteTone?: "muted" | "warning";
 }
 /**
  * The records an answer rests on.
@@ -1593,21 +2063,56 @@ interface ClarifyOption {
     detail?: React$1.ReactNode;
     disabled?: boolean;
 }
+/**
+ * Where the ask is in its life. `pending` waits on the reader; the rest are
+ * settled and read-only. Open: a surface may name its own.
+ */
+type ClarifyState = "pending" | "answered" | "skipped" | "superseded" | "expired" | (string & {});
 interface ClarifyCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** @default "pending" */
+    state?: ClarifyState;
+    /** The header's word while the ask waits — `confirm` for a yes-or-no. @default "question" */
+    kind?: React$1.ReactNode;
     /** Which step asked — `understand`. */
     step?: React$1.ReactNode;
     /** How long it has been waiting — `parked 14 min`. */
     waiting?: React$1.ReactNode;
+    /** When it settled — `just now`, `2 min ago`. At the header's right, after `waiting`. */
+    time?: React$1.ReactNode;
     /** The question. One sentence. */
-    question: React$1.ReactNode;
-    options: ClarifyOption[];
+    question?: React$1.ReactNode;
+    /** The choices, as one Questionnaire item. Ignored when `children` is given. */
+    options?: ClarifyOption[];
     value?: string;
     onSelect?: (value: string) => void;
-    /** The confirm control. */
-    actions?: React$1.ReactNode;
-    /** Why these options and not others. */
+    /**
+     * Any other control, in place of `options` — a `Questionnaire` of several
+     * steps, a form, a summary of the answers.
+     */
+    children?: React$1.ReactNode;
+    /** Why these options and not others, or where a default came from. */
     footnote?: React$1.ReactNode;
+    /** The confirm control. */
+    actions?: React$1.ReactNode;
+    /** Which edge the actions sit on. @default "start" */
+    actionsAlign?: "start" | "end";
+}
+interface ClarifyFootnoteProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+    children?: React$1.ReactNode;
 }
+/** The line under an ask: why these options, or where a default came from. *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
+ */
+declare const ClarifyFootnote: React$1.ForwardRefExoticComponent<ClarifyFootnoteProps & React$1.RefAttributes<HTMLParagraphElement>>;
+interface ClarifyActionsProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Which edge the actions sit on. @default "start" */
+    align?: "start" | "end";
+    children?: React$1.ReactNode;
+}
+/** The row of controls that answers, skips or changes an ask. *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
+ */
+declare const ClarifyActions: React$1.ForwardRefExoticComponent<ClarifyActionsProps & React$1.RefAttributes<HTMLDivElement>>;
 /**
  * The run stopped and asked, rather than guessing.
  *
@@ -1620,6 +2125,14 @@ interface ClarifyCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
  * holds, which is why `detail` exists and why `footnote` is worth saying out
  * loud. A card that offered invented options would undo the grounding the rest
  * of the system is built on.
+ *
+ * **One card through the ask's whole life.** `pending` offers the choice; once
+ * `answered`, `skipped`, `superseded` or `expired` the header says so and the
+ * body is read-only. The body is `options` for a choice, or any control passed
+ * as `children` — a `Questionnaire` of several steps (with its progress and
+ * Skip / Next), a form, or the answers of a finished multi-step ask.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare const ClarifyCard: React$1.ForwardRefExoticComponent<ClarifyCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
@@ -1638,7 +2151,8 @@ interface ContextBarProps extends React$1.HTMLAttributes<HTMLDivElement> {
     hint?: React$1.ReactNode;
 }
 /**
- * The 28px bar between a panel and the status bar.
+ * The `sm` bar between a panel and the status bar — a control's height, so
+ * it lines up with the controls it sits beside.
  *
  * It answers "where am I, and what is true right now" — the view switch, the
  * counts that matter for the work in front of you, and the shortcut that
@@ -1702,100 +2216,19 @@ interface DiffListProps extends React$1.HTMLAttributes<HTMLUListElement> {
 declare const DiffList: React$1.ForwardRefExoticComponent<DiffListProps & React$1.RefAttributes<HTMLUListElement>>;
 declare const DiffRow: React$1.ForwardRefExoticComponent<DiffRowProps & React$1.RefAttributes<HTMLLIElement>>;
 
-/**
- * TODO — provisional. Built ahead of its design review.
- *
- * The chart set was deliberately deferred while the rest of the kit was built,
- * because charts are the one group with a real design question in them rather
- * than a markup question: which forms this product actually needs, at what
- * sizes, and how much a 330px drawer can carry. This component satisfies the
- * dataviz rules and the validated palette, but the *form inventory* has not been
- * agreed — treat the API as unsettled until a board screen uses it in anger.
- */
-
-interface DivergingDatum {
-    label: React$1.ReactNode;
-    /** Signed. The sign is the whole point of this chart. */
-    value: number;
-    display?: React$1.ReactNode;
-}
-interface DivergingBarProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
-    data: DivergingDatum[];
-    /** Fixes the scale on both sides. Defaults to the largest magnitude present. */
-    max?: number;
-    labelWidth?: number;
-    /** Above the midpoint. Defaults to `--color-success`. */
-    positiveColor?: string;
-    /** Below it. Defaults to `--color-destructive`. */
-    negativeColor?: string;
-    caption?: React$1.ReactNode;
-}
-/**
- * Polarity — how far either side of zero.
- *
- * A net learning weight, a delta against a baseline, a sentiment score. The
- * midpoint is a real zero line, drawn in the neutral border colour, and both
- * sides share one scale so a `−9` is visibly longer than a `+6`.
- *
- * The poles use the **status** colours rather than data-palette hues, because
- * this chart's two directions are good and bad, not two categories. That is the
- * one place status colour belongs on a chart — it is encoding valence, not
- * identity, so it is never "series 1 and series 2". Every bar is directly
- * labelled, so the sign is readable without seeing colour at all.
- */
-declare const DivergingBar: React$1.ForwardRefExoticComponent<DivergingBarProps & React$1.RefAttributes<HTMLDivElement>>;
-
-/**
- * What of the Graph's data may accompany a call across the boundary.
- *
- * A **closed** set, because an open one is a list nobody can audit: a reader
- * has to know that what is not named cannot be sent, and that only holds if the
- * vocabulary is fixed.
- */
-type EgressClass = "type_names" | "property_names" | "the_question" | "property_values" | "record_ids" | "aggregates" | "everything";
-interface EgressListProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
-    /** The destination this governs — `llm/anthropic-prod/claude-opus-5`. */
-    to: string;
-    /** What may be sent. **Empty is the default and means nothing may.** */
-    classes?: EgressClass[];
-    /**
-     * What was actually withheld on a real crossing. Absent reads as a **rule**
-     * at rest; present reads as an **event** — see the note below.
-     */
-    cut?: EgressClass[];
-}
-/**
- * Per destination: what may be sent, and what was cut.
- *
- * **Egress is declared per destination, on the rule that matched it.** A
- * run-wide setting would have to be the strictest of its destinations, which is
- * the least useful one — so this component is always about *one* address, and a
- * surface showing several renders several.
- *
- * **Reading a thing and sending it are different permissions.** A query may
- * filter on `Deal.revenue` while the value never enters a prompt — used to
- * **compute**, not to **reason**. That is the distinction this list exists to
- * make visible, and it is why `property_values` being absent is worth as much
- * screen as the classes that are present.
- *
- * **`cut` is what makes it evidence rather than configuration.** The same
- * component states the bound before a run and what the bound actually withheld
- * after one; without `cut`, a reader cannot tell a rule that did work from a
- * rule that never bit.
- *
- * An empty `classes` is drawn in words, because the lens default is `[]` and a
- * blank row would read as *not configured* rather than *nothing may leave*.
- */
-declare const EgressList: React$1.ForwardRefExoticComponent<EgressListProps & React$1.RefAttributes<HTMLDivElement>>;
-
 /**
  * How an answer's records are rendered. A kind is a *body inside* the emission
  * card, never a block of its own (DS9) — so this names the body, it does not
  * pick a different container.
+ *
+ * Open: the names below are the common ones, and an assistant answer labels
+ * its card in the grammar's own words — `ranked`, `scenario`, `model check`.
  */
-type EmissionKind = "metric" | "table" | "chart" | "subgraph" | "prose" | "empty" | "html";
-interface EmissionHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+type EmissionKind = "metric" | "table" | "chart" | "subgraph" | "prose" | "empty" | "html" | (string & {});
+interface EmissionHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
     kind: EmissionKind;
+    /** What the card shows, in words — `Apex Components, weekly lead time`. */
+    title?: React$1.ReactNode;
     /** The projection template that rendered it — `table-compact@3`. Shown in mono. */
     template?: React$1.ReactNode;
     /**
@@ -1812,6 +2245,7 @@ interface EmissionHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
     actions?: React$1.ReactNode;
 }
 interface EmissionCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title">, Omit<EmissionHeaderProps, keyof React$1.HTMLAttributes<HTMLDivElement>> {
+    title?: React$1.ReactNode;
     /** Set false to render the body alone, where a surface supplies its own header. */
     showHeader?: boolean;
     children?: React$1.ReactNode;
@@ -1823,6 +2257,8 @@ interface EmissionCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
  * result, a scheduled answer (DS7). It is exported on its own so a surface that
  * already owns its container can still show the same header rather than
  * inventing a second one that drifts.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare const EmissionHeader: React$1.ForwardRefExoticComponent<EmissionHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
 /**
@@ -1837,11 +2273,21 @@ declare const EmissionHeader: React$1.ForwardRefExoticComponent<EmissionHeaderPr
  * object (DS6). It does not know what an Observation is, and it does not fetch,
  * re-render or re-query anything; switching templates is the caller's job,
  * handed in through `actions`.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare const EmissionCard: React$1.ForwardRefExoticComponent<EmissionCardProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * The card's body: its blocks in one padded column, each a step apart.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
+ */
+declare const EmissionBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
 /**
  * The `prose` body's citation marker — the superscript that ties a clause to
- * the records behind it.
+ * the records behind it. Set `data-active` while its source is the one in view.
+ *
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
 declare const CitationMarker: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLElement> & React$1.RefAttributes<HTMLElement>>;
 
@@ -1875,21 +2321,81 @@ declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & Re
 /** One not-yet-available surface, and the condition that opens it. */
 declare const EmptyStateLock: React$1.ForwardRefExoticComponent<EmptyStateLockProps & React$1.RefAttributes<HTMLSpanElement>>;
 
-declare class ErrorBoundary extends Component<{
+interface ErrorBoundaryProps {
     children: ReactNode;
-}, {
+    /**
+     * Called once for each error the boundary catches, with React's component
+     * stack — where an app reports the error (a log, a counter). The boundary
+     * still shows its fallback; this only observes.
+     */
+    onError?: (error: Error, info: ErrorInfo) => void;
+    /** What to show instead of the children once they have thrown. Defaults to a short notice. */
+    fallback?: ReactNode;
+}
+/**
+ * Catches a render error in its children and shows a fallback in their place,
+ * so one broken region does not blank the whole screen.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * <ErrorBoundary onError={(error) => report(error)}>
+ *   <Region />
+ * </ErrorBoundary>
+ * ```
+ *
+ * `onError` is how an app learns what broke; without it the error goes to the
+ * console only.
+ */
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, {
     hasError: boolean;
 }> {
-    constructor(props: {
-        children: ReactNode;
-    });
-    static getDerivedStateFromError(_: Error): {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(): {
         hasError: boolean;
     };
-    componentDidCatch(error: Error, errorInfo: any): void;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
     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
@@ -1925,6 +2431,18 @@ interface EyebrowProps extends React$1.HTMLAttributes<HTMLDivElement> {
  */
 declare const Eyebrow: React$1.ForwardRefExoticComponent<EyebrowProps & React$1.RefAttributes<HTMLDivElement>>;
 
+interface ExpandToggleProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    open: boolean;
+    /** What opens — `fetch_filings` — read as `Open fetch_filings` / `Close fetch_filings`. */
+    label?: string;
+}
+declare function Spacer({ className }: {
+    className?: string;
+}): React$1.JSX.Element;
+declare const ExpandToggle: React$1.ForwardRefExoticComponent<ExpandToggleProps & React$1.RefAttributes<HTMLButtonElement>> & {
+    Spacer: typeof Spacer;
+};
+
 interface FilterBarProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** The filter controls. `FilterChip`s, a `SearchInput`, a toggle. */
     children?: React$1.ReactNode;
@@ -1935,6 +2453,12 @@ interface FilterBarProps extends React$1.HTMLAttributes<HTMLDivElement> {
      * filters ask, so it belongs on the same line as them and nowhere else.
      */
     summary?: React$1.ReactNode;
+    /**
+     * No rule under it and no padding at its ends: whatever holds it is the
+     * frame — a table's border under it, the table's edges either side. Off by
+     * default, so a bar over a bare list keeps the rule that divides the two.
+     */
+    seamless?: boolean;
 }
 interface FilterChipProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "value"> {
     /** The dimension — `status`, `kind`, `agent`, `age`. */
@@ -1943,6 +2467,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.
@@ -1957,62 +2493,102 @@ declare const FilterBar: React$1.ForwardRefExoticComponent<FilterBarProps & Reac
 /**
  * One dimension, as a chip that opens a menu.
  *
- * The caret is drawn rather than iconised so the chip stays 22px and reads as
- * one token — `status ▾` — instead of a control with an icon glued to it.
+ * The caret is drawn rather than iconised so the chip reads as
+ * one token — `status ▾` — instead of a control with an icon glued to it. It is
+ * a `sm` button: the control scale's 26px, the height of the `sm` search
+ * beside it.
  */
 declare const FilterChip: React$1.ForwardRefExoticComponent<FilterChipProps & React$1.RefAttributes<HTMLButtonElement>>;
+/** One choice in a {@link MultiFilterChip}: its value, or a value with a label. */
+type FilterChipOption = string | {
+    value: string;
+    label?: React$1.ReactNode;
+};
+interface MultiFilterChipProps {
+    /** The dimension — `kind`, `agent`, `status`. */
+    label: React$1.ReactNode;
+    options: FilterChipOption[];
+    /** What it is narrowed to. Empty means "not filtered". */
+    value: string[];
+    onChange: (next: string[]) => void;
+    /**
+     * Many at once (the default) — a row matches any of them — or one, where
+     * picking a choice replaces the last and picking it again clears it.
+     */
+    multiple?: boolean;
+}
+/**
+ * A `FilterChip` with its menu: the choices for one dimension, checked as
+ * they narrow the list. The chip reads what it is set to — the value, or
+ * `3 selected` — and, once set, carries the × that clears it.
+ */
+declare function MultiFilterChip({ label, options, value, onChange, multiple, }: MultiFilterChipProps): React$1.JSX.Element;
 
+interface FloatingPanelProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** What the panel is — `Activity`, `Logs`. */
+    title: React$1.ReactNode;
+    /** Beside the title — a `live` dot, a count, a view switch. */
+    aside?: React$1.ReactNode;
+    /** Folded to its bar: the body is hidden and `summary` takes the title's room. */
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** What a folded panel still says — `● 3 · 4 layers`. */
+    summary?: React$1.ReactNode;
+    /** Shows a close control at the end of the bar. */
+    onClose?: () => void;
+    /** Under the body, above the edge — a total, a link out. */
+    footer?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    bodyClassName?: string;
+}
 /**
- * TODO — provisional. Built ahead of its design review.
+ * A panel that floats over the work — the run's activity, its log — rather
+ * than taking a split of it.
+ *
+ * It stays open over the work, so it is drawn as a card that is lifted — the
+ * card ground, a border and a shadow — and not as a popover, which is the
+ * ground of what opens and closes in a moment. Its bar is chrome, as every
+ * panel's header is.
+ *
+ * It sits **on** a canvas, so it can be folded to its bar and closed: a panel
+ * that could only be moved out of the way by resizing the work would be a
+ * split, and a split is `AppLayoutV2`'s. Folded, it keeps one line of what it
+ * would say, so folding it never hides that something is happening.
  *
- * The chart set was deliberately deferred while the rest of the kit was built,
- * because charts are the one group with a real design question in them rather
- * than a markup question: which forms this product actually needs, at what
- * sizes, and how much a 330px drawer can carry. This component satisfies the
- * dataviz rules and the validated palette, but the *form inventory* has not been
- * agreed — treat the API as unsettled until a board screen uses it in anger.
+ * Content-height up to its parent, then its body scrolls: two of these stacked
+ * in a column share the height between them.
  */
+declare const FloatingPanel: React$1.ForwardRefExoticComponent<FloatingPanelProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface HeatCell {
-    /** When this cell is — `09:45`. Used in the hover title. */
-    at: React$1.ReactNode;
-    /** Which state key this cell is in. Must exist in `states`. */
-    state: string;
-    /** Extra detail for the hover title — `2 names: BPCL, HINDPETRO`. */
-    detail?: React$1.ReactNode;
-}
-interface HeatState {
-    key: string;
-    /** What the state is called. Shown in the legend and the hover title. */
-    label: React$1.ReactNode;
-    color?: string;
-    /** Renders as a ring rather than a fill — for "nothing happened here". */
-    hollow?: boolean;
-}
-interface HeatStripProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
-    cells: HeatCell[];
-    states: HeatState[];
-    /** Axis ticks under the strip — `[{at: 0, label: '09'}, …]`. */
-    ticks?: {
-        at: number;
-        label: React$1.ReactNode;
-    }[];
-    cellSize?: number;
+/**
+ * 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;
 }
 /**
- * A run of firings, one square each, in time order.
+ * What kind of run this row is: `ask` · `import` · `bulk` · `stitch` · `enrich`.
  *
- * A schedule's day: twenty-one firings, most served, one skipped, one that could
- * not answer. The shape of the day is the point — a reader sees the run of green
- * and the one square that is not, without reading any of them.
+ * **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`.
  *
- * These are **status** colours, so they are reserved and never stand in for
- * categories. The legend is mandatory rather than optional: a square carries no
- * label of its own, so without the legend the strip would be colour-alone. Each
- * cell also names its state in the hover title, which is what a screen reader
- * and a keyboard user get.
+ * 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 HeatStrip: React$1.ForwardRefExoticComponent<HeatStripProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const KindChip: React$1.ForwardRefExoticComponent<KindChipProps & React$1.RefAttributes<HTMLSpanElement>>;
 
 interface LayerSectionProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
     layer: Layer;
@@ -2059,272 +2635,17 @@ interface LayerSectionProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
  */
 declare const LayerSection: React$1.ForwardRefExoticComponent<LayerSectionProps & React$1.RefAttributes<HTMLDivElement>>;
 
-/**
- * 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.
- *
- * 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.
- */
-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. */
-    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;
-}
-/**
- * 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;
-    /** 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;
-}
-/** A bounded repetition over a stretch of the axis — `loop · max 3`. */
-interface LayerBracket {
-    id: string;
-    start: number;
-    end: number;
-    label: string;
-}
-/**
- * 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;
-    /**
-     * 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;
-    /** 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;
-    /** 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: 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;
-    /**
-     * 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;
-}
-/** An unknown state is still a state: it says its own name. */
-declare const stateLabel: (state: LayerItemState) => string;
-/**
- * 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
- * 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"
+/** A filled square — a column or a bar. */
+ | "box"
+/** A dashed square outline — a plan or a target a column stands inside. */
+ | "outline" | "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
@@ -2360,35 +2681,135 @@ interface LegendProps extends React$1.HTMLAttributes<HTMLDivElement> {
 declare const Legend: React$1.ForwardRefExoticComponent<LegendProps & React$1.RefAttributes<HTMLDivElement>>;
 declare const LegendItem: React$1.ForwardRefExoticComponent<LegendItemProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface LensChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children" | "onClick"> {
+type TerminalLineKind = "prompt" | "output" | "comment";
+/**
+ * The severity a **log** line was emitted at, as the runtime recorded it.
+ *
+ * Distinct from `kind`, which says what part of a *transcript* a line is — a
+ * 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 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;
+    /**
+     * How loud this line is. Tints **one** cell — the one named by
+     * `levelColumn` — and nothing else.
+     *
+     * Only the level word is coloured, never the message: a wall of amber
+     * sentences is unreadable, and what a reader scans is the column, not the
+     * prose. Setting this also drops the `kind` marker — a log line is not a
+     * transcript line and does not want a `→` in front of it.
+     *
+     * The level **word** stays in `columns`. Colour is never the carrier.
+     */
+    level?: TerminalLevel;
     /**
-     * The lens in force. **`undefined` is a real, common state** and reads
-     * `Everything` — see below.
+     * Which cell of `columns` holds the level word. Defaults to `1`, because a
+     * log line reads `time · LEVEL · source · message` and the timestamp comes
+     * first in every log anyone has ever read.
      */
-    lens?: {
-        name: string;
-        kind?: "world" | "guardrail";
-    };
-    /** Open the picker. Absent leaves the chip as a statement. */
-    onPick?: () => void;
+    levelColumn?: number;
+    /**
+     * Columns, for the step-shaped output a run prints — name, detail, timing,
+     * result. Given as cells so they align down the transcript instead of each
+     * line padding itself with spaces.
+     */
+    columns?: React$1.ReactNode[];
+    children?: React$1.ReactNode;
+}
+interface TerminalProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    children?: React$1.ReactNode;
+    /** Shows a blinking block at the end. */
+    cursor?: boolean;
+    /**
+     * `grid-template-columns` for every columned line in this transcript.
+     *
+     * Set once here rather than per line, because the point of columns is that
+     * they line up *down* the transcript — a width chosen per row aligns nothing.
+     */
+    columnTemplate?: string;
+}
+/**
+ * A shell transcript, as a first-class surface.
+ *
+ * Some of this product's work happens outside Studio — imports run from the
+ * CLI, a scheduler calls the Python API — and the hand-off has to be shown
+ * honestly rather than redrawn as a wizard. So this renders what the terminal
+ * actually printed.
+ *
+ * It is presentational: a record of a run that already happened, not a live
+ * console. There is no input here, and it does not scroll itself.
+ */
+declare const Terminal: React$1.ForwardRefExoticComponent<TerminalProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TerminalLine: React$1.ForwardRefExoticComponent<TerminalLineProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/** One line of a run's log, as the runtime emitted it. */
+interface LogLine {
+    id?: string;
+    /** When, already worded — `10:42:01`. */
+    at: string;
+    level: TerminalLevel;
+    /** What emitted it — `graph.query`, `egress`. */
+    source?: string;
+    message: string;
+}
+/** How loud a line must be to show: everything, warnings and up, errors only. */
+type LogFloor = "all" | "warn" | "error";
+interface LogCardProps extends Omit<FloatingPanelProps, "title" | "children" | "summary" | "aside"> {
+    /** @default "Logs" */
+    title?: React$1.ReactNode;
+    /** Every line so far, oldest first. New lines are appended as they arrive. */
+    lines: LogLine[];
+    /** Lines are still arriving. */
+    live?: boolean;
+    /** Only lines from this source — a call opened in the activity panel. Controlled with `onSourceChange`. */
+    source?: string | null;
+    onSourceChange?: (source: string | null) => void;
+}
+/**
+ * The run's log, as it is written — in a panel that floats over the work.
+ *
+ * The raw record behind the activity panel: every line the runtime emitted,
+ * its level the one coloured word ({@link TerminalLine}). It follows new lines
+ * while live; **pausing freezes what is shown**, so a line can be read while
+ * the run keeps writing, and resuming catches up. Filter by how loud a line
+ * is, by words, or by the source a call wrote it from.
+ */
+declare const LogCard: React$1.ForwardRefExoticComponent<LogCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/** 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;
 }
 /**
- * Which world a run is being read under — the header's right-hand chip, and the
- * one on an agent's row.
+ * 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.
  *
- * **No lens reads `Everything`, never blank and never `None`.** A Graph that
- * sets no lens sees the whole global model, every configured provider and every
- * third party its agents are credentialed for: the widest state is the default,
- * and it is a *state*, not a missing value. `None` would suggest nothing is in
- * view, which is the exact opposite of what is true. `Everything` is also still
- * inside the guardrails, which is why a guardrail is not a lens you pick.
+ * **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.
  *
- * It is the smallest surface in Govern and the one most often on screen, so it
- * carries the name and nothing else. What that world narrows belongs in the
- * drawer the chip opens — a chip that listed its rules would be a rule list
- * that happened to be in a header.
+ * 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 LensChip: React$1.ForwardRefExoticComponent<LensChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const MarkChip: React$1.ForwardRefExoticComponent<MarkChipProps & React$1.RefAttributes<HTMLSpanElement>>;
 
 interface MatchCandidate {
     address: string;
@@ -2442,6 +2863,11 @@ interface MenuItem {
     onClick?: () => void;
     children?: MenuItem[];
 }
+/**
+ * A row of a menu; with `children`, a submenu that opens beside it. The submenu
+ * opens on hover and on focus, and from the keyboard: → or Enter opens it on its
+ * first row, ← or Escape closes it back to its row.
+ */
 declare const MenuItem: React$1.FC<MenuItemProps>;
 
 /**
@@ -2451,7 +2877,7 @@ 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 KnownMetricTone = "running" | "success" | "warning" | "error" | "info";
+type KnownMetricTone = "running" | "success" | "warning" | "error" | "info" | "muted";
 /**
  * The values the kit draws specially — **suggestions, not a limit.** Anything
  * else renders with the neutral token and its own name.
@@ -2466,6 +2892,11 @@ interface MetricTileProps extends React$1.HTMLAttributes<HTMLDivElement> {
     caption?: React$1.ReactNode;
     /** Tints the value. See {@link MetricTone} — most tiles should not set it. */
     tone?: MetricTone;
+    /**
+     * Tints the caption instead — for a caption that is a change, `▲ 8 d vs
+     * normal`, where the direction is the signal and the value is a plain figure.
+     */
+    captionTone?: MetricTone;
     /**
      * How much of a known ceiling has been spent, `0`–`1`, as a 4px bar under the
      * caption. Takes `tone`'s colour when one is set.
@@ -2476,6 +2907,36 @@ interface MetricTileProps extends React$1.HTMLAttributes<HTMLDivElement> {
      * a deadline that does not exist.
      */
     meter?: number;
+    /**
+     * The figure against a target, as a bar under it: `fill` is how far the
+     * figure has come and `mark` where the target sits, both `0`–`1` of the
+     * scale. `labels` writes the scale's start, the target and its end under it.
+     *
+     * Unlike `meter`, the target is a line the figure is read against, not a
+     * ceiling it spends — the fill may pass it.
+     */
+    gauge?: {
+        fill: number;
+        mark: number;
+        labels?: [React$1.ReactNode, React$1.ReactNode, React$1.ReactNode];
+    };
+    /**
+     * Set on the warning ground: the one tile in a band that needs a second look
+     * — a figure resting on too few records. Say why in a line under the band.
+     */
+    flagged?: boolean;
+    /** Beside the figure, at the right, bottom-aligned — a sparkline of its recent run. */
+    aside?: React$1.ReactNode;
+    /**
+     * `tile` is one of several, boxed, in a strip. `hero` is the one figure an
+     * answer turns on — the adjusted odds ratio, net revenue retention — set
+     * large on the surface it sits in: no box, the label in sentence case over
+     * it, the caption in mono under it, so it reads as a result, not a gauge.
+     * `figure` is one of a band of figures inside an answer — boxed like a tile
+     * but set like a small hero: the label in sentence case, the value in a
+     * larger sans, the caption in mono.
+     */
+    variant?: "tile" | "hero" | "figure";
     /** A sparkline, or anything else that sits under the value. */
     children?: React$1.ReactNode;
 }
@@ -2487,10 +2948,28 @@ interface MetricGridProps extends React$1.HTMLAttributes<HTMLDivElement> {
      *
      * It is a prop because a tile strip is usually one band of something larger,
      * and a grid that keeps its own tighter rhythm makes the whole surface read
-     * as two grids. A dashboard passes its own gap; a standalone strip keeps the
+     * as two grids. A board passes its own gap; a standalone strip keeps the
      * default.
      */
     gap?: number;
+    /**
+     * One strip, the tiles divided by rules instead of spaced apart — for a
+     * band of figures that belong to one answer and read left to right. `gap`
+     * is ignored.
+     */
+    joined?: boolean;
+    /**
+     * With `joined`: no box around the strip, and nothing wasted on its outside
+     * — only the rules between tiles are drawn, and the outer tiles sit flush
+     * with the text around the grid, as a seamless table's outer columns do.
+     * For a strip inside a card or an answer, whose edge already frames it.
+     */
+    seamless?: boolean;
+    /**
+     * A fixed number of columns instead of fitting to the width — for a band
+     * whose shape is part of what it says: three across, two by two.
+     */
+    columns?: number;
     children?: React$1.ReactNode;
 }
 /**
@@ -2530,6 +3009,12 @@ interface NavMenuItem {
     /** Draw a separator immediately above this row. */
     separatorBefore?: boolean;
     onSelect?: () => void;
+    /**
+     * A submenu: the row opens these beside it (hover, → or Enter; ← or Escape
+     * closes it). Its own `onSelect` is not called — the rows inside are the
+     * choices.
+     */
+    children?: NavMenuItem[];
 }
 /**
  * NavItemConfig - Shared configuration for a single navigation item, used by
@@ -2592,6 +3077,12 @@ interface NavItemConfig {
      * is why a tab strip could not be built on nav items before.
      */
     menuTrigger?: "item" | "caret";
+    /**
+     * Draws an inline `×` inside the item — a tab that is closed rather than
+     * managed. The body still selects; only the `×` closes. Like the caret, it
+     * makes the item host a button, so the item itself renders as a `<div>`.
+     */
+    onClose?: () => void;
     /**
      * A count pinned to the item's top-right — unread reviews, waiting questions.
      *
@@ -2608,11 +3099,11 @@ interface NavItemConfig {
 /**
  * The visual treatments a strip of nav items can wear.
  *
- * One table, because the kit draws all three and used to draw two of them by
- * hand in separate components. `nav` is what nav items have always looked
- * like; `underline` and `folder` are the two tab strips — a panel's views and
- * a workbook's pages — lifted out of `TabbedPanel` and
- * `CanvasPagesViewPanel` unchanged, so migrating those renders identically.
+ * One table, because the kit used to draw these by hand in separate
+ * components. `nav` is what nav items have always looked like; `underline` and
+ * `folder` are the two tab strips — a panel's views (`TabbedPanel`) and a
+ * workbook's pages (`Workbook`) — and `folder-bottom` is the workbook's strip
+ * under its pages.
  */
 declare const VARIANT: {
     /** The capsule: a filled, ringed chip. Toolbars, rails, header actions. */
@@ -2642,6 +3133,14 @@ declare const VARIANT: {
         readonly active: "mb-[-1px] rounded-t-md border border-b-0 border-primary text-primary";
         readonly strip: "items-stretch";
     };
+    /** The folder tab turned over, for a strip under its pages: open at the top, rounded below. */
+    readonly "folder-bottom": {
+        readonly item: "h-full rounded-none px-3 py-2 gap-1.5";
+        readonly hover: "hover:text-foreground";
+        readonly open: "data-[state=open]:text-foreground";
+        readonly active: "mt-[-1px] rounded-b-md border border-t-0 border-primary text-primary";
+        readonly strip: "items-stretch";
+    };
 };
 type NavItemsVariant = keyof typeof VARIANT;
 interface NavItemsProps {
@@ -2904,8 +3403,12 @@ interface NestedMenuProps {
 declare const NestedMenu: React__default.FC<NestedMenuProps>;
 
 interface PanelBoxProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
-    /** What this band is — `Input · what opened this run`, `result.json`, `Log`. */
-    title: React$1.ReactNode;
+    /**
+     * What this band is — `Input · what opened this run`, `result.json`, `Log`.
+     * Without one there is no label bar: the box still frames its content, which
+     * is how a band of figures sits on a board as it sits in an answer card.
+     */
+    title?: React$1.ReactNode;
     /**
      * The fact on the right of the header — `214 lines · tailing`, `rendered from
      * result.json`, a `<Badge>`, a count.
@@ -2924,9 +3427,10 @@ interface PanelBoxProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "ti
     bodyClassName?: string;
 }
 /**
- * One band of a dashboard: a bordered box with a label bar over it.
+ * One band of a board: a bordered box, with a label bar over it when it
+ * has a `title`.
  *
- * A dashboard is a scrolling column of these — tiles, then the flow, then
+ * A board is a scrolling column of these — tiles, then the flow, then
  * Input beside `result.json`, then the Log. Each box is **content-height and
  * owns no scroller**: the column scrolls, so a band that scrolled itself would
  * hide its own content behind a second bar.
@@ -2949,6 +3453,11 @@ interface PanelContentProps {
     title?: React__default.ReactNode;
     /** Header title as plain text, rendered in the default panel header style. */
     titleText?: string;
+    /**
+     * How many things the panel holds — `4`, `12 changed` — beside the title,
+     * muted. A fact about the panel, so always shown, unlike its actions.
+     */
+    count?: React__default.ReactNode;
     children?: React__default.ReactNode;
     /** Classes for the outer card. */
     className?: string;
@@ -2989,7 +3498,7 @@ interface PanelContentProps {
      */
     actionsOnHover?: boolean;
 }
-declare function PanelContent({ title, titleText, children, className, headerClassName, bodyClassName, footerContent, footerClassName, headerActions, actionsOnHover, }: PanelContentProps): React__default.JSX.Element;
+declare function PanelContent({ title, titleText, count, children, className, headerClassName, bodyClassName, footerContent, footerClassName, headerActions, actionsOnHover, }: PanelContentProps): React__default.JSX.Element;
 
 interface PanelStackSection {
     /** Unique identifier for the section within the stack. */
@@ -3006,6 +3515,12 @@ interface PanelStackSection {
     content: React$1.ReactNode;
     /** Optional leading icon component, shown before the title. */
     icon?: React$1.ElementType;
+    /**
+     * How many things the section holds — `4`, `12 changed` — beside the title,
+     * muted. A fact, not an action: always shown, even while the actions wait
+     * for hover, and while the section is collapsed.
+     */
+    count?: React$1.ReactNode;
     /**
      * Actions on the right of the title bar, as `NavHorizontal` items — the same
      * list `PanelContent` and `TabbedPanel` take, so a header is described once
@@ -3027,7 +3542,7 @@ interface PanelStackSection {
     /**
      * Keep `headerActions` hidden until the header is hovered or focused (or a
      * menu inside them is open) — VS Code's quiet view header. Defaults to
-     * `true`. Chrome that must always read, like a count, belongs in `title`.
+     * `true`. A count that must always read is `count`.
      */
     actionsOnHover?: boolean;
     /** Start the section collapsed (header only). Defaults to `false`. */
@@ -3125,12 +3640,65 @@ 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
      * starts on the same x — the reason to use this rather than a row of flexes.
+     * `"auto"` sizes the column to the widest label, for a short list of known
+     * labels such as the answers to an ask.
      */
-    labelWidth?: number | string;
+    labelWidth?: number | "auto" | (string & {});
+    /**
+     * `summary` sets the rows tight — a settled answer read at a glance, such as
+     * the values an ask was answered with, or a proposal's terms.
+     */
+    variant?: "default" | "summary";
     children?: React$1.ReactNode;
 }
 interface PropertyRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
@@ -3154,14 +3722,26 @@ declare const PropertyList: React$1.ForwardRefExoticComponent<PropertyListProps
 declare const PropertyRow: React$1.ForwardRefExoticComponent<PropertyRowProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface ProposalCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
-    /** What is being proposed — `Draft pattern`. */
-    title: React$1.ReactNode;
+    /** What is being proposed — `Draft pattern`. Left out when the frame around the card already says it. */
+    title?: React$1.ReactNode;
     /** Where it came from — `from the agent's result`. */
     source?: React$1.ReactNode;
     /** The draft itself. A `PropertyList`, usually. */
     children?: React$1.ReactNode;
+    /**
+     * The draft without its muted box — for a card whose frame is already its
+     * own, such as a proposal under an answer, where a box inside it is a box
+     * inside a box.
+     */
+    flush?: boolean;
     /** What the proposal rests on — the instances, as a table or list. */
     evidence?: React$1.ReactNode;
+    /**
+     * The evidence without its box — for evidence that is a `seamless` table or
+     * grid, drawing only the rules between its rows, whose edge the card's own
+     * frame already is.
+     */
+    seamless?: boolean;
     /** A heading for the evidence — `The six instances`. */
     evidenceTitle?: React$1.ReactNode;
     /** Scope of the evidence — `30 days`. */
@@ -3170,6 +3750,8 @@ interface ProposalCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
     consequence?: React$1.ReactNode;
     /** Author / reject / reassign. */
     actions?: React$1.ReactNode;
+    /** Written: what was made — `Alert created` — stamped above the draft. */
+    done?: React$1.ReactNode;
 }
 /**
  * An agent proposes; a person publishes.
@@ -3248,15 +3830,22 @@ interface RecordHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
     chips?: React$1.ReactNode;
     /** What you can do to it — prev/next, a view switch, buttons, a `…` menu. */
     actions?: React$1.ReactNode;
+    /**
+     * The bar's height, on the control scale — a bar is as tall as a control of
+     * its size. `lg` (40px at a 13px root) tops a page or a board; `md`
+     * (32px) tops a panel or a drawer, level with a `PanelBox` header. Either
+     * holds `sm` chips and buttons.
+     */
+    size?: "md" | "lg";
 }
 /**
  * Which record you are looking at, across the top of the surface showing it.
  *
- * A run dashboard, a step dashboard, a plan, a draft — every one of them opens
+ * A run board, a step board, a plan, a draft — every one of them opens
  * with this line, so a reader who followed a link knows what they are reading
  * before they read any of it.
  *
- * It is **not** a `ContextBar`. That is 28px under a panel and describes the
+ * It is **not** a `ContextBar`. That is the `sm` bar under a panel and describes the
  * *view* — counts, a keyboard hint, a tab-shaped switch. This is above the
  * content and names the *record*, which is why the crumbs are mono: they are
  * identifiers, not prose.
@@ -3267,6 +3856,60 @@ 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 RefusalCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Which bound refused it, as a short label — `refused · the agent's
+     * guardrail`. The bound is the point: it says whom to ask.
+     */
+    label?: React$1.ReactNode;
+    /**
+     * What was refused and why, in one or two sentences — *This ask was not run.
+     * In Everything, decide is cast to … and … does not allow it.*
+     */
+    children?: React$1.ReactNode;
+    /** The way round it — another world, another agent, a person to ask. */
+    remedy?: React$1.ReactNode;
+}
+/**
+ * A bound refused the work **before it ran**.
+ *
+ * Not a cannot-answer and not a failure, and its own component for the same
+ * reason those are (DS8): nothing was read, so there is nothing the graph does
+ * not hold; nothing broke, so there is no fault to diagnose. A rule said no,
+ * and the card names the rule's side so the reader knows whose rule to change.
+ *
+ * Tinted with the destructive token, because the reader has to act before
+ * anything happens — but no citation strip and no retry, since running it again
+ * under the same bounds would be refused again.
+ */
+declare const RefusalCard: React$1.ForwardRefExoticComponent<RefusalCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface RepairNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** What was wrong — `unknown property Theme.velocity5d`. */
     from: React$1.ReactNode;
@@ -3314,6 +3957,33 @@ interface RichSelectOption {
     /** Trailing content (e.g. a count or status badge), pushed to the right. */
     badge?: React$1.ReactNode;
     disabled?: boolean;
+    /**
+     * Why a disabled option cannot be picked, shown under it in the warning
+     * tone. A greyed-out row with no reason is a refusal nobody can act on.
+     */
+    disabledReason?: React$1.ReactNode;
+}
+/**
+ * An on/off setting beside the choice — *Next ask only* on a world picker. It
+ * is not an option: it scopes the choice, so it sits below the options and
+ * toggling it keeps the menu open.
+ */
+interface RichSelectToggle {
+    id: string;
+    label: React$1.ReactNode;
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    disabled?: boolean;
+}
+/**
+ * Something to do rather than something to pick — *Manage worlds…*. It sits
+ * last, below a separator, so it is never mistaken for a value.
+ */
+interface RichSelectAction {
+    id: string;
+    label: React$1.ReactNode;
+    icon?: React$1.ElementType;
+    onSelect: () => void;
 }
 interface RichSelectProps {
     options: RichSelectOption[];
@@ -3343,6 +4013,25 @@ interface RichSelectProps {
     side?: "top" | "right" | "bottom" | "left";
     /** Gap in px between the trigger and the menu. Default `4`. */
     sideOffset?: number;
+    /**
+     * `field` (default) is an outlined control for a form. `inline` is the
+     * borderless, compact trigger a toolbar uses — every control in a chat
+     * composer is one, so the ask kind and the world read as one row.
+     */
+    appearance?: "field" | "inline";
+    /** Glyph before the selected value on the trigger — a globe for a world. */
+    triggerIcon?: React$1.ElementType;
+    /** A short tag after the value on the trigger — `next ask only`. */
+    triggerTag?: React$1.ReactNode;
+    /** Settings that scope the choice; rendered below the options. */
+    toggles?: RichSelectToggle[];
+    /** Acts, not values; rendered last. */
+    actions?: RichSelectAction[];
+    /**
+     * The trigger's accessible name — *Ask kind*, *World*. An inline trigger
+     * shows only the current value, which names the choice made, not the control.
+     */
+    triggerAriaLabel?: string;
     /** Trigger tooltip content; omit to disable the tooltip. */
     tooltip?: React$1.ReactNode;
     /** Side the trigger tooltip is placed on. Default `'top'`. */
@@ -3360,8 +4049,13 @@ interface RichSelectProps {
  * rich content (`label`, `description`, `icon`, `badge`) and both the rows and
  * the trigger are fully customizable via `renderOption` / `renderValue`.
  * Supports single (radio) and multi (checkbox) selection via `multiple`.
+ *
+ * Beyond the choice it can carry **toggles** that scope it and **actions**
+ * below it, and an `inline` trigger for toolbars — which is what lets every
+ * control in a chat composer (ask kind, query language, world, timeout) be the
+ * same component rather than a `Select` beside a hand-rolled menu.
  */
-declare function RichSelect({ options, value, onChange, multiple, label, placeholder, renderOption, renderValue, align, side, sideOffset, tooltip, tooltipSide, disabled, triggerClassName, contentClassName, className, }: RichSelectProps): React$1.JSX.Element;
+declare function RichSelect({ options, value, onChange, multiple, label, placeholder, renderOption, renderValue, align, side, sideOffset, tooltip, tooltipSide, disabled, appearance, triggerIcon: TriggerIcon, triggerTag, triggerAriaLabel, toggles, actions, triggerClassName, contentClassName, className, }: RichSelectProps): React$1.JSX.Element;
 
 /** A slice along the axes the matched model **declared**. */
 interface RuleSelect {
@@ -3493,19 +4187,191 @@ interface RuleRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "chi
 declare const RuleRow: React$1.ForwardRefExoticComponent<RuleRowProps & 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.
+ * 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" | "awaiting_input" | "partial" | "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>>;
+/**
+ * Which glyph each status is drawn with, where the word is not beside it.
+ *
+ * The shape is the point: every state a reader acts on differently gets its own
+ * — done, broken, moving, not started, **waiting on you**, could not answer,
+ * answered in part, stopped. An unknown status reads as not started.
+ */
+declare const ICON: Record<string, StatusIconState>;
+
+interface RunRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title" | "onSelect"> {
+    status: RunStatus;
+    /** Overrides the glyph the status resolves to — `partial` on a run that succeeded. */
+    state?: StatusIconState;
+    kind?: RunKind;
+    /**
+     * What it was about, in the words it was opened with — the question as typed,
+     * the query text, the dataset loaded. **Line one**, because it is what a
+     * reader scans the journal for.
+     */
+    title: React$1.ReactNode;
+    /** The title is a query, not a sentence — drawn mono. */
+    titleMono?: boolean;
+    /**
+     * The run's address — the last eight characters of its uuid, mono.
+     *
+     * **First on line two.** 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;
+    /** After the address — `nl-query@5 · 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.
+ *
+ * Line one is what it was about; line two is the id, then what it spent. The
+ * status is a glyph in the leading slot and **not a word** — the shape carries
+ * it, so the badge's column goes back to the prompt.
+ *
+ * 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>>;
+
+interface ScopeLineChoice {
+    value: string;
+    label: React$1.ReactNode;
+    /** At the right of the choice, in mono — `188`, `2 of 3`. */
+    detail?: React$1.ReactNode;
+}
+/** A part with more to say than its text. */
+interface ScopeLinePart {
+    text: React$1.ReactNode;
+    /**
+     * `changed` — this part differs from the question it was carried from;
+     * `stale` — the data behind it is late.
+     */
+    mark?: "changed" | "stale";
+    /** What the part can be changed to. Opening the part lists them under the line. */
+    choices?: ScopeLineChoice[];
+}
+interface ScopeLineProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** What the figure covers, in order — period, comparison, filters, population, freshness. */
+    parts: (React$1.ReactNode | ScopeLinePart)[];
+    /**
+     * Makes the text parts editable in place: click one, type, `Enter` to send
+     * the new value, `Escape` or leaving it to keep the old one. Called only
+     * when the value changed.
+     */
+    onPartChange?: (index: number, value: string) => void;
+    /**
+     * Parts that stay as stated even when the rest can be edited — the data's
+     * freshness is a fact about the load, not a choice of the analyst's.
+     */
+    fixedParts?: number[];
+    /** The part whose choices are showing. Controlled; see `defaultOpenPart`. */
+    openPart?: number | null;
+    /** The part whose choices show at first, uncontrolled. */
+    defaultOpenPart?: number;
+    onOpenPartChange?: (index: number | null) => void;
+    /** A line under the scope — `Click any part to change it and re-run`. */
+    note?: React$1.ReactNode;
+    /** `warning` when the note is about late data. */
+    noteTone?: "muted" | "warning";
+    /**
+     * No box, and nothing wasted on its outside: only the rules between parts
+     * are drawn, and the first part sits flush with the text around the strip.
+     * For a scope inside a card or an answer, whose edge already frames it.
+     */
+    seamless?: boolean;
+}
+/**
+ * What an answer covers, stated in one strip: `Q3 2026 · vs Q2 · Stores,
+ * Online · 214 stores · as of 06:00`.
+ *
+ * Every analytic answer carries one, above its figures, so a number is never
+ * read without the period and population it was computed over. The parts are
+ * exactly as applied — the filters the query ran with, not the ones asked for.
+ *
+ * With `onPartChange` the scope is also where it is changed: a part is edited
+ * where it is read, rather than by asking the question again.
+ */
+declare const ScopeLine: React$1.ForwardRefExoticComponent<ScopeLineProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * The control scale: `sm` (26px) is the application field — a search box
+ * docked in a panel header or a table toolbar; `default` (32px) a standalone
+ * form; `lg` (40px) a page. Size is height only: every size reads at the root,
+ * the size of the rows being searched.
  *
  * Named `inputSize` for the same reason `Input` is: `size` is already an
  * `<input>` attribute meaning "how many characters wide".
  */
-type SearchInputSize = 'default' | 'sm';
+type SearchInputSize = 'sm' | 'default' | 'lg';
 interface SearchInputProps extends Omit<React__default.ComponentProps<'input'>, 'value' | 'onChange' | 'size' | 'type'> {
+    /** Sits on the box around the field — its width, its place in a row. */
     className?: string;
     value: string;
     /** Receives the raw string, not the event — a search box has one value. */
     onChange: (value: string) => void;
     inputSize?: SearchInputSize;
+    /**
+     * A clear button at the end of the field while it holds text, and Escape
+     * clears it too; both send `onChange("")`. On by default.
+     */
+    clearable?: boolean;
+    /** The clear button's glyph — yours, at 14px. Default: a plain cross. */
+    clearIcon?: React__default.ReactNode;
+    /** The clear button's accessible name. */
+    clearLabel?: string;
 }
 declare const SearchInput: React__default.FC<SearchInputProps>;
 
@@ -3532,47 +4398,12 @@ interface SectionHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>
  *
  * A panel is a stack of these: Node types, Edge types, Relationships, Selected,
  * Anchors, Recent plans. It is 35px because that is what reads as a heading
- * against 30px rows without becoming a second toolbar.
- *
- * Not a `<Card>` header — a section is a band inside a scrolling panel, not a
- * container, so it carries a rule rather than a border box.
- */
-declare const SectionHeader: React$1.ForwardRefExoticComponent<SectionHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
-
-/**
- * TODO — provisional. Built ahead of its design review.
- *
- * The chart set was deliberately deferred while the rest of the kit was built,
- * because charts are the one group with a real design question in them rather
- * than a markup question: which forms this product actually needs, at what
- * sizes, and how much a 330px drawer can carry. This component satisfies the
- * dataviz rules and the validated palette, but the *form inventory* has not been
- * agreed — treat the API as unsettled until a board screen uses it in anger.
- */
-
-interface SparklineProps extends Omit<React$1.SVGAttributes<SVGSVGElement>, "children" | "values"> {
-    values: number[];
-    width?: number;
-    height?: number;
-    color?: string;
-    /** Washes the area under the line at 10%. Off by default at this size. */
-    area?: boolean;
-    /** A filled dot on the last point, ringed in the surface colour. */
-    endMarker?: boolean;
-    /** What the line is, for assistive tech. The surface around it usually says. */
-    label?: string;
-}
-/**
- * The shape of a series, small enough to sit inside a row.
- *
- * No axis, no gridlines, no labels — a sparkline answers "which way, and how
- * steadily", and the number it accompanies answers "how much". If a reader
- * needs to read a value off it, it wanted to be a chart.
+ * against 30px rows without becoming a second toolbar.
  *
- * The end marker carries a 2px ring in the surface colour so it stays legible
- * where the line runs under it.
+ * Not a `<Card>` header — a section is a band inside a scrolling panel, not a
+ * container, so it carries a rule rather than a border box.
  */
-declare const Sparkline: React$1.ForwardRefExoticComponent<SparklineProps & React$1.RefAttributes<SVGSVGElement>>;
+declare const SectionHeader: React$1.ForwardRefExoticComponent<SectionHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface TabConfig {
     /** Unique identifier for the tab */
@@ -3590,6 +4421,8 @@ interface TabConfig {
     content: React__default.ReactNode;
     /** Whether this tab should be disabled */
     disabled?: boolean;
+    /** Draw a close button on the tab; pressing it calls the panel's `onTabClose`. */
+    closable?: boolean;
 }
 interface TabbedPanelProps {
     /** Array of tab configurations */
@@ -3600,6 +4433,11 @@ interface TabbedPanelProps {
     activeTab?: string;
     /** Callback when tab changes */
     onTabChange?: (value: string) => void;
+    /**
+     * A `closable` tab's close was pressed, by its value. The tabs are yours, so
+     * closing is too: drop it from `tabs`, and move `activeTab` if it was open.
+     */
+    onTabClose?: (value: string) => void;
     /**
      * Actions on the right of the tab bar, as `NavHorizontal` items. A panel
      * header has one action area — the right — so this is the item list itself
@@ -3616,6 +4454,16 @@ interface TabbedPanelProps {
      * ```
      */
     headerActions?: NavHorizontalItem[];
+    /**
+     * A control on the right of the tab strip, before `headerActions`, that
+     * applies to **every** tab: a time window, a version. Not a place for a
+     * tab's own controls — those belong in that tab's body.
+     *
+     * ```tsx
+     * headerContent={<ToggleGroup type="single" size="sm">…</ToggleGroup>}
+     * ```
+     */
+    headerContent?: React__default.ReactNode;
     /**
      * Fold the tabs that do not fit the header into a `…` dropdown at the end of
      * the strip, instead of letting the strip set the panel's minimum width.
@@ -3653,7 +4501,7 @@ interface TabbedPanelProps {
     footerContent?: React__default.ReactNode;
 }
 /**
- * TabbedPanel — a panel whose views sit behind one 30px tab strip.
+ * TabbedPanel — a panel whose views sit behind one `md` tab strip.
  *
  * The strip is a `NavItems` tab list (`variant="underline"`), not a Radix
  * `Tabs`: the same component draws this kit's nav rails and its workbook tabs,
@@ -3663,47 +4511,129 @@ interface TabbedPanelProps {
  * `TabsContent`, and a panel that tears its canvas down on every tab switch is
  * not a panel anyone wants.
  */
-declare function TabbedPanel({ tabs, defaultTab, activeTab, onTabChange, headerActions, overflow, overflowLabel, keepMounted, className, headerClassName, bodyClassName, footerClassName, footerContent, }: TabbedPanelProps): React__default.JSX.Element;
+declare function TabbedPanel({ tabs, defaultTab, activeTab, onTabChange, onTabClose, headerActions, headerContent, overflow, overflowLabel, keepMounted, className, headerClassName, bodyClassName, footerClassName, footerContent, }: TabbedPanelProps): React__default.JSX.Element;
+
+/**
+ * Which rows of a tree are open, by key — `true` for every one. The same shape
+ * as a `DataTable`'s `expanded`, so a page holding both passes one value.
+ */
+type ExpandedKeys = true | Record<string, boolean>;
+interface UseExpandedKeysOptions {
+    /** Controlled. Pair it with `onExpandedChange`. */
+    expanded?: ExpandedKeys;
+    /** Uncontrolled: what is open at first. Closed by default. */
+    defaultExpanded?: ExpandedKeys;
+    onExpandedChange?: (expanded: ExpandedKeys) => void;
+    /** Every key that can open, so closing one row of `true` keeps the rest open. */
+    keys: string[];
+}
+/**
+ * Open and close the rows of a tree, controlled or not. What a chart drawn as
+ * rows uses to nest — a Gantt's subtasks, a heat strip's children — so each
+ * opens the same way and reports the same value.
+ */
+declare function useExpandedKeys({ expanded, defaultExpanded, onExpandedChange, keys, }: UseExpandedKeysOptions): {
+    isOpen: (key: string) => boolean;
+    toggle: (key: string) => void;
+};
 
 /**
- * What a task did with its slice of the run's clock.
+ * What a bar did with its slice of the clock.
  *
  * These are the engine's own step statuses (`StepStatus`, plus `skipped` for a
  * branch that never ran), not a second vocabulary: a Gantt row and a log line
- * are the same task seen twice, so they say the same word for the same state.
+ * are the same work seen twice, so they say the same word for the same state.
+ * `refused` is what a rule stopped — reached for and not allowed — which is a
+ * different fact from `skipped`, and both are drawn.
  */
-type TaskGanttStatus = "succeeded" | "running" | "failed" | "needs_input" | "stopped" | "skipped" | "queued";
+type GanttStatus = "succeeded" | "running" | "failed" | "needs_input" | "stopped" | "skipped" | "queued" | "refused";
 /** A `Date`, an ISO string, or epoch milliseconds — whatever the JSON carried. */
-type TaskGanttInstant = string | number | Date;
+type GanttInstant = string | number | Date;
 /**
- * One bar. A task is usually one of these; a retried task is two or more, the
- * failed attempt sitting to the left of the one that stuck.
+ * One bar on the clock. A row's own bar is one of these, so is each earlier
+ * attempt — the failed one sitting to the left of the one that stuck — and so
+ * is each of the row's `bars`.
  */
-interface TaskGanttSegment {
+interface GanttBar {
     /** Offset from the run's zero. Use this, or `startedAt` with `origin`. */
     startMs?: number;
     durationMs?: number;
-    startedAt?: TaskGanttInstant;
-    finishedAt?: TaskGanttInstant;
-    status?: TaskGanttStatus;
+    startedAt?: GanttInstant;
+    finishedAt?: GanttInstant;
+    status?: GanttStatus;
     /** Overrides the hover text, which otherwise reads `key · status · duration`. */
     title?: string;
+    /**
+     * Names the bar, so it can be picked on its own — `fetch_source#1`. Only a
+     * bar in a row's `bars` has one; the row's own bar is picked with the row.
+     */
+    key?: string;
+    /**
+     * Written in the bar — the task a slot held, the participant a layer reached.
+     * A row with a labelled bar grows to the `xs` control height to carry it, and
+     * the bar draws as a card with its fill as a rail, so the text stays legible
+     * on any status or palette colour.
+     */
+    label?: React$1.ReactNode;
+    /**
+     * Which entry of `palette` paints it, in place of its status fill — a layer,
+     * a lane, an agent. A group the palette does not name keeps the status fill,
+     * and a `failed` or `refused` bar is always drawn as one.
+     */
+    group?: string;
+    /**
+     * `solid` (the default) is spent time. `outline` is time held but not spent
+     * — queued, waiting on a gate; `dashed` is time that may be spent — declared,
+     * not yet dispatched.
+     */
+    variant?: "solid" | "outline" | "dashed";
+    /**
+     * A second line under the label — `1,204 of 1,251`, `503`. A row with one
+     * grows to the `md` control height to carry both lines.
+     */
+    note?: React$1.ReactNode;
+    /** A small mark at the bar's end — a `Badge`, an icon, a count. Drawn with a label. */
+    chip?: React$1.ReactNode;
+    /**
+     * What this bar did, for its own hover card — the same fields a row's card
+     * reads. A row with a bar that has one opens no card of its own: its bars
+     * do, so the reader gets the bar under the cursor rather than the row.
+     */
+    summary?: React$1.ReactNode;
+    result?: React$1.ReactNode | Record<string, unknown>;
+    error?: {
+        code?: React$1.ReactNode;
+        message?: React$1.ReactNode;
+        detail?: React$1.ReactNode;
+    };
+    log?: React$1.ReactNode;
 }
-interface TaskGanttTask extends TaskGanttSegment {
-    /** `task_key` — what the log lines call this task. Also the row's label. */
+/**
+ * One row: a task on a run's clock, a worker slot, a layer, a participant —
+ * whatever the surface groups time by. It carries its own bar, earlier
+ * attempts, many `bars` of its own, and the `rows` it opens into.
+ */
+interface GanttRow extends GanttBar {
+    /** What the log lines call it — `task_key`, `slot-1`, `ingest`. Also the row's label. */
     key: string;
     /** Shown instead of `key`, when the row wants a human name. */
     label?: React$1.ReactNode;
     /** Earlier attempts, oldest first. A failed one draws in `destructive`. */
-    attempts?: TaskGanttSegment[];
-    /** Overrides the right-hand duration cell. `—` when the task never ran. */
+    attempts?: GanttBar[];
+    /**
+     * Many bars on one row, each a thing of its own rather than a retry — what a
+     * worker slot held in order, what a layer was reached for. Drawn with the
+     * row's own bar, if it has one; give each a `label` to say what it was.
+     */
+    bars?: GanttBar[];
+    /** Overrides the right-hand duration cell. `—` when the row never ran. */
     duration?: React$1.ReactNode;
-    /** One line — what the task said. The card's last line. */
+    /** One line — what it said. The card's last line. */
     log?: React$1.ReactNode;
     /** A sentence under the card's header, when the row wants one. */
     summary?: React$1.ReactNode;
     /**
-     * What the task produced — its `result.json`, or any part of it.
+     * What it produced — its `result.json`, or any part of it.
      *
      * An object renders as label/value pairs, with nested values as JSON; a node
      * renders as given, which is the hook for a kind-specific card (a table
@@ -3718,12 +4648,44 @@ interface TaskGanttTask extends TaskGanttSegment {
     };
     /** Replaces this row's card body entirely. */
     detail?: React$1.ReactNode;
+    /**
+     * The rows this one opens into — the tasks it split into, the participants
+     * of a layer — drawn under it, indented, when it is open. A row with no
+     * timing of its own draws the stretch its rows cover.
+     */
+    rows?: GanttRow[];
+}
+/**
+ * A bounded repetition — a loop's rounds — drawn as a bracket over the rows
+ * it holds, with its label on a line of its own above them.
+ */
+interface GanttBracket {
+    /** The first row it holds, by `key`. */
+    from: string;
+    /** The last row it holds, by `key`. Rows are matched in order, first hit. */
+    to: string;
+    /** `↻ 2 of 3 rounds — understood on round 2`. */
+    label: React$1.ReactNode;
+}
+/**
+ * A gate — a moment the run held and spent nothing — drawn as a rule across
+ * the stretch of the clock it held, between the rows it lies between.
+ */
+interface GanttSeam extends Pick<GanttBar, "startMs" | "durationMs" | "startedAt" | "finishedAt"> {
+    /** The row it follows, by `key`. */
+    after: string;
+    /** The label column's word — `approval`. */
+    label: React$1.ReactNode;
+    /** What it was and how it resolved, written on the rule — `approved by ravi`. */
+    note?: React$1.ReactNode;
+    /** Overrides the right-hand cell, which otherwise reads the time it held. */
+    duration?: React$1.ReactNode;
 }
-interface TaskGanttProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
-    /** One entry per task, in plan order — the run's `steps`, grouped by task. */
-    tasks: TaskGanttTask[];
-    /** The run's zero, when tasks carry timestamps. Defaults to the earliest one. */
-    origin?: TaskGanttInstant;
+interface GanttProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** One entry per row, in order — a run's tasks, its slots, its layers. */
+    rows: GanttRow[];
+    /** The clock's zero, when bars carry timestamps. Defaults to the earliest one. */
+    origin?: GanttInstant;
     /** The clock's ceiling. Defaults to the last end, or `nowMs` if that is later. */
     spanMs?: number;
     /** Draws the *now* line. Set it while the run is in flight; omit it after. */
@@ -3734,10 +4696,32 @@ interface TaskGanttProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "o
     ticks?: number;
     formatTick?: (ms: number) => string;
     formatDuration?: (ms: number) => string;
-    /** The key column, in px. 112 in the drawer, wider on a dashboard. */
+    /**
+     * The key column, in px. Omit it and the column takes its longest label,
+     * up to 40% of the width — the surface decides the width, never the chart.
+     */
     labelWidth?: number;
     /**
-     * `compact` in a drawer, `comfortable` on a dashboard. It moves the bar's
+     * The right-hand duration column, in px. Omit it and it takes its widest
+     * cell; set it on charts stacked over one clock so their tracks end together.
+     */
+    durationWidth?: number;
+    /** Loops, bracketed over their rounds. */
+    brackets?: GanttBracket[];
+    /** Gates, ruled across the time they held. */
+    seams?: GanttSeam[];
+    /**
+     * What each bar `group` is painted with — `{ ingest: "bg-data-1" }`. The
+     * kit ships no hues: a group nobody painted keeps its status fill.
+     */
+    palette?: Record<string, string>;
+    /**
+     * The inside of a bar, for every bar in `bars` — a chip, an icon, a count. Return
+     * `null` for a bar that should stay a plain fill. Wins over `label`.
+     */
+    renderBar?: (bar: GanttBar, row: GanttRow) => React$1.ReactNode;
+    /**
+     * `compact` in a drawer, `comfortable` on a board. It moves the bar's
      * height, not the type scale — one component, three surfaces (SR14).
      */
     density?: "compact" | "comfortable";
@@ -3752,18 +4736,33 @@ interface TaskGanttProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "o
      * Replaces the default card body, for every row. Return `null` for a row that
      * should not open one.
      */
-    renderDetail?: (task: TaskGanttTask) => React$1.ReactNode;
+    renderDetail?: (row: GanttRow) => React$1.ReactNode;
     /** Where the card sits, how fast it opens, and how wide it is. */
-    detailProps?: TaskGanttDetailProps;
-    /** The task the log is currently filtered to (SR15). */
+    detailProps?: GanttDetailProps;
+    /** The row or bar picked — what the log is currently filtered to (SR15). */
     selectedKey?: string | null;
     /** Makes the rows pickable. Picking one is what filters the log. */
-    onSelectTask?: (key: string) => void;
+    onSelectRow?: (key: string) => void;
+    /**
+     * Makes each keyed bar pickable on its own — the task a layer was reached
+     * for, rather than the layer. A row whose bars are keyed is then
+     * picked by its bars, not as a whole, so a bar is never a button inside a
+     * button. `selectedKey` lights a bar with that key as it lights a row.
+     */
+    onSelectBar?: (barKey: string, rowKey: string) => void;
+    /** Which rows with `rows` are open, by key — `true` for all. Controlled. */
+    expanded?: ExpandedKeys;
+    /** Which are open at first, uncontrolled. Closed by default. */
+    defaultExpanded?: ExpandedKeys;
+    /** A row opened or closed: every open key, as a `DataTable`'s `expanded` reads. */
+    onExpandedChange?: (expanded: ExpandedKeys) => void;
 }
-interface TaskGanttDetailProps {
-    /** @default "right" */
+/**
+ * Where the card opens. With neither `side` nor `align` it opens beside the
+ * cursor, under the row; set either and it is placed against the row instead.
+ */
+interface GanttDetailProps {
     side?: "top" | "right" | "bottom" | "left";
-    /** @default "start" */
     align?: "start" | "center" | "end";
     sideOffset?: number;
     /** @default 200 */
@@ -3774,14 +4773,14 @@ interface TaskGanttDetailProps {
     width?: number | string;
     className?: string;
 }
-interface TaskGanttDetailCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
-    task: TaskGanttTask;
-    /** Elapsed so far, for a task still running — it has no `durationMs` yet. */
+interface GanttDetailCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    row: GanttRow;
+    /** Elapsed so far, for a row still running — it has no `durationMs` yet. */
     elapsedMs?: number;
     formatDuration?: (ms: number) => string;
 }
 /**
- * What one task did, as a card.
+ * What one row — or one bar — did, as a card.
  *
  * The body of the hover card, and exported so a surface can compose its own
  * around the same header — `renderDetail` returning this with a kind-specific
@@ -3791,25 +4790,30 @@ interface TaskGanttDetailCardProps extends Omit<React$1.HTMLAttributes<HTMLDivEl
  * Order is fixed and is the order a reader asks in: what state, how long, what
  * went wrong, what came out, what it said last.
  */
-declare const TaskGanttDetailCard: React$1.ForwardRefExoticComponent<TaskGanttDetailCardProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const GanttDetailCard: React$1.ForwardRefExoticComponent<GanttDetailCardProps & React$1.RefAttributes<HTMLDivElement>>;
 /**
- * Where the time went — one row per task, on the run's own clock.
+ * Where the time went — rows of bars on one clock.
  *
- * Duration is the question a run detail is opened with, and a step list with a
- * duration column answers it one row at a time. A bar placed by start and sized
- * by duration puts the slow task, the retry and the branch that never ran in one
- * glance (SR14).
+ * A row is whatever a surface groups time by. Read by **task**, it answers the
+ * question a run detail is opened with: a bar placed by start and sized by
+ * duration puts the slow task, the retry and the branch that never ran in one
+ * glance (SR14). Read by **layer**, the same drawing answers what the run
+ * reached and what it was stopped from reaching: a row per layer opens into its
+ * participants, and each holds the `bars` of the tasks that reached it, painted
+ * by `palette` — `refused` where a rule said no, `dashed` where it was declared
+ * and never dispatched. Read by **slot**, each row is a worker and its bars are
+ * what it ran, in order.
  *
- * It is one component across three surfaces — the Runs drawer (compact, with a
- * line of log per row), the run dashboard (full width, logs off) and the
- * document rendering — so `density` and `showLogs` are props, not three
- * drawings.
+ * A row opens into its `rows`, indented under it, and a parent with no timing
+ * of its own draws the stretch they cover as a thin rule — so a closed plan
+ * still says how long it took. The clock is milliseconds by default; a plan
+ * read in order passes step numbers and a `formatTick` that names them.
  *
- * Colour never carries state alone: every row names its duration, the bar
- * titles itself with its status, and a task that never ran is an *outline*
- * rather than a paler fill.
+ * Colour never carries state alone: every row names its duration, a bar titles
+ * itself with its status, a row that never ran is an *outline* rather than a
+ * paler fill, and a refused bar's name is struck through.
  */
-declare const TaskGantt: React$1.ForwardRefExoticComponent<TaskGanttProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const Gantt: React$1.ForwardRefExoticComponent<GanttProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface TaskNodeTag {
     /** `3 lanes`, `attempt 2`, `map_over: datasets`. */
@@ -3839,6 +4843,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`. */
@@ -3897,76 +4910,10 @@ interface TemplatePickerProps extends Omit<React$1.HTMLAttributes<HTMLDivElement
  * again**. That is why unavailable options are listed rather than hidden — the
  * reason a template does not fit ("needs a time column") is information about
  * the data, and hiding it would leave the reader wondering what else exists.
- */
-declare const TemplatePicker: React$1.ForwardRefExoticComponent<TemplatePickerProps & React$1.RefAttributes<HTMLDivElement>>;
-
-type TerminalLineKind = "prompt" | "output" | "comment";
-/**
- * The severity a **log** line was emitted at, as the runtime recorded it.
- *
- * Distinct from `kind`, which says what part of a *transcript* a line is — a
- * 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 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;
-    /**
-     * How loud this line is. Tints **one** cell — the one named by
-     * `levelColumn` — and nothing else.
-     *
-     * Only the level word is coloured, never the message: a wall of amber
-     * sentences is unreadable, and what a reader scans is the column, not the
-     * prose. Setting this also drops the `kind` marker — a log line is not a
-     * transcript line and does not want a `→` in front of it.
-     *
-     * The level **word** stays in `columns`. Colour is never the carrier.
-     */
-    level?: TerminalLevel;
-    /**
-     * Which cell of `columns` holds the level word. Defaults to `1`, because a
-     * log line reads `time · LEVEL · source · message` and the timestamp comes
-     * first in every log anyone has ever read.
-     */
-    levelColumn?: number;
-    /**
-     * Columns, for the step-shaped output a run prints — name, detail, timing,
-     * result. Given as cells so they align down the transcript instead of each
-     * line padding itself with spaces.
-     */
-    columns?: React$1.ReactNode[];
-    children?: React$1.ReactNode;
-}
-interface TerminalProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    children?: React$1.ReactNode;
-    /** Shows a blinking block at the end. */
-    cursor?: boolean;
-    /**
-     * `grid-template-columns` for every columned line in this transcript.
-     *
-     * Set once here rather than per line, because the point of columns is that
-     * they line up *down* the transcript — a width chosen per row aligns nothing.
-     */
-    columnTemplate?: string;
-}
-/**
- * A shell transcript, as a first-class surface.
- *
- * Some of this product's work happens outside Studio — imports run from the
- * CLI, a scheduler calls the Python API — and the hand-off has to be shown
- * honestly rather than redrawn as a wizard. So this renders what the terminal
- * actually printed.
  *
- * It is presentational: a record of a run that already happened, not a live
- * console. There is no input here, and it does not scroll itself.
+ * @deprecated Import from `@invana/assistant`. This export leaves `@invana/ui` in the next release.
  */
-declare const Terminal: React$1.ForwardRefExoticComponent<TerminalProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const TerminalLine: React$1.ForwardRefExoticComponent<TerminalLineProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TemplatePicker: React$1.ForwardRefExoticComponent<TemplatePickerProps & React$1.RefAttributes<HTMLDivElement>>;
 
 /**
  * How the list arranges one entry.
@@ -3978,8 +4925,12 @@ declare const TerminalLine: React$1.ForwardRefExoticComponent<TerminalLineProps
  * `rail` — `when` sits above the title and a line threads the markers. For a
  * narrow card or sidebar, where a 72px column would eat a third of the width
  * and titles wrap anyway; the rail supplies the alignment the column was.
+ *
+ * `compact` — `when`, the marker and the text on one line, no rules. For a few
+ * dated events inside an answer, `wk 8 · Yantian port congestion notice`,
+ * where rules between two lines would outweigh the lines.
  */
-type TimelineVariant = "columns" | "rail";
+type TimelineVariant = "columns" | "rail" | "compact";
 interface TimelineEntryProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "title"> {
     /** When — `Fri 5 Sep`, `09:47`, `Sun`. */
     when: React$1.ReactNode;
@@ -3987,6 +4938,21 @@ interface TimelineEntryProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>,
     title?: React$1.ReactNode;
     /** A marker in the rail — a `StatusDot`, usually. */
     marker?: React$1.ReactNode;
+    /**
+     * Calls the entry out on a tinted ground — the anomaly the events around it
+     * explain. `compact` only.
+     */
+    highlight?: "error" | "warning" | "success" | "info";
+    /**
+     * The events this one breaks into — `TimelineEntry`s drawn under it, in the
+     * list's variant, when it is open. A chevron beside the entry opens it.
+     */
+    nested?: React$1.ReactNode;
+    /** Controlled. Pair it with `onOpenChange`. */
+    open?: boolean;
+    /** Uncontrolled: open at first. Closed by default. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
     children?: React$1.ReactNode;
 }
 interface TimelineListProps extends React$1.HTMLAttributes<HTMLOListElement> {
@@ -4004,7 +4970,9 @@ interface TimelineFooterProps extends React$1.HTMLAttributes<HTMLLIElement> {
  * because the order carries meaning — these are events in sequence, not a set.
  *
  * Both variants take the same entries; only the arrangement differs. See
- * `TimelineVariant` for which one a surface wants.
+ * `TimelineVariant` for which one a surface wants. An entry that breaks into
+ * smaller events carries them as `nested` entries, drawn under it, in the
+ * same variant, once it is opened.
  */
 declare const TimelineList: React$1.ForwardRefExoticComponent<TimelineListProps & React$1.RefAttributes<HTMLOListElement>>;
 declare const TimelineEntry: React$1.ForwardRefExoticComponent<TimelineEntryProps & React$1.RefAttributes<HTMLLIElement>>;
@@ -4018,8 +4986,80 @@ declare const TimelineEntry: React$1.ForwardRefExoticComponent<TimelineEntryProp
  * `columns` has no rail to run on, so the footer is a plain last row there.
  */
 declare const TimelineFooter: React$1.ForwardRefExoticComponent<TimelineFooterProps & React$1.RefAttributes<HTMLLIElement>>;
+interface TimelineSectionProps extends React$1.HTMLAttributes<HTMLLIElement> {
+    children?: React$1.ReactNode;
+}
+/**
+ * A label over a run of entries — `Before`, `Spike`, `After` — for events read
+ * around one moment rather than as one sequence.
+ */
+declare const TimelineSection: React$1.ForwardRefExoticComponent<TimelineSectionProps & React$1.RefAttributes<HTMLLIElement>>;
+
+/** One control of a toolbar: a word, or an icon named by its tooltip. */
+interface ToolbarAction {
+    id: string;
+    /** The word, or — with an `icon` — the tooltip and accessible name. */
+    label: string;
+    /** Draws the control as an icon; the caller's, at 16px. */
+    icon?: React$1.ReactNode;
+    /** A toggle that is on — `Lock` while the canvas is locked. */
+    pressed?: boolean;
+    disabled?: boolean;
+}
+/** A rule between groups of controls. */
+interface ToolbarSeparator {
+    separator: true;
+}
+type ToolbarItem = ToolbarAction | ToolbarSeparator;
+interface ToolbarProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    items: ToolbarItem[];
+    /** A control was pressed, by its `id`. */
+    onAction?: (id: string) => void;
+}
+/**
+ * A row of controls over a canvas or a panel — icon toggles named by their
+ * tooltips, words, and rules between groups — on the control scale a step
+ * below its bar (`sm`). What each control does is the caller's: it says which
+ * was pressed.
+ */
+declare const Toolbar: React$1.ForwardRefExoticComponent<ToolbarProps & React$1.RefAttributes<HTMLDivElement>>;
 
-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;
+    /**
+     * `row` (default) is one cell per layer on one line, above a trace. `column`
+     * is one line per layer, the note right-aligned — how a 420px panel reads the
+     * same summary, where six cells on a line would truncate every note.
+     */
+    orientation?: "row" | "column";
+}
+/**
+ * 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
@@ -4124,6 +5164,122 @@ 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> {
+    /**
+     * `default` is the run view: stripe, sequence, layer, duration. `progress` is
+     * the trace a running answer streams — a dot per step (filled when done,
+     * pulsing while it runs, hollow while it waits), the step in plain text, and
+     * its timing or count at the right in mono.
+     */
+    variant?: "default" | "progress";
+    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 `Gantt`, by task or by layer.
+ */
+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;
+    /**
+     * Where the step is, in a `progress` list: `done`, `running`, `pending`,
+     * `failed`, `waiting` on the reader, `retrying` after a failed attempt, or
+     * `stopped` by the reader. Defaults to `done`. The run view says the same
+     * with `dim` and `struck`.
+     */
+    status?: "done" | "running" | "pending" | "failed" | "waiting" | "retrying" | "stopped";
+    /** Why a failed step failed, on a line under it in a `progress` list. */
+    error?: React$1.ReactNode;
+}
+/**
+ * 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;
@@ -4155,64 +5311,169 @@ interface UnderDevelopmentProps extends VariantProps<typeof underDevelopmentVari
 }
 declare function UnderDevelopment({ title, description, iconSize, size, className, }: UnderDevelopmentProps): React$1.JSX.Element;
 
-interface TypographyPreProps extends React$1.HTMLAttributes<HTMLPreElement> {
+/** One page in the strip — its tab label plus the content shown when active. */
+interface WorkbookPage {
+    /** Stable identity — the key for mounting and the value passed to callbacks. */
+    id: string;
+    /** Tab label. */
+    title: string;
+    /** What renders in the body when this page is active (or, with
+     *  `keepMounted`, stays mounted-but-hidden while another page is active). */
+    content: ReactNode;
+    /** Optional leading icon in the tab. */
+    icon?: ElementType;
+    /** Disable selecting this tab. */
+    disabled?: boolean;
+    /** Extra classes for *this* tab button (win over the built-ins via
+     *  tailwind-merge) — e.g. a per-page accent. */
+    tabClassName?: string;
+    /** Inline styles for *this* tab button — e.g. a custom brand colour. */
+    tabStyle?: CSSProperties;
+    /** Draw an inline `×` on this tab (active or not) that calls the view's
+     *  `onClose`, in place of the caret menu — for a page with nothing to manage
+     *  but its own closing. Needs `onClose`. */
+    closable?: boolean;
+}
+/**
+ * One entry in the active tab's actions dropdown. The consumer supplies the list
+ * (`pageMenuItems`); each item's `onSelect` is invoked with the id of the page
+ * whose menu is open. This is how a host declares what a page can do — rename,
+ * duplicate, remove, export, … — without the view knowing any of those verbs.
+ */
+interface WorkbookPageMenuItem {
+    /** Stable key for the row. */
+    id: string;
+    /** Row label. */
+    label: string;
+    /** Optional leading icon. */
+    icon?: ElementType;
+    /** Invoked with the active page's id when the row is chosen. */
+    onSelect: (pageId: string) => void;
+    /** Render with destructive (danger) styling — e.g. "Remove". */
+    destructive?: boolean;
+    /** Disable the row — a boolean, or a predicate on the page id (e.g. disable
+     *  "Remove" on the last remaining page). */
+    disabled?: boolean | ((pageId: string) => boolean);
+    /** Draw a separator immediately *before* this row (to group actions). */
+    separatorBefore?: boolean;
+}
+/**
+ * An extra icon button for the header's right-pinned control cluster (next to the
+ * pager / `+`) — e.g. settings, about, help. Strip-level, not per-page: its
+ * `onSelect` takes no page id. The consumer supplies the list via `headerActions`.
+ */
+interface WorkbookAction {
+    /** Stable key for the button. */
+    id: string;
+    /** Accessible label / tooltip. */
+    label: string;
+    /** Icon component. */
+    icon: ElementType;
+    /** Click handler. */
+    onClick: () => void;
+    /** Optional disabled state. */
+    disabled?: boolean;
 }
+interface WorkbookProps {
+    /** The pages, in tab order. */
+    pages: WorkbookPage[];
+    /** Id of the active page. */
+    activeId: string;
+    /** Select a page (tab click). */
+    onSelect: (id: string) => void;
+    /** Show a `+` (in the pager cluster) that requests a new page. Omit to hide it. */
+    onAdd?: () => void;
+    /** Which edge of the body the tab strip sits on — `'top'` (default) or
+     *  `'bottom'`, the spreadsheet look, with each tab open at its top. */
+    tabPosition?: 'top' | 'bottom';
+    /** Which end of the strip the pager cluster (prev / next / `+`) docks at —
+     *  `'start'` (left of the tabs) or `'end'` (right of the tabs). Default `'end'`. */
+    pagerPosition?: 'start' | 'end';
+    /** Extra icon buttons pinned to the far right of the strip (right of the pager)
+     *  — e.g. settings, about. Optional. */
+    headerActions?: WorkbookAction[];
+    /** Actions offered on the **active** tab via a caret dropdown. Omit (or pass an
+     *  empty list) to hide the caret entirely. */
+    pageMenuItems?: WorkbookPageMenuItem[];
+    /** Close a page — invoked by the `×` on a `closable` page. */
+    onClose?: (id: string) => void;
+    /** Tooltip / aria label for the add button. */
+    addLabel?: string;
+    /** Fold tabs that don't fit into a `…` menu at the end of the strip, instead of
+     *  scrolling the strip horizontally. Default `true` — the pager still steps
+     *  through every page, folded or not. */
+    overflow?: boolean;
+    /** Accessible label / tooltip for the overflow (`…`) trigger. */
+    overflowLabel?: string;
+    /** Keep every page mounted and hide the inactive ones (default `true`), so a
+     *  page's state survives tab switches — a canvas's camera and layout, a
+     *  board's scroll and fetched data. Set `false` to mount only the active page. */
+    keepMounted?: boolean;
+    /** Extra classes on the root column. */
+    className?: string;
+    /** Extra classes on the header (tab strip). */
+    headerClassName?: string;
+    /** Extra classes on the body. */
+    bodyClassName?: string;
+    /** Extra classes applied to *every* tab button (win over the built-ins via
+     *  tailwind-merge). Per-page `WorkbookPage.tabClassName` layers on top of this. */
+    tabClassName?: string;
+    /** Extra classes applied to the **active** tab only — override the default
+     *  folder-tab look (e.g. a different accent colour). */
+    activeTabClassName?: string;
+}
+/**
+ * A folder-tab strip over independent pages. The active tab carries a
+ * caret dropdown of consumer-supplied {@link WorkbookPageMenuItem}s (rename /
+ * duplicate / remove / …). Presentational and engine-agnostic — the consumer owns
+ * the page list + active id and applies the reported intents. See the module
+ * header for `keepMounted` and strip-renderer notes.
+ */
+declare function Workbook({ pages, activeId, onSelect, onAdd, tabPosition, pagerPosition, headerActions, pageMenuItems, onClose, addLabel, overflow, overflowLabel, keepMounted, className, headerClassName, bodyClassName, tabClassName, activeTabClassName, }: WorkbookProps): React$1.JSX.Element;
+
+type TypographyPreProps = React$1.HTMLAttributes<HTMLPreElement>;
 declare const TypographyPre: React$1.ForwardRefExoticComponent<TypographyPreProps & React$1.RefAttributes<HTMLPreElement>>;
 
-interface TypographyListProps extends React$1.HTMLAttributes<HTMLUListElement> {
-}
+type TypographyListProps = React$1.HTMLAttributes<HTMLUListElement>;
 declare const TypographyList: React$1.ForwardRefExoticComponent<TypographyListProps & React$1.RefAttributes<HTMLUListElement>>;
 
-interface TypographyMutedProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
-}
+type TypographyMutedProps = React$1.HTMLAttributes<HTMLParagraphElement>;
 declare const TypographyMuted: React$1.ForwardRefExoticComponent<TypographyMutedProps & React$1.RefAttributes<HTMLParagraphElement>>;
 
-interface TypographySmallProps extends React$1.HTMLAttributes<HTMLElement> {
-}
+type TypographySmallProps = React$1.HTMLAttributes<HTMLElement>;
 declare const TypographySmall: React$1.ForwardRefExoticComponent<TypographySmallProps & React$1.RefAttributes<HTMLElement>>;
 
-interface TypographyLargeProps extends React$1.HTMLAttributes<HTMLDivElement> {
-}
+type TypographyLargeProps = React$1.HTMLAttributes<HTMLDivElement>;
 declare const TypographyLarge: React$1.ForwardRefExoticComponent<TypographyLargeProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface TypographyLeadProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
-}
+type TypographyLeadProps = React$1.HTMLAttributes<HTMLParagraphElement>;
 declare const TypographyLead: React$1.ForwardRefExoticComponent<TypographyLeadProps & React$1.RefAttributes<HTMLParagraphElement>>;
 
-interface TypographyInlineCodeProps extends React$1.HTMLAttributes<HTMLElement> {
-}
+type TypographyInlineCodeProps = React$1.HTMLAttributes<HTMLElement>;
 declare const TypographyInlineCode: React$1.ForwardRefExoticComponent<TypographyInlineCodeProps & React$1.RefAttributes<HTMLElement>>;
 
-interface TypographyBlockquoteProps extends React$1.BlockquoteHTMLAttributes<HTMLQuoteElement> {
-}
+type TypographyBlockquoteProps = React$1.BlockquoteHTMLAttributes<HTMLQuoteElement>;
 declare const TypographyBlockquote: React$1.ForwardRefExoticComponent<TypographyBlockquoteProps & React$1.RefAttributes<HTMLQuoteElement>>;
 
-interface TypographyPProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
-}
+type TypographyPProps = React$1.HTMLAttributes<HTMLParagraphElement>;
 declare const TypographyP: React$1.ForwardRefExoticComponent<TypographyPProps & React$1.RefAttributes<HTMLParagraphElement>>;
 
-interface TypographyH6Props extends React$1.HTMLAttributes<HTMLHeadingElement> {
-}
+type TypographyH6Props = React$1.HTMLAttributes<HTMLHeadingElement>;
 declare const TypographyH6: React$1.ForwardRefExoticComponent<TypographyH6Props & React$1.RefAttributes<HTMLHeadingElement>>;
 
-interface TypographyH5Props extends React$1.HTMLAttributes<HTMLHeadingElement> {
-}
+type TypographyH5Props = React$1.HTMLAttributes<HTMLHeadingElement>;
 declare const TypographyH5: React$1.ForwardRefExoticComponent<TypographyH5Props & React$1.RefAttributes<HTMLHeadingElement>>;
 
-interface TypographyH4Props extends React$1.HTMLAttributes<HTMLHeadingElement> {
-}
+type TypographyH4Props = React$1.HTMLAttributes<HTMLHeadingElement>;
 declare const TypographyH4: React$1.ForwardRefExoticComponent<TypographyH4Props & React$1.RefAttributes<HTMLHeadingElement>>;
 
-interface TypographyH3Props extends React$1.HTMLAttributes<HTMLHeadingElement> {
-}
+type TypographyH3Props = React$1.HTMLAttributes<HTMLHeadingElement>;
 declare const TypographyH3: React$1.ForwardRefExoticComponent<TypographyH3Props & React$1.RefAttributes<HTMLHeadingElement>>;
 
-interface TypographyH2Props extends React$1.HTMLAttributes<HTMLHeadingElement> {
-}
+type TypographyH2Props = React$1.HTMLAttributes<HTMLHeadingElement>;
 declare const TypographyH2: React$1.ForwardRefExoticComponent<TypographyH2Props & React$1.RefAttributes<HTMLHeadingElement>>;
 
-interface TypographyH1Props extends React$1.HTMLAttributes<HTMLHeadingElement> {
-}
+type TypographyH1Props = React$1.HTMLAttributes<HTMLHeadingElement>;
 declare const TypographyH1: React$1.ForwardRefExoticComponent<TypographyH1Props & React$1.RefAttributes<HTMLHeadingElement>>;
 
 declare const Typography: {
@@ -4305,4 +5566,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, AgentHeader, type AgentHeaderProps, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AppStatusBar, type AppStatusBarProps, type Artifact, ArtifactCard, type ArtifactCardProps, ArtifactTable, type ArtifactTableProps, Avatar, AvatarFallback, AvatarGroup, type AvatarGroupProps, AvatarImage, type AvatarProps, Badge, type BadgeProps, 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, CaveatNote, type CaveatNoteProps, ChatSession, ChatSessionActivityRow, type ChatSessionActivityRowProps, type ChatSessionActivityStatus, ChatSessionActivitySubLine, type ChatSessionActivitySubLineProps, ChatSessionCaret, ChatSessionComposer, type ChatSessionComposerProps, ChatSessionContextChip, type ChatSessionContextChipProps, ChatSessionDisclosure, ChatSessionDisclosureCode, type ChatSessionDisclosureProps, ChatSessionDisclosureSteps, type ChatSessionDisclosureStepsProps, 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, ClarifyActions, type ClarifyActionsProps, ClarifyCard, type ClarifyCardProps, ClarifyFootnote, type ClarifyFootnoteProps, type ClarifyOption, type ClarifyState, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextBar, type ContextBarProps, DataReach, type DataReachModel, type DataReachProps, type DeclaredAxes, DiagnosisCard, type DiagnosisCardProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiffList, type DiffListProps, type DiffOp, DiffRow, type DiffRowProps, DotRating, type DotRatingProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type EgressClass, EgressList, type EgressListProps, EmissionBody, EmissionCard, type EmissionCardProps, EmissionHeader, type EmissionHeaderProps, type EmissionKind, EmptyState, EmptyStateLock, type EmptyStateLockProps, type EmptyStateProps, ErrorBoundary, type ErrorBoundaryProps, type ExchangeOption, ExchangeRecord, type ExchangeRecordProps, ExpandToggle, type ExpandToggleProps, type ExpandedKeys, Eyebrow, type EyebrowProps, FilterBar, type FilterBarProps, FilterChip, type FilterChipOption, type FilterChipProps, FloatingPanel, type FloatingPanelProps, Gantt, type GanttBar, type GanttBracket, GanttDetailCard, type GanttDetailCardProps, type GanttDetailProps, type GanttInstant, type GanttProps, type GanttRow, type GanttSeam, type GanttStatus, 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 KnownMetricTone, type KnownParticipantVerdict, type KnownRunKind, type KnownRunStatus, type KnownTerminalLevel, type Layer, LayerChip, type LayerChipProps, type LayerPaint, type LayerPalette, LayerSection, type LayerSectionProps, Legend, LegendItem, type LegendItemProps, type LegendProps, type LegendSwatchKind, LensRow, type LensRowProps, type LensUsage, Link, type LinkProps, LogCard, type LogCardProps, type LogFloor, type LogLine, 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, MultiFilterChip, type MultiFilterChipProps, 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, Questionnaire, QuestionnaireActions, QuestionnaireChoice, QuestionnaireChoiceDescription, type QuestionnaireChoiceFigure, type QuestionnaireChoiceProps, QuestionnaireChoiceTitle, QuestionnaireChoices, QuestionnaireDescription, QuestionnaireError, type QuestionnaireFigureTone, QuestionnaireInput, type QuestionnaireInputProps, QuestionnaireItem, QuestionnaireNext, QuestionnairePrevious, QuestionnaireProgress, QuestionnaireProgressBar, QuestionnaireSkip, QuestionnaireSubmit, QuestionnaireTitle, RatingControl, type RatingControlProps, RecordHeader, type RecordHeaderProps, RecordPager, type RecordPagerProps, RefusalCard, type RefusalCardProps, RepairNote, type RepairNoteProps, ResizableHandle, ResizablePanel, ResizablePanelGroup, RetryNote, type RetryNoteProps, RichSelect, type RichSelectAction, type RichSelectOption, type RichSelectProps, type RichSelectToggle, type RuleEgress, type RuleProperties, RuleRow, type RuleRowProps, type RuleSelect, type RunKind, RunRow, type RunRowProps, type RunStatus, RunStatusText, type RunStatusTextProps, ScopeLine, type ScopeLineChoice, type ScopeLinePart, type ScopeLineProps, 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, Spinner, Stack, type StackProps, StatusDot, type StatusDotProps, StatusIcon, type StatusIconProps, type StatusIconState, type TabConfig, TabbedPanel, type TabbedPanelProps, Table, TableBody, TableCaption, TableCell, type TableDensity, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, 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, TimelineSection, type TimelineSectionProps, type TimelineVariant, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Toolbar, type ToolbarAction, type ToolbarItem, type ToolbarProps, type ToolbarSeparator, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, 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 UseExpandedKeysOptions, type UseOverflowItemsOptions, type UseOverflowItemsResult, type UseTourOptions, type Verdict, Workbook, type WorkbookAction, type WorkbookPage, type WorkbookPageMenuItem, type WorkbookProps, agentChipVariants, avatarVariants, badgeVariants, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, describeSlice, formatRecords, layerLabel, layerPaint, linkVariants, navigationMenuTriggerStyle, ICON as runStatusIcons, TONE as runStatusTones, split as splitAddress, stackVariants, statusDotVariants, statusIconVariants, summarizeReach, toggleVariants, useExpandedKeys, useOverflowItems, useSidebar, useTour };