@invana/ui 0.0.20 → 0.0.22

package/dist/index.d.ts

@@ -60,12 +60,29 @@ declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.Ava
 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>>;
 
+/**
+ * `variant` is the treatment, `tone` is the meaning.
+ *
+ * They are separate axes on purpose: "this is a warning" and "this is filled
+ * rather than outlined" are different questions, and crossing them into one
+ * enum (`warning-soft`, `warning-outline`, …) multiplies into a list nobody can
+ * hold. A tone sets two custom properties; the treatments read them. So `tone`
+ * 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.
+ */
 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;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }
-declare function Badge({ className, variant, ...props }: BadgeProps): React$1.JSX.Element;
+declare function Badge({ className, variant, tone, size, ...props }: BadgeProps): React$1.JSX.Element;
 
 declare const Breadcrumb: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
     separator?: React$1.ReactNode;
@@ -87,7 +104,7 @@ declare const BreadcrumbEllipsis: {
 
 declare const buttonVariants: (props?: ({
     variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | "soft" | null | undefined;
-    size?: "default" | "sm" | "lg" | "icon" | "nav-icon" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon-xs" | "icon" | "nav-icon" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
@@ -265,9 +282,10 @@ declare function ItemGroup({ className, ...props }: React$1.ComponentProps<"div"
 declare function ItemSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): React$1.JSX.Element;
 declare const itemVariants: (props?: ({
     variant?: "default" | "outline" | "muted" | null | undefined;
-    size?: "default" | "sm" | null | undefined;
+    size?: "default" | "xs" | "sm" | null | undefined;
+    selected?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Item({ className, variant, size, asChild, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof itemVariants> & {
+declare function Item({ className, variant, size, selected, asChild, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof itemVariants> & {
     asChild?: boolean;
 }): React$1.JSX.Element;
 declare const itemMediaVariants: (props?: ({
@@ -350,7 +368,15 @@ declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
 declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
 declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * `sm` (4px) is the inline meter — a budget bar under a figure, a quota in a
+ * row. At that height it reads as part of the number above it rather than as a
+ * control, which is the point: nobody drags it.
+ */
+type ProgressSize = "default" | "sm";
+declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    size?: ProgressSize;
+} & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const ResizablePanelGroup: (props: React.ComponentProps<typeof Group>) => React$1.JSX.Element;
 declare const ResizablePanel: typeof Panel;
@@ -367,7 +393,7 @@ declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.Dial
 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> {
 }
@@ -457,7 +483,42 @@ declare const Toaster: ({ ...props }: ToasterProps) => React$1.JSX.Element;
 
 declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): React$1.JSX.Element;
 
-declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+/**
+ * The state of one thing, as a dot.
+ *
+ * It appears beside almost everything that has a state — a step in a run, an
+ * agent in a roster, a dataset, a schedule firing, a node type in a legend.
+ * Extracted from `ChatSessionTaskRow`, which had grown its own copy: the same
+ * six states were being re-declared per surface, and two of them had already
+ * drifted apart.
+ *
+ * `rounded-full` is correct here and not a violation of the radius rule — a
+ * status dot is one of the shapes where round *is* the object, alongside
+ * avatars and spinners (see `@invana/styling` › border radius).
+ *
+ * **A dot is never the only carrier of state.** Every use names the state
+ * beside it, or exposes it through `label`. Colour alone fails colour-blind
+ * readers, and a `running` pulse fails anyone with motion reduced — which the
+ * `motion-reduce` variant below honours by design.
+ */
+declare const statusDotVariants: (props?: ({
+    tone?: "success" | "warning" | "info" | "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> {
+    /**
+     * What this state is called, for a screen reader.
+     *
+     * Pass it when the dot is the only thing carrying the state. Omit it when
+     * the state is already written beside the dot, so it is not announced twice.
+     */
+    label?: string;
+}
+declare const StatusDot: React$1.ForwardRefExoticComponent<StatusDotProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & {
+    density?: "default" | "compact";
+} & 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>>;
 declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
@@ -466,7 +527,21 @@ declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttribu
 declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
 declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
 
-declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Density for a tab strip.
+ *
+ * `sm` (28px) is the application tab strip — a panel's views, a canvas's open
+ * tabs. It drops the list's inset background and padding: at that height the
+ * tray reads as a second toolbar, and the strip sits directly on the panel's
+ * own rule instead.
+ *
+ * Passed through context rather than as a prop on every part, so a caller sets
+ * it once on `<Tabs>` and the list and triggers follow.
+ */
+type TabsSize = "default" | "sm";
+declare const Tabs: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    size?: TabsSize;
+} & React$1.RefAttributes<HTMLDivElement>>;
 declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
@@ -489,11 +564,186 @@ 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>>;
 
+declare const agentChipVariants: (props?: ({
+    kind?: "agent" | "person" | null | undefined;
+    inactive?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AgentChipProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof agentChipVariants> {
+    /** A 12px lucide icon, or an `<Avatar>`. */
+    icon?: React$1.ReactNode;
+    name: React$1.ReactNode;
+}
+/**
+ * Who did this — an agent or a person — as a 22px chip.
+ *
+ * It appears wherever work has a holder: a task row's assignee, a step's actor,
+ * a skill's users, a rule's audience, a proposal's author.
+ *
+ * Deliberately not a `Badge`. A badge carries a *state* and takes a tone from
+ * the status palette; this carries an *identity* and must never look like a
+ * status. Same reason it does not take a colour: agents are told apart by name,
+ * not by hue.
+ */
+declare const AgentChip: React$1.ForwardRefExoticComponent<AgentChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const stateVariants: (props?: ({
+    tone?: "active" | "error" | "running" | "draft" | "review" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AppStatusBarProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stateVariants> {
+    /** The session's state — `ACTIVE`, `DRAFT`, `RUNNING`, `REVIEW`. */
+    state?: React$1.ReactNode;
+    /** What the session currently holds — `26 nodes · 41 edges · 60 fps`. */
+    children?: React$1.ReactNode;
+    /** Right-hand slot. The build version, usually. */
+    end?: React$1.ReactNode;
+}
+/**
+ * The 25px line at the bottom of the window.
+ *
+ * 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
+ * — a status bar that flickered with every route would stop being somewhere the
+ * eye can rest.
+ *
+ * Generalised from `ChatSessionStatusBar`, which is the same bar scoped to a
+ * thread. This one adds the state marker, because at the application level
+ * "what state is this in" is the first question and a bare row of counters does
+ * not answer it.
+ */
+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;
+    /**
+     * 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.
+     */
+    color?: string;
+    /** What the tip should read, if not the raw value. */
+    display?: 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;
+}
+/**
+ * Magnitude across a handful of named things.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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 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;
+}
+/**
+ * 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.
+ */
+declare const BarChartV: React$1.ForwardRefExoticComponent<BarChartVProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface ButtonWithTooltipProps extends ButtonProps {
     tooltip: React__default.ReactNode;
 }
 declare function ButtonWithTooltip(props: ButtonWithTooltipProps): React__default.JSX.Element;
 
+interface CannotAnswerCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** What the graph does not hold. One sentence, in the graph's own terms. */
+    children?: React$1.ReactNode;
+    /**
+     * What would change the answer — an import, a connector, a missing model.
+     *
+     * Not optional in spirit. A refusal without a next step is a dead end, and the
+     * reader is left unable to tell "never" from "not yet".
+     */
+    remedy?: React$1.ReactNode;
+    /** Overrides the label. Defaults to `cannot answer`. */
+    label?: React$1.ReactNode;
+}
+/**
+ * The graph does not hold what was asked.
+ *
+ * One of the four run outcomes, and its own component rather than a variant
+ * (DS8) — because it is neither a failure nor an empty answer, and it must not
+ * be reachable by flipping a prop on either.
+ *
+ * Dashed, and with **no citation strip**: there is nothing to cite, and an empty
+ * strip would read as an uncited claim. This is the surface that keeps the
+ * system's promise that it says so when it cannot answer.
+ */
+declare const CannotAnswerCard: React$1.ForwardRefExoticComponent<CannotAnswerCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface ChatSessionProps {
     /** The message list — typically `<ChatSessionMessage />` nodes. */
     children?: React$1.ReactNode;
@@ -806,6 +1056,304 @@ interface ChatSessionStatusBarProps {
  */
 declare function ChatSessionStatusBar({ start, end, className, }: ChatSessionStatusBarProps): React$1.JSX.Element;
 
+interface ChatSessionContextChipProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** A small icon for what is bound — a node, a dataset, a task. */
+    icon?: React$1.ReactNode;
+    /** What the question will be about — `Asking about obs_20260908_bpcl_01`. */
+    children?: React$1.ReactNode;
+    /** Unbinds it. Omit to make the binding fixed. */
+    onDismiss?: () => void;
+    dismissLabel?: string;
+}
+/**
+ * What the next question is about, shown above the composer.
+ *
+ * Selecting something on a canvas binds it here, so the thing you are looking
+ * at is the thing you are asking about — that is the whole point of the chip.
+ * It fills `ChatSessionComposer`'s `attachments` slot rather than living inside
+ * the composer, because what is bound is the surface's business, not the
+ * composer's.
+ *
+ * It states the binding in words. A highlight on the canvas alone would leave
+ * the reader guessing what scope their question has.
+ */
+declare function ChatSessionContextChip({ icon, onDismiss, dismissLabel, className, children, ...props }: ChatSessionContextChipProps): 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;
+    /** 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;
+}
+interface CitationListProps extends React$1.HTMLAttributes<HTMLUListElement> {
+    children?: React$1.ReactNode;
+}
+/**
+ * The records an answer rests on.
+ *
+ * Every claim in this system is traceable to records, and this is where that
+ * trace is read. A row names the **kind** first because that is what tells the
+ * reader whether the claim is grounded in the right sort of evidence — a
+ * recommendation citing three Articles and no Bar is a different thing from one
+ * citing both.
+ *
+ * `source` is not optional in spirit: a citation you cannot locate is not a
+ * citation. An absent one should mean the record has no source, not that the
+ * caller could not be bothered.
+ */
+declare const CitationList: React$1.ForwardRefExoticComponent<CitationListProps & React$1.RefAttributes<HTMLUListElement>>;
+declare const CitationRow: React$1.ForwardRefExoticComponent<CitationRowProps & React$1.RefAttributes<HTMLLIElement>>;
+
+interface ClarifyOption {
+    /** Stable id handed back to `onSelect`. */
+    value: string;
+    /** The choice, in the user's terms — `Theme velocity, 5 sessions`. */
+    label: React$1.ReactNode;
+    /**
+     * Where the choice comes from in the model — `Theme.velocity_5d · 14 themes`.
+     *
+     * This is what makes the question answerable rather than a guess: the reader
+     * can see that each option is a measure the graph actually holds.
+     */
+    detail?: React$1.ReactNode;
+    disabled?: boolean;
+}
+interface ClarifyCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** Which step asked — `understand`. */
+    step?: React$1.ReactNode;
+    /** How long it has been waiting — `parked 14 min`. */
+    waiting?: React$1.ReactNode;
+    /** The question. One sentence. */
+    question: React$1.ReactNode;
+    options: ClarifyOption[];
+    value?: string;
+    onSelect?: (value: string) => void;
+    /** The confirm control. */
+    actions?: React$1.ReactNode;
+    /** Why these options and not others. */
+    footnote?: React$1.ReactNode;
+}
+/**
+ * The run stopped and asked, rather than guessing.
+ *
+ * A thinking that cannot tell which of two measures was meant parks and asks —
+ * parked, not failed. Answering resumes *that* thinking rather than starting a
+ * new one, which is why this renders inline in the thread and not as a modal:
+ * the question belongs to the run above it.
+ *
+ * **Options are declared, never generated.** Each one names a measure the model
+ * 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.
+ */
+declare const ClarifyCard: React$1.ForwardRefExoticComponent<ClarifyCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface ContextBarProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * What this surface is showing — usually tabs, or a tab-shaped set of views.
+     * Sits first because it is the only thing here that changes what you see.
+     */
+    children?: React$1.ReactNode;
+    /**
+     * Counts and states about the current view — `1 running`, `2 in review`.
+     * Facts, never controls: nothing here should be clickable.
+     */
+    counters?: React$1.ReactNode;
+    /** The keyboard route out — `⌘↵ accept`, `⌘N new task`. */
+    hint?: React$1.ReactNode;
+}
+/**
+ * The 28px bar between a panel and the status bar.
+ *
+ * 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
+ * finishes it.
+ *
+ * Distinct from `AppStatusBar` below it: this describes the *surface* you are
+ * on and changes as you move around; the status bar describes the *session* and
+ * barely changes at all. Two bars because they answer different questions —
+ * merging them would make a stable line flicker with navigation.
+ */
+declare const ContextBar: React$1.ForwardRefExoticComponent<ContextBarProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface DiagnosisCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Where it broke and how — `execute · connection_refused`. Shown in mono. */
+    code: React$1.ReactNode;
+    /** One sentence a person can act on. Not a stack trace. */
+    children?: React$1.ReactNode;
+    /** The query, command or request that was attempted. Mono, wraps. */
+    attempted?: React$1.ReactNode;
+    /** What it ran against, and how hard — `bolt://…:7687 · 2 attempts · 4.1s`. */
+    target?: React$1.ReactNode;
+    /** `Open the trace`, `Retry`. */
+    actions?: React$1.ReactNode;
+}
+/**
+ * Something broke, and it is named.
+ *
+ * One of the four run outcomes, and its own component (DS8) — a failure must
+ * never be one prop away from an answer.
+ *
+ * Built from evidence: what was tried, against what, how many times. It carries
+ * its next step, and nothing partial is dressed up as a result — which is why
+ * there is no slot here for "the rows we did get".
+ */
+declare const DiagnosisCard: React$1.ForwardRefExoticComponent<DiagnosisCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type DiffOp = "add" | "remove" | "change";
+interface DiffRowProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "children"> {
+    op?: DiffOp;
+    /** What kind of thing changed — `node`, `edge`, `property`. */
+    kind?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+}
+interface DiffListProps extends React$1.HTMLAttributes<HTMLUListElement> {
+    children?: React$1.ReactNode;
+}
+/**
+ * What a change would do, before it is committed.
+ *
+ * Staged model edits, a schedule's firing diff against the previous run, a
+ * proposal's additions. It is a *preview*, which is why the sign is spelled out
+ * per row rather than implied by colour alone — a reader who cannot separate
+ * red from green still has to be able to tell an addition from a removal before
+ * approving it.
+ */
+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>>;
+
+/**
+ * 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.
+ */
+type EmissionKind = "metric" | "table" | "chart" | "subgraph" | "prose" | "empty" | "html";
+interface EmissionHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    kind: EmissionKind;
+    /** The projection template that rendered it — `table-compact@3`. Shown in mono. */
+    template?: React$1.ReactNode;
+    /**
+     * What the answer is grounded in — `cite · 214 records`.
+     *
+     * Absent means *not applicable*, not *none*: an emission with nothing to cite
+     * says so with `0 records`. A missing strip must never read as an uncited
+     * claim.
+     */
+    citation?: React$1.ReactNode;
+    /** A short state word — `in use`, `switched`. */
+    note?: React$1.ReactNode;
+    /** Trailing controls, usually the template switcher. */
+    actions?: React$1.ReactNode;
+}
+interface EmissionCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title">, Omit<EmissionHeaderProps, keyof React$1.HTMLAttributes<HTMLDivElement>> {
+    /** Set false to render the body alone, where a surface supplies its own header. */
+    showHeader?: boolean;
+    children?: React$1.ReactNode;
+}
+/**
+ * The strip that says what an emission is and what it is grounded in.
+ *
+ * One component wherever an emission appears — the assistant thread, a task
+ * 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.
+ */
+declare const EmissionHeader: React$1.ForwardRefExoticComponent<EmissionHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * One rendered piece of an answer.
+ *
+ * Every emission renders through this card, whatever its kind (DS9): a metric,
+ * a table, a chart, a subgraph, cited prose, an empty result. That is what makes
+ * an answer scannable — the reader learns one shape and then only reads the
+ * body.
+ *
+ * The card takes a **kind, a template name and children** — never a domain
+ * 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`.
+ */
+declare const EmissionCard: React$1.ForwardRefExoticComponent<EmissionCardProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * The `prose` body's citation marker — the superscript that ties a clause to
+ * the records behind it.
+ */
+declare const CitationMarker: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLElement> & React$1.RefAttributes<HTMLElement>>;
+
+interface EmptyStateProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** An icon or illustration. Sized by the caller. */
+    icon?: React$1.ReactNode;
+    /** What is not here — `Nothing loaded yet`. States the fact, not an apology. */
+    title: React$1.ReactNode;
+    /** The path out of it, in order. */
+    description?: React$1.ReactNode;
+    /** Live actions the user can take now. */
+    actions?: React$1.ReactNode;
+    /** What is not available yet, and what unlocks it. See `EmptyStateLock`. */
+    locks?: React$1.ReactNode;
+}
+interface EmptyStateLockProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    icon?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+}
+/**
+ * A surface with nothing in it yet.
+ *
+ * The important half is `locks`. An empty product that only says "nothing here"
+ * leaves the user guessing whether they are stuck or simply early; naming the
+ * thing that unlocks each surface turns an empty screen into a sequence.
+ *
+ * Separate from `UnderDevelopment`, which says *we* have not built it. This one
+ * says *you* have not filled it — different cause, different next step.
+ */
+declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
+/** 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<{
     children: ReactNode;
 }, {
@@ -821,6 +1369,131 @@ declare class ErrorBoundary extends Component<{
     render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
 }
 
+interface FilterBarProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** The filter controls. `FilterChip`s, a `SearchInput`, a toggle. */
+    children?: React$1.ReactNode;
+    /**
+     * What the filters left behind — `8 datasets`, `6 tasks`, `7 waiting`.
+     *
+     * Sits after a spacer, hard right. It is the answer to the question the
+     * filters ask, so it belongs on the same line as them and nowhere else.
+     */
+    summary?: React$1.ReactNode;
+}
+interface FilterChipProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "value"> {
+    /** The dimension — `status`, `kind`, `agent`, `age`. */
+    label: React$1.ReactNode;
+    /** What it is narrowed to. Absent means "not filtered". */
+    value?: React$1.ReactNode;
+    /** Marks the chip as narrowing the list, so an active filter is visible while scrolling. */
+    active?: boolean;
+}
+/**
+ * The row above a list that narrows it.
+ *
+ * Every list surface in the system has one: the roster, datasets, tasks,
+ * schedules, workflows, the review queue. It is a `<Toolbar>`-shaped thing but
+ * kept separate — a toolbar holds actions that *do* something, this holds
+ * controls that *hide* rows, and mixing them costs the reader the guarantee
+ * that nothing here changes their data.
+ */
+declare const FilterBar: React$1.ForwardRefExoticComponent<FilterBarProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * 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.
+ */
+declare const FilterChip: React$1.ForwardRefExoticComponent<FilterChipProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * 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 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;
+}
+/**
+ * A run of firings, one square each, in time order.
+ *
+ * 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.
+ *
+ * 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.
+ */
+declare const HeatStrip: React$1.ForwardRefExoticComponent<HeatStripProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type LegendSwatchKind = "dot" | "line" | "dashed" | "arrow" | "ring";
+interface LegendItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "color"> {
+    /**
+     * What the mark looks like on the canvas. A legend that draws a dot for
+     * something rendered as a dashed line is worse than no legend.
+     */
+    kind?: LegendSwatchKind;
+    /**
+     * The mark's colour — a CSS colour or, preferably, a data-palette token:
+     * `var(--color-data-3)`. Defaults to the current text colour.
+     */
+    color?: string;
+    label: React$1.ReactNode;
+    /** Trailing count — `1,912`, `52,100`. */
+    count?: React$1.ReactNode;
+}
+interface LegendProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** `row` wraps inline under a canvas; `column` stacks in a panel. */
+    orientation?: "row" | "column";
+    children?: React$1.ReactNode;
+}
+/**
+ * What the colours on a canvas mean.
+ *
+ * Every canvas in the system carries one: node types, edge kinds, run outcomes,
+ * schedule firings, plan dependencies. It is the other half of the rule that
+ * colour never carries meaning alone — the palette says which hue, the legend
+ * says what the hue is.
+ *
+ * `kind` exists because these canvases draw more than dots. A dependency that
+ * renders as a dashed arrow needs a dashed arrow in the legend, or the legend
+ * is describing a different picture.
+ */
+declare const Legend: React$1.ForwardRefExoticComponent<LegendProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const LegendItem: React$1.ForwardRefExoticComponent<LegendItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface MenuItemProps extends MenuItem {
     level?: number;
 }
@@ -836,6 +1509,59 @@ interface MenuItem {
 }
 declare const MenuItem: React$1.FC<MenuItemProps>;
 
+interface MetricTileProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** What is being measured — `accepted`, `served (plan.verified)`, `hit rate`. */
+    label: React$1.ReactNode;
+    /** The number. `31 of 38`, `91%`, `9.6 s`, `$38.20`. */
+    value: React$1.ReactNode;
+    /** Why the number is what it is — the denominator, the window, the caveat. */
+    caption?: React$1.ReactNode;
+    /** A bar, a sparkline, anything that sits under the value. */
+    children?: React$1.ReactNode;
+}
+interface MetricGridProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Smallest a tile may get before the grid drops a column. */
+    minTileWidth?: number;
+    children?: React$1.ReactNode;
+}
+/**
+ * One number, with enough around it to be read correctly.
+ *
+ * `caption` is not decoration. A tile that says `91%` and nothing else invites
+ * the reader to supply their own denominator; `of thinkings` stops that. If
+ * there is no honest caption, the number probably needs a different surface.
+ */
+declare const MetricTile: React$1.ForwardRefExoticComponent<MetricTileProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Tiles at whatever width the panel gives them.
+ *
+ * `auto-fit` rather than a column count, because the same set of tiles appears
+ * in a 420px panel and across a full-width board and should not need a
+ * different call site for each.
+ */
+declare const MetricGrid: React$1.ForwardRefExoticComponent<MetricGridProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * NavMenuItem - one row of the dropdown a nav item can open. Give an item
+ * `menuItems` and it becomes a menu trigger instead of a plain button: the
+ * `…` overflow in a panel header, a "New…" split action, an account menu.
+ */
+interface NavMenuItem {
+    /** Unique identifier within the menu. */
+    id: string;
+    /** Row label — a string, or any node if you need your own markup. */
+    label: React__default.ReactNode;
+    /** Optional leading icon component. */
+    icon?: React__default.ElementType;
+    /** Keyboard hint, shown right-aligned (display only — bind the key yourself). */
+    shortcut?: string;
+    disabled?: boolean;
+    /** Render the row in the destructive colour (delete, drop, remove…). */
+    destructive?: boolean;
+    /** Draw a separator immediately above this row. */
+    separatorBefore?: boolean;
+    onSelect?: () => void;
+}
 /**
  * NavItemConfig - Shared configuration for a single navigation item, used by
  * both NavHorizontal and NavVertical. An item renders as an `<a>` (when `href`
@@ -868,6 +1594,24 @@ interface NavItemConfig {
     icon?: React__default.ElementType | LucideIcon;
     /** Custom tooltip content (overrides name) */
     tooltip?: React__default.ReactNode;
+    /**
+     * Rows of a dropdown opened by this item. With `menuItems` the item is a
+     * menu trigger — it needs no `onClick`, and stays highlighted while its menu
+     * is open. Ignored when `href` is set.
+     */
+    menuItems?: NavMenuItem[];
+    /**
+     * A count pinned to the item's top-right — unread reviews, waiting questions.
+     *
+     * The one place in the kit where a rounded capsule is right: a count bubble
+     * is a round object, not a rectangle with soft ends (see `@invana/styling`
+     * › border radius). Keep it short; it is a signal, not a readout.
+     *
+     * The badge text sits inside the item, so it contributes to the accessible
+     * name; the item's `name` reaches assistive tech through its tooltip. Pass a
+     * bare number — anything longer belongs in the tooltip.
+     */
+    badge?: React__default.ReactNode;
 }
 interface NavItemsProps {
     items: NavItemConfig[];
@@ -1069,18 +1813,51 @@ interface NestedMenuProps {
 declare const NestedMenu: React__default.FC<NestedMenuProps>;
 
 interface PanelContentProps {
+    /** Header title as a node — rendered as-is, so you own its typography. */
     title?: React__default.ReactNode;
+    /** Header title as plain text, rendered in the default panel header style. */
     titleText?: string;
     children?: React__default.ReactNode;
+    /** Classes for the outer card. */
+    className?: string;
     headerClassName?: string;
     bodyClassName?: string;
     footerContent?: React__default.ReactNode;
     footerClassName?: string;
-    onClose?: () => void;
-    showClose?: boolean;
-    closeIcon?: React__default.ReactNode;
+    /**
+     * Actions on the right of the title bar, as `NavHorizontal` items. A panel
+     * header has one action area — the right — so this is the item list itself
+     * rather than the full `NavHorizontal` props that `PanelStack` and
+     * `TabbedPanel` take: there is no left or centre slot to fill here, and the
+     * title already owns the left.
+     *
+     * Give an item `menuItems` and it becomes a `…` overflow dropdown.
+     *
+     * ```tsx
+     * headerActions={[
+     *   { name: "Refresh", icon: RefreshCw, onClick: refetch },
+     *   { name: "More options", icon: MoreHorizontal, menuItems: [
+     *     { id: "export", label: "Export as CSV", onSelect: exportCsv },
+     *   ] },
+     *   { name: "Close panel", icon: X, onClick: close },
+     * ]}
+     * ```
+     *
+     * Closing is one of these and nothing more — there is no `onClose` prop. A
+     * panel that dismisses lists a close item like any other action, which is
+     * why the two look and behave identically.
+     */
+    headerActions?: NavHorizontalItem[];
+    /**
+     * Keep the header actions hidden until the header is hovered or focused (or
+     * a menu inside them is open). Defaults to `false` — unlike a `PanelStack`
+     * section, a `PanelContent` is one panel rather than one of a column, so its
+     * actions are not noise. A close affordance in particular should not have to
+     * be hunted for.
+     */
+    actionsOnHover?: boolean;
 }
-declare function PanelContent({ title, titleText, children, onClose, showClose, headerClassName, bodyClassName, footerContent, footerClassName, closeIcon }: PanelContentProps): React__default.JSX.Element;
+declare function PanelContent({ title, titleText, children, className, headerClassName, bodyClassName, footerContent, footerClassName, headerActions, actionsOnHover, }: PanelContentProps): React__default.JSX.Element;
 
 interface PanelStackSection {
     /** Unique identifier for the section within the stack. */
@@ -1098,10 +1875,29 @@ interface PanelStackSection {
     /** Optional leading icon component, shown before the title. */
     icon?: React$1.ElementType;
     /**
-     * Header actions (buttons, badges) rendered on the right of the title bar.
-     * Only shown while the section is expanded, mirroring VS Code's view header.
+     * Actions on the right of the title bar, as `NavHorizontal` items — the same
+     * list `PanelContent` and `TabbedPanel` take, so a header is described once
+     * and reads the same everywhere. A header has one action area, so this is
+     * the item list itself rather than left/centre/right slots; the title owns
+     * the left. Give an item `menuItems` and it becomes the `…` overflow
+     * dropdown.
+     *
+     * ```tsx
+     * headerActions: [
+     *   { name: "Refresh", icon: RefreshCw, onClick: refetch },
+     *   { name: "More options", icon: MoreHorizontal, menuItems: [
+     *     { id: "sort", label: "Sort oldest first", onSelect: sort },
+     *   ] },
+     * ]
+     * ```
      */
-    actions?: React$1.ReactNode;
+    headerActions?: NavHorizontalItem[];
+    /**
+     * 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`.
+     */
+    actionsOnHover?: boolean;
     /** Start the section collapsed (header only). Defaults to `false`. */
     defaultCollapsed?: boolean;
     /**
@@ -1157,6 +1953,145 @@ interface PanelStackProps {
  */
 declare function PanelStack({ sections, headerHeight, withHandle, className, headerClassName, bodyClassName, }: PanelStackProps): React$1.JSX.Element;
 
+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.
+     */
+    labelWidth?: number | string;
+    children?: React$1.ReactNode;
+}
+interface PropertyRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    label: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    /** Renders the value in the mono face — an id, a key, a query fragment. */
+    mono?: boolean;
+}
+/**
+ * What one selected thing *is*, as label/value pairs.
+ *
+ * The inspector's body: a node's properties, an agent's bindings, a proposal's
+ * draft, a run's parameters. A `<dl>` because that is what this is — pairs, not
+ * a two-column table and not a form.
+ *
+ * The label column is fixed by the list rather than by each row, so values line
+ * up down the panel. A ragged value column is the thing that makes an inspector
+ * read as noise.
+ */
+declare const PropertyList: React$1.ForwardRefExoticComponent<PropertyListProps & React$1.RefAttributes<HTMLDListElement>>;
+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;
+    /** Where it came from — `from the agent's result`. */
+    source?: React$1.ReactNode;
+    /** The draft itself. A `PropertyList`, usually. */
+    children?: React$1.ReactNode;
+    /** What the proposal rests on — the instances, as a table or list. */
+    evidence?: React$1.ReactNode;
+    /** A heading for the evidence — `The six instances`. */
+    evidenceTitle?: React$1.ReactNode;
+    /** Scope of the evidence — `30 days`. */
+    evidenceMeta?: React$1.ReactNode;
+    /** What authoring would actually write. */
+    consequence?: React$1.ReactNode;
+    /** Author / reject / reassign. */
+    actions?: React$1.ReactNode;
+}
+/**
+ * An agent proposes; a person publishes.
+ *
+ * Nothing here exists in the graph yet — the draft is a shape the agent found,
+ * and authoring is what writes it. The card is built so that separation is
+ * legible: the draft and the evidence it rests on are shown together, so the
+ * decision is made against the instances rather than against a summary of them.
+ *
+ * `consequence` says what authoring will write. A person approving something
+ * should not have to infer the side effects.
+ */
+declare const ProposalCard: React$1.ForwardRefExoticComponent<ProposalCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type Verdict = "appreciate" | "depreciate";
+interface DotRatingProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    value: number;
+    max?: number;
+    onChange?: (value: number) => void;
+    /** Read-only display, e.g. inside a history entry. */
+    readOnly?: boolean;
+    label?: string;
+}
+interface RatingControlProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    verdict?: Verdict;
+    onVerdictChange?: (v: Verdict) => void;
+    weight: number;
+    onWeightChange?: (w: number) => void;
+    maxWeight?: number;
+    /** What the rating refines — a pattern name. */
+    refines?: React$1.ReactNode;
+    /** Who is rating. An `AgentChip`, usually. */
+    by?: React$1.ReactNode;
+    /** The note field, and anything else the caller wants under the controls. */
+    children?: React$1.ReactNode;
+}
+/**
+ * A small integer, as dots.
+ *
+ * Weight is 1–3, so a slider or a number input would both be heavier than the
+ * value they carry. Dots read at a glance and are still a real radio group
+ * underneath. Lives beside `RatingControl` rather than in `ui/` because it is
+ * the only thing that uses it; promote it if a second caller appears.
+ */
+declare const DotRating: React$1.ForwardRefExoticComponent<DotRatingProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * A person's verdict on an agent's result.
+ *
+ * This is the capture signal the learning loop runs on: accepting or rejecting
+ * with a weight becomes a Learning that rates the observation and refines the
+ * pattern behind it. So the control states its consequence rather than implying
+ * it — `by` and `refines` are shown on the control itself.
+ *
+ * Appreciate and depreciate are one control with two positions, not two
+ * buttons: it is a single decision with a sign, and two buttons would invite
+ * pressing both.
+ */
+declare const RatingControl: React$1.ForwardRefExoticComponent<RatingControlProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface RepairNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** What was wrong — `unknown property Theme.velocity5d`. */
+    from: React$1.ReactNode;
+    /** What it became — `Theme.velocity_5d`. */
+    to: React$1.ReactNode;
+}
+/**
+ * The query went back once, carrying its error, and came back correct.
+ *
+ * One of the four run outcomes (DS8). It renders **on the step that repaired
+ * it**, never as a message in the thread — a repair is a detail of how the
+ * answer was reached, not something asked of the reader. Promoting it to a card
+ * would make a successful run look like a problem.
+ */
+declare const RepairNote: React$1.ForwardRefExoticComponent<RepairNoteProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface RetryNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Which attempt this is — `retry 1 of 2`. */
+    attempt?: React$1.ReactNode;
+    /** What happened, in time — `no response in 2.0s; the second returned in 0.6s`. */
+    children?: React$1.ReactNode;
+}
+/**
+ * The database was slow, not wrong.
+ *
+ * One of the four run outcomes (DS8), and like a repair it renders on its step
+ * rather than as a card. Transient: nothing is asked of the reader, because it
+ * is already retrying — visibly — and the answer still arrives.
+ *
+ * Separate from `RepairNote` on purpose. A retry means *the same query, again*;
+ * a repair means *a different query*. Collapsing them into one component with a
+ * `reason` prop would lose the only distinction that matters to the reader.
+ */
+declare const RetryNote: React$1.ForwardRefExoticComponent<RetryNoteProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface RichSelectOption {
     /** Stable key used as the selection value. */
     value: string;
@@ -1218,6 +2153,88 @@ interface RichSelectProps {
  */
 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;
 
+/**
+ * `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.
+ *
+ * Named `inputSize` for the same reason `Input` is: `size` is already an
+ * `<input>` attribute meaning "how many characters wide".
+ */
+type SearchInputSize = 'default' | 'sm';
+interface SearchInputProps extends Omit<React__default.ComponentProps<'input'>, 'value' | 'onChange' | 'size' | 'type'> {
+    className?: string;
+    value: string;
+    /** Receives the raw string, not the event — a search box has one value. */
+    onChange: (value: string) => void;
+    inputSize?: SearchInputSize;
+}
+declare const SearchInput: React__default.FC<SearchInputProps>;
+
+interface SectionHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Sits before the title. A 14px lucide icon, usually. */
+    icon?: React$1.ReactNode;
+    /** What this section is. */
+    title: React$1.ReactNode;
+    /**
+     * How many things are in it — `4`, `6 shown · 1 hidden`, `derived`.
+     *
+     * Kept separate from `actions` because a count is a fact about the section
+     * and an action is something you do to it. They read differently and they
+     * align differently.
+     */
+    count?: React$1.ReactNode;
+    /** Trailing controls — `+ add`, `edit`, a toggle. */
+    actions?: React$1.ReactNode;
+    /** Renders the header without its bottom rule, for a section that opens a card. */
+    bare?: boolean;
+}
+/**
+ * The bar that titles one section of a panel.
+ *
+ * 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.
+ *
+ * The end marker carries a 2px ring in the surface colour so it stays legible
+ * where the line runs under it.
+ */
+declare const Sparkline: React$1.ForwardRefExoticComponent<SparklineProps & React$1.RefAttributes<SVGSVGElement>>;
+
 interface TabConfig {
     /** Unique identifier for the tab */
     value: string;
@@ -1239,8 +2256,22 @@ interface TabbedPanelProps {
     activeTab?: string;
     /** Callback when tab changes */
     onTabChange?: (value: string) => void;
-    /** Full NavHorizontal props for header right-side actions */
-    headerActions?: NavHorizontalProps;
+    /**
+     * 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
+     * rather than full `NavHorizontal` props: the tabs already own the left.
+     *
+     * Give an item `menuItems` and it becomes a `…` overflow dropdown. Closing
+     * is one of these items and nothing more; there is no close prop.
+     *
+     * ```tsx
+     * headerActions={[
+     *   { name: "Split editor", icon: Columns2, onClick: split },
+     *   { name: "Close panel", icon: X, onClick: close },
+     * ]}
+     * ```
+     */
+    headerActions?: NavHorizontalItem[];
     /** Additional CSS classes for the container */
     className?: string;
     /** Additional CSS classes for the header */
@@ -1251,21 +2282,107 @@ interface TabbedPanelProps {
     footerClassName?: string;
     /** Optional footer content */
     footerContent?: React__default.ReactNode;
-    /** Whether to show default close button */
-    showClose?: boolean;
-    /** Callback when close button is clicked */
-    onClose?: () => void;
-    /** Custom close icon component */
-    closeIcon?: React__default.ReactNode;
 }
-declare function TabbedPanel({ tabs, defaultTab, activeTab, onTabChange, headerActions, className, headerClassName, bodyClassName, footerClassName, footerContent, showClose: _showClose, onClose: _onClose, closeIcon: _closeIcon, }: TabbedPanelProps): React__default.JSX.Element;
+declare function TabbedPanel({ tabs, defaultTab, activeTab, onTabChange, headerActions, className, headerClassName, bodyClassName, footerClassName, footerContent, }: TabbedPanelProps): React__default.JSX.Element;
 
-interface SearchInputProps {
-    className?: string;
-    value: string;
-    onChange: (value: string) => void;
+interface TemplateOption {
+    /** The projection template — `table-compact@3`. */
+    id: string;
+    kind: EmissionKind;
+    /**
+     * Why it cannot be used on these records — `needs a time column`,
+     * `needs 1 record, has 4`.
+     *
+     * Present means unavailable. Saying *why* is the point: a greyed row with no
+     * reason reads as a bug.
+     */
+    unavailable?: React$1.ReactNode;
+    /** A note on an available row — `in use`, `sandboxed`. */
+    note?: React$1.ReactNode;
 }
-declare const SearchInput: React__default.FC<SearchInputProps>;
+interface TemplatePickerProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** How many records are being re-rendered — `Render these 4 records as`. */
+    heading?: React$1.ReactNode;
+    options: TemplateOption[];
+    value?: string;
+    onSelect?: (id: string) => void;
+    /** The reassurance under the list. */
+    footnote?: React$1.ReactNode;
+}
+/**
+ * Render the same records a different way.
+ *
+ * It hangs off an emission's header, because a template belongs to **that
+ * emission** — not to the thread, and not to a setting somewhere else.
+ *
+ * Switching re-renders from records already in hand: **the query does not run
+ * 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";
+interface TerminalLineProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    kind?: TerminalLineKind;
+    /**
+     * 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>>;
+
+interface TimelineEntryProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "title"> {
+    /** When — `Fri 5 Sep`, `09:47`, `Sun`. */
+    when: React$1.ReactNode;
+    /** A one-line summary. The body below carries the detail. */
+    title?: React$1.ReactNode;
+    /** A marker in the rail — a `StatusDot`, usually. */
+    marker?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+}
+interface TimelineListProps extends React$1.HTMLAttributes<HTMLOListElement> {
+    children?: React$1.ReactNode;
+}
+/**
+ * What happened, newest first.
+ *
+ * A task's history, a session's past rounds, a schedule's firings. An `<ol>`
+ * because the order carries meaning — these are events in sequence, not a set.
+ *
+ * `when` is a column rather than a line above the entry, so a reader scanning
+ * for "what changed on Friday" reads down one edge instead of hunting through
+ * prose.
+ */
+declare const TimelineList: React$1.ForwardRefExoticComponent<TimelineListProps & React$1.RefAttributes<HTMLOListElement>>;
+declare const TimelineEntry: React$1.ForwardRefExoticComponent<TimelineEntryProps & React$1.RefAttributes<HTMLLIElement>>;
 
 declare const Toolbar: React__default.FC;
 
@@ -1481,4 +2598,4 @@ declare const Typography: {
     Pre: React$1.ForwardRefExoticComponent<TypographyPreProps & React$1.RefAttributes<HTMLPreElement>>;
 };
 
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, type BaseNavProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, ButtonGroupSeparator, ButtonGroupText, type ButtonProps, ButtonWithTooltip, type ButtonWithTooltipProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CardWithHeader, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, ChatSession, ChatSessionActivityRow, type ChatSessionActivityRowProps, type ChatSessionActivityStatus, ChatSessionActivitySubLine, type ChatSessionActivitySubLineProps, ChatSessionComposer, type ChatSessionComposerProps, 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, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ErrorBoundary, HoverCard, HoverCardContent, HoverCardTrigger, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, Kbd, KbdGroup, MenuItem, type MenuItemProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, NavBase, NavHorizontal, type NavHorizontalItem, NavHorizontalItems, type NavHorizontalItemsProps, type NavHorizontalProps, type NavItemConfig, NavItems, type NavItemsProps, 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, PanelContent, type PanelContentProps, PanelStack, type PanelStackProps, type PanelStackSection, Popover, PopoverContent, PopoverTrigger, Progress, ResizableHandle, ResizablePanel, ResizablePanelGroup, RichSelect, type RichSelectOption, type RichSelectProps, ScrollArea, ScrollBar, SearchInput, 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, Spinner, type TabConfig, TabbedPanel, type TabbedPanelProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Toolbar, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, 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 UseTourOptions, badgeVariants, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, navigationMenuTriggerStyle, toggleVariants, useSidebar, useTour };
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, 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, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, ButtonGroupSeparator, ButtonGroupText, type ButtonProps, ButtonWithTooltip, type ButtonWithTooltipProps, CannotAnswerCard, type CannotAnswerCardProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CardWithHeader, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, 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, ClarifyCard, type ClarifyCardProps, type ClarifyOption, type ColumnDatum, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextBar, type ContextBarProps, 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, EmissionCard, type EmissionCardProps, EmissionHeader, type EmissionHeaderProps, type EmissionKind, EmptyState, EmptyStateLock, type EmptyStateLockProps, type EmptyStateProps, ErrorBoundary, 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, Legend, LegendItem, type LegendItemProps, type LegendProps, type LegendSwatchKind, 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, NavBase, NavHorizontal, type NavHorizontalItem, NavHorizontalItems, type NavHorizontalItemsProps, type NavHorizontalProps, type NavItemConfig, NavItems, type NavItemsProps, 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, PanelContent, type PanelContentProps, PanelStack, type PanelStackProps, type PanelStackSection, Popover, PopoverContent, PopoverTrigger, Progress, PropertyList, type PropertyListProps, PropertyRow, type PropertyRowProps, ProposalCard, type ProposalCardProps, RatingControl, type RatingControlProps, RepairNote, type RepairNoteProps, ResizableHandle, ResizablePanel, ResizablePanelGroup, RetryNote, type RetryNoteProps, RichSelect, type RichSelectOption, type RichSelectProps, 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, Sparkline, type SparklineProps, Spinner, StatusDot, type StatusDotProps, type TabConfig, TabbedPanel, type TabbedPanelProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, type TemplateOption, TemplatePicker, type TemplatePickerProps, Terminal, TerminalLine, type TerminalLineKind, type TerminalLineProps, type TerminalProps, TimelineEntry, type TimelineEntryProps, TimelineList, type TimelineListProps, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Toolbar, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, 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 UseTourOptions, type Verdict, agentChipVariants, badgeVariants, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, navigationMenuTriggerStyle, statusDotVariants, toggleVariants, useSidebar, useTour };