@invana/ui 0.0.28 → 0.0.30

package/dist/index.d.cts

@@ -25,6 +25,24 @@ import * as TogglePrimitive from '@radix-ui/react-toggle';
 import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
 import { LucideIcon } from 'lucide-react';
 
+/**
+ * `clsx` + `tailwind-merge`, and nothing else.
+ *
+ * This used to be an `extendTailwindMerge` that registered one class group.
+ * `text-*` is ambiguous — it is both the font-size scale and the text-colour
+ * scale — so tailwind-merge decides which group a class belongs to by matching
+ * its value against Tailwind's built-in size names. `meta` was not one of them,
+ * so `text-meta` was read as a *colour* and silently dropped whatever colour
+ * class came before it:
+ *
+ *   cn("text-[var(--badge-ink)]", "text-meta")  →  "text-meta"   // colour lost
+ *
+ * The type ladder is now `base · sm · xs` (`@invana/styling`), every one of
+ * them a Tailwind built-in, so there is nothing left to register and the
+ * footgun is gone with the token that caused it. If a future `--text-*` token
+ * invents a name Tailwind does not know, bring the `extend` back in the same
+ * breath — it will eat colours at a distance and the cause will not be obvious.
+ */
 declare function cn(...inputs: ClassValue[]): string;
 
 declare const Accordion: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
@@ -302,6 +320,63 @@ declare function ItemFooter({ className, ...props }: React$1.ComponentProps<"div
 declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): React$1.JSX.Element;
 declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
 
+/**
+ * `variant` is how loudly the link asks to be clicked.
+ *
+ * Three, because three is what the product actually uses and a fourth would be
+ * a decision nobody could state:
+ *
+ * - `default` — a link inside a sentence. Accent-coloured, underlined on hover.
+ *   The colour is what marks it as a link while reading; the underline confirms
+ *   it under the cursor.
+ * - `underlined` — always underlined, accent-coloured. For a link that has to
+ *   read as a link **before** the cursor arrives: terms and conditions under a
+ *   sign-in button, a citation, anything legal or referential.
+ * - `quiet` — muted, brightening to the foreground on hover. A footer link, a
+ *   row that happens to be navigable. It is not shouting, and it is not
+ *   pretending to be body copy either: the hover is the affordance.
+ *
+ * Deliberately **not** a `Button` variant. A button performs an act on this
+ * page; a link goes somewhere, which is a different promise, a different
+ * element and a different set of things a browser will do for you (middle
+ * click, copy address, open in a tab). A `<button>` styled as a link takes all
+ * of that away, and `Button asChild` around an `<a>` is the escape hatch for
+ * the genuinely button-shaped case.
+ *
+ * No size axis. A link takes the size of the text it sits in — that is what
+ * makes it a link *in a sentence* rather than a control dropped into one.
+ */
+declare const linkVariants: (props?: ({
+    variant?: "default" | "underlined" | "quiet" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface LinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement>, VariantProps<typeof linkVariants> {
+    /**
+     * The destination is outside this app: opens in a new tab, and carries
+     * `rel="noreferrer noopener"` so the opened page cannot reach back through
+     * `window.opener`.
+     *
+     * A flag rather than asking every call site to remember `target` and `rel`
+     * together — the pair is the thing that is correct, and half of it is a
+     * security bug nobody notices.
+     */
+    external?: boolean;
+}
+/**
+ * A link. An `<a>` with the kit's colours, and the two behaviours an external
+ * one needs.
+ *
+ * It exists because every surface was writing its own — `text-primary
+ * hover:underline` here, `text-muted-foreground hover:underline` there — which
+ * is four spellings of one object and a colour that drifts the day the accent
+ * moves.
+ *
+ * Routing is the consumer's: this renders an `<a>`, and a router's own `Link`
+ * wraps it (`<RouterLink asChild>`) or takes these classes. The kit does not
+ * depend on a router, because a component that did could only ever be used with
+ * that one.
+ */
+declare const Link: React$1.ForwardRefExoticComponent<LinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+
 declare function MenubarMenu({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Menu>): React$1.JSX.Element;
 declare function MenubarGroup({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Group>): React$1.JSX.Element;
 declare function MenubarPortal({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Portal>): React$1.JSX.Element;
@@ -393,7 +468,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?: "bottom" | "left" | "right" | "top" | null | undefined;
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
 }
@@ -564,6 +639,67 @@ 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>>;
 
+/**
+ * How this address stood in the run, or in the rule being read.
+ *
+ * `denied` and `refused` are two different facts and the boards print both:
+ * a **denied** address is what the bound says, read at rest; a **refused** one
+ * is what actually happened when a run reached for it. One is a rule, the other
+ * is an event, and collapsing them loses *the bound was there and nothing ever
+ * tested it*.
+ */
+type KnownAddressTone = "allowed" | "denied" | "refused" | "untouched";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type AddressTone = KnownAddressTone | (string & {});
+/**
+ * Split an address so the **participant survives truncation**.
+ *
+ * `graph_data/model/Deals@1.0.0` is read right-to-left: the last segment is
+ * which thing, and the first two are which kind of thing — and the kind is
+ * already carried by the `LayerChip` beside it. So the head flexes and clips
+ * and the tail is pinned, giving `graph_data/mod…/Deals@1.0.0` rather than the
+ * `graph_data/model/Dea…` a plain `truncate` would give.
+ *
+ * A wildcard pattern is the same shape (`graph_data/model/Deals@*`), and
+ * `third_party/**` has no tail to lose.
+ */
+declare function split(address: string): {
+    head: string;
+    tail: string;
+};
+interface AddressChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children" | "onClick"> {
+    /** `graph_data/model/Deals@1.0.0`, or a pattern — `third_party/**`. */
+    address: string;
+    tone?: AddressTone;
+    /**
+     * Open the participant this names. Present makes the chip a button; absent
+     * leaves it text, because an address that looks pressable and is not teaches
+     * the reader to stop pressing.
+     */
+    onOpen?: (address: string) => void;
+}
+/**
+ * One participant's address, printed so the participant stays readable.
+ *
+ * The address is the only identifier there is — the lens matches on it, the
+ * ledger records it, the run drawing expands it — so it appears wherever a
+ * bound, a touch or a refusal is shown, and it has to survive a narrow column
+ * without becoming three of the same string.
+ *
+ * **It truncates in the middle, not the end.** See {@link split}: the last
+ * segment is which thing and the ones before it are which kind, so the kind is
+ * what gives way. Clipping the tail would render every model in a Graph as
+ * `graph_data/model/…`.
+ *
+ * The separators sit at half opacity so the segments read as three parts of one
+ * name rather than one long token. Monospace for the same reason it is
+ * monospace in the ledger: these are compared by eye, down a column.
+ */
+declare const AddressChip: React$1.ForwardRefExoticComponent<AddressChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
 declare const agentChipVariants: (props?: ({
     kind?: "agent" | "person" | null | undefined;
     inactive?: boolean | null | undefined;
@@ -586,46 +722,6 @@ interface AgentChipProps extends React$1.HTMLAttributes<HTMLSpanElement>, Varian
  */
 declare const AgentChip: React$1.ForwardRefExoticComponent<AgentChipProps & React$1.RefAttributes<HTMLSpanElement>>;
 
-/**
- * The closed set of capabilities a callable may spend.
- *
- * Nine values, fixed. The catalogue is grouped by these and an envelope
- * ceilings them, so this is a vocabulary rather than a list that grows.
- */
-type Bound = "none" | "network" | "graph_read" | "graph_write" | "schema_write" | "ingest" | "llm" | "plan_write" | "work_write";
-/**
- * One hue per bound, fixed — colour follows the bound, never its position in a
- * list. Five come from the status tokens because they already mean the right
- * thing; the other four take data-palette slots, which are chosen for being
- * distinguishable from each other rather than for meaning anything.
- */
-declare const SWATCH: Record<Bound, string>;
-interface BoundChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
-    bound: Bound;
-    /**
-     * Render the swatch alone, for somewhere the name is already written beside
-     * it. Use sparingly — see the note on colour below.
-     */
-    swatchOnly?: boolean;
-}
-/**
- * What a task is allowed to spend, as a swatch and a name.
- *
- * It appears on a task node in a flow, in a run's record header, on a catalogue
- * row and in the parameter form's contract card — everywhere a reader has to
- * know *what this act costs* before reading what it does.
- *
- * **The name is always there.** The swatch is a scanning aid, not the carrier:
- * nine hues cannot be told apart reliably, several pairs are close, and a
- * colour-blind reader gets nothing from any of them. `swatchOnly` exists for
- * the one case where the name is already printed next to the chip.
- *
- * Deliberately not a `Badge`. A badge carries *state* and takes a tone from the
- * status palette; a bound is a fixed property of a callable and must not read
- * as "this went well" because it happens to be green.
- */
-declare const BoundChip: React$1.ForwardRefExoticComponent<BoundChipProps & React$1.RefAttributes<HTMLSpanElement>>;
-
 declare const stateVariants: (props?: ({
     tone?: "active" | "error" | "running" | "draft" | "review" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -753,6 +849,78 @@ interface BarChartVProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "c
  */
 declare const BarChartV: React$1.ForwardRefExoticComponent<BarChartVProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * The capabilities Invana ships today — **suggestions, not a limit.**
+ *
+ * These are what {@link Bound} autocompletes to. They bind nothing: a product
+ * that adds a `vector_write` bound as it grows passes `"vector_write"` and the
+ * chip draws it. The catalogue groups by these and an envelope ceilings them,
+ * but that is the *runtime's* vocabulary to police — a chip that refused to
+ * render an unknown bound would make the design kit a release blocker for
+ * every new capability.
+ */
+type KnownBound = "none" | "network" | "graph_read" | "graph_write" | "schema_write" | "ingest" | "llm" | "plan_write" | "work_write";
+/**
+ * What a callable may spend — any identifier at all.
+ *
+ * `(string & {})` keeps the known set autocompleting while accepting anything
+ * else without a cast. See {@link KnownBound}.
+ */
+type Bound = KnownBound | (string & {});
+/**
+ * What each bound is painted with — **the kit ships no hues.**
+ *
+ * Which colour means `schema_write` is a product's decision. Four of the nine
+ * were only ever data-palette slots picked for being distinguishable from one
+ * another, which is exactly the kind of choice a component should not be
+ * making on a consumer's behalf; and holding the map forced every consumer
+ * onto a stylesheet that defines those slots, which is how `bg-data-*` came to
+ * be dead in the precompiled `@invana/ui/styles.css` without anyone noticing.
+ *
+ * Values are class strings, so a surface spends whatever its own Tailwind
+ * build has — a data-palette token, a status token, a brand colour. A bound
+ * left out draws in the neutral.
+ */
+type BoundPalette = Partial<Record<Bound, string>>;
+interface BoundChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
+    bound: Bound;
+    /**
+     * Render the swatch alone, for somewhere the name is already written beside
+     * it. Use sparingly — see the note on colour below.
+     */
+    swatchOnly?: boolean;
+    /** What to call it, when the identifier is not what this surface says. */
+    label?: React$1.ReactNode;
+    /**
+     * This chip's swatch class, given directly — `bg-data-7`, `bg-violet-500`.
+     * The shortest path when a call site draws one chip and knows its bound.
+     * Wins over {@link BoundChipProps.palette}.
+     */
+    swatch?: string;
+    /**
+     * What the bounds are painted with, when a caller draws several and would
+     * rather state the map once. Only this chip's own bound is read.
+     */
+    palette?: BoundPalette;
+}
+/**
+ * What a task is allowed to spend, as a swatch and a name.
+ *
+ * It appears on a task node in a flow, in a run's record header, on a catalogue
+ * row and in the parameter form's contract card — everywhere a reader has to
+ * know *what this act costs* before reading what it does.
+ *
+ * **The name is always there.** The swatch is a scanning aid, not the carrier:
+ * nine hues cannot be told apart reliably, several pairs are close, and a
+ * colour-blind reader gets nothing from any of them. `swatchOnly` exists for
+ * the one case where the name is already printed next to the chip.
+ *
+ * Deliberately not a `Badge`. A badge carries *state* and takes a tone from the
+ * status palette; a bound is a fixed property of a callable and must not read
+ * as "this went well" because it happens to be green.
+ */
+declare const BoundChip: React$1.ForwardRefExoticComponent<BoundChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
 interface ButtonWithTooltipProps extends ButtonProps {
     tooltip: React__default.ReactNode;
 }
@@ -784,6 +952,247 @@ interface CannotAnswerCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
  */
 declare const CannotAnswerCard: React$1.ForwardRefExoticComponent<CannotAnswerCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * The classes of participant Invana ships today — **suggestions, not a limit.**
+ *
+ * These are what {@link Layer} autocompletes to. They bind nothing: a product
+ * that grows a `vector_store` layer next week passes `"vector_store"` and every
+ * component here draws it, because a component that had to be edited before a
+ * developer could name a new layer is a component that owns the product's
+ * vocabulary.
+ *
+ * `agent` is the **spine**: the runtime itself, which does the participating
+ * rather than being a participant, and is never governed. Nothing in this file
+ * knows that — a band says so with `spine`, see `LayerStrip`.
+ */
+type KnownLayer = "graph_data" | "llm" | "third_party" | "cache" | "human" | "agent";
+/**
+ * What a participant **is** — any identifier at all.
+ *
+ * `(string & {})` is what keeps both halves: the known set still autocompletes
+ * and still documents itself, while an unknown string is accepted without a
+ * cast. Widening this to plain `string` would silently drop the suggestions;
+ * narrowing it back to the union would make the kit the gatekeeper of a
+ * vocabulary it does not own.
+ */
+type Layer = KnownLayer | (string & {});
+/**
+ * What a reader calls the layer: the identifier with its underscores opened up.
+ *
+ * Derived rather than looked up — a table would have to be edited for every
+ * layer a product adds, and for all six Invana ships today the table said
+ * exactly this anyway (`graph_data` → `graph data`). A layer that wants
+ * something else passes `label`.
+ */
+declare const layerLabel: (layer: Layer) => string;
+/**
+ * How one layer is painted. **The kit ships no hues** — a consumer supplies
+ * these, because which colour means `llm` is a product's decision and not a
+ * component's.
+ *
+ * Both are class strings rather than colours, so a surface spends whatever
+ * palette its own Tailwind build already has: `bg-data-7` from
+ * `@invana/styling`, a brand token, a plain `bg-violet-500`. A component that
+ * held the map would force every consumer onto the kit's palette *and* onto a
+ * stylesheet that defines it — which is how `bg-data-*` came to be dead in the
+ * precompiled `@invana/ui/styles.css` without anyone noticing.
+ *
+ * It is passed to the component that draws, as a prop, every time — never
+ * installed once for a tree. A caller restating its palette at four call sites
+ * is the honest cost: the alternative hides *which* colours a drawing is using
+ * behind a provider somebody else mounted.
+ *
+ * - `swatch` is the **solid mark**: the dot beside a name, the rail down a bar.
+ * - `tint` is the **wash**: a bar's ground and edge together. Keep it faint —
+ *   it sits *behind* text, so a hue dark enough to label in is a hue too dark
+ *   to wash with.
+ * - `text` is the hue **as type**: a participant address written in its layer's
+ *   colour, so `model/Orders@v2` and the `graph data` dot above it are visibly
+ *   the same thing. This is the one that has to clear a contrast floor, which
+ *   is why it is yours to choose and separate from `swatch` — the token that
+ *   makes a legible 6px dot is often not the one that makes legible 13px mono.
+ */
+interface LayerPaint {
+    /** The solid mark — `bg-data-7`. */
+    swatch?: string;
+    /** The wash, ground and edge — `border-data-7/35 bg-data-7/10`. */
+    tint?: string;
+    /** The hue as type, for an address that should read as its layer — `text-data-7`. */
+    text?: string;
+}
+/**
+ * What each layer is painted with. Partial on purpose: a layer left out falls
+ * back to the neutral, which is a legible answer rather than a blank one.
+ */
+type LayerPalette = Partial<Record<Layer, LayerPaint>>;
+/**
+ * One layer's paint, with the neutral filled in for anything unsaid — so a
+ * caller never branches on `undefined` to draw a dot.
+ *
+ * There is no provider and no context. Colour arrives as the `palette` prop on
+ * the component that draws, every time: a chip painted from somewhere up the
+ * tree is a chip whose colour you cannot find by reading its call site.
+ */
+declare const layerPaint: (palette: LayerPalette | undefined, layer: Layer) => Required<LayerPaint>;
+interface LayerChipProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "children"> {
+    layer: Layer;
+    /**
+     * How many participants this layer holds — `graph data 4`. Omit where the
+     * count is already in the row, and note that `0` is a fact worth printing:
+     * *nothing is configured* reads differently from *nothing matched*.
+     */
+    count?: number;
+    /** What to call it, when {@link layerLabel} is not what this surface says. */
+    label?: React$1.ReactNode;
+    /**
+     * The layer is closed, empty or out of view: the swatch drops to the muted
+     * token and the label goes with it. The chip stays legible — this is *not
+     * in play*, never *not there*.
+     */
+    dim?: boolean;
+    /**
+     * This chip's swatch class, given directly — `bg-data-7`, `bg-violet-500`.
+     * The shortest path when a call site draws one chip and knows its layer.
+     * Wins over {@link LayerChipProps.palette}.
+     */
+    swatch?: string;
+    /**
+     * What the layers are painted with, when a caller draws several and would
+     * rather state the map once. Only this chip's own layer is read.
+     */
+    palette?: LayerPalette;
+}
+/**
+ * One class of participant, as a swatch and a name.
+ *
+ * It heads a `LayerSection`, bands a run's `LayerStrip`, and counts a layer in
+ * the Worlds drawer — everywhere a reader has to know *what kind of thing this
+ * is* before reading which one.
+ *
+ * **The name is always there.** Six hues cannot be told apart reliably and a
+ * colour-blind reader gets nothing from any of them: the swatch speeds up
+ * scanning a list you can already read, and carries nothing on its own.
+ *
+ * Deliberately not a `Badge` and deliberately not `BoundChip`. A badge carries
+ * *state* from the status palette; a bound is what a callable may **spend**; a
+ * layer is what a participant **is**. The two chips co-occur on the agent
+ * boards, which is why they never share a hue.
+ */
+declare const LayerChip: React$1.ForwardRefExoticComponent<LayerChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+/** The four roles a plan may name. Fixed — `tier` would not survive a re-cast. */
+type CastRole = "extract" | "decide" | "judge" | "embed";
+/**
+ * One thing a lens does to the world it is read against.
+ *
+ * A closed set, because the drawer's job is *what does this narrow* answered at
+ * a glance, and a free-text summary is a sentence each caller writes
+ * differently. Empty means the lens narrows nothing — which is a real state and
+ * the row says so in words, never with a blank.
+ */
+type Narrowing = {
+    kind: "allow";
+    count: number;
+} | {
+    kind: "deny";
+    count: number;
+} | {
+    kind: "sliced";
+} | {
+    kind: "excludes";
+    properties: string[];
+} | {
+    kind: "closes";
+    layers: Layer[];
+} | {
+    kind: "casts";
+    roles: CastRole[];
+};
+interface LensUsage {
+    /** How many runs opened under this lens. `0` is printed, not hidden. */
+    runs: number;
+    /** Already humanised — `2h ago`. The row does not own a clock. */
+    lastUsed?: string;
+}
+interface LensRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> {
+    name: string;
+    narrows?: Narrowing[];
+    usage?: LensUsage;
+    selected?: boolean;
+    onSelect?: (name: string) => void;
+    /**
+     * What the layers of a `closes` narrowing are painted with. Omitted, those
+     * chips draw in the neutral.
+     */
+    palette?: LayerPalette;
+}
+/**
+ * One world in the Worlds drawer: its name, what it narrows, and how used it is.
+ *
+ * **What it narrows is chips, not prose.** A world is picked by comparing it
+ * with the four above it, and four sentences do not compare — six fixed kinds
+ * of narrowing do. `closes` renders its layers as `LayerChip`s because *which*
+ * layer is closed is the part being compared.
+ *
+ * **A world that narrows nothing says so in words.** `Everything` is a real
+ * world and the default one; a blank row would read as a world whose summary
+ * failed to load, which is the opposite of the reassurance it is there to give.
+ *
+ * **Usage is a fact, not a ranking.** `used in 34 runs · last 2h ago` tells a
+ * reader whether they are about to edit something live. It never sorts the list
+ * — a world used once may be the one that matters, and a list that reorders
+ * itself under you cannot be scanned twice.
+ */
+declare const LensRow: React$1.ForwardRefExoticComponent<LensRowProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * The four roles, in the order a run spends them. Fixed, and **always all four**
+ * — see the note on the component.
+ */
+declare const CAST_ROLES: CastRole[];
+/** Where a resolved address came from. Innermost wins. */
+type CastSource = "todo" | "plan" | "agent" | "shipped";
+interface CastResolution {
+    role: CastRole;
+    /** `null` when nothing casts the role and no shipped default resolves it. */
+    address: string | null;
+    allowed: boolean;
+    /** The rule that denied it, when one did — so a refusal names its bound. */
+    ruleMatched?: string | null;
+    source?: CastSource;
+}
+interface CastTableProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** What the lens itself casts: role → model address. Partial is normal. */
+    cast?: Partial<Record<CastRole, string>>;
+    /**
+     * The same four roles after resolution — innermost wins, then checked against
+     * the effective rules. Absent leaves the table read as *what this lens says*
+     * rather than *what a run would get*.
+     */
+    resolved?: CastResolution[];
+    readOnly?: boolean;
+}
+/**
+ * `role → resolves to → why this one`, four fixed rows.
+ *
+ * A plan names a **role**, not a model: `decide` says *how much this matters*,
+ * which stays true when the line-up moves, in a way `tier` and a hard-coded
+ * model id do not. The cast is what turns the role into an address.
+ *
+ * **All four rows, always — including the ones nothing casts.** A table that
+ * showed only what was set would make *nothing casts `judge`* invisible, and
+ * that is precisely the state worth seeing before a run opens: it is the one
+ * that falls to a shipped default, which may name a model this Graph is not
+ * credentialed for.
+ *
+ * **The cast is not a bound.** It picks *within* the rules and never widens
+ * them: innermost wins, and the resolved address is then checked against the
+ * effective rules and refused by name if denied. That is why a denied row names
+ * the rule rather than just going red — the recourse is to edit that rule, and
+ * the reader has to know which.
+ */
+declare const CastTable: React$1.ForwardRefExoticComponent<CastTableProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface ChatSessionProps {
     /** The message list — typically `<ChatSessionMessage />` nodes. */
     children?: React$1.ReactNode;
@@ -1266,7 +1675,12 @@ interface DiagnosisCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
  */
 declare const DiagnosisCard: React$1.ForwardRefExoticComponent<DiagnosisCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
-type DiffOp = "add" | "remove" | "change";
+type KnownDiffOp = "add" | "remove" | "change";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type DiffOp = KnownDiffOp | (string & {});
 interface DiffRowProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "children"> {
     op?: DiffOp;
     /** What kind of thing changed — `node`, `edge`, `property`. */
@@ -1331,6 +1745,49 @@ interface DivergingBarProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
  */
 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
@@ -1433,6 +1890,41 @@ 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 EyebrowProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Right-aligned trailing text — a count, a position, a state. Kept separate
+     * from `children` so the label stays left and the fact stays right without
+     * every call site building its own flex row.
+     */
+    aside?: React$1.ReactNode;
+    /**
+     * `muted` (default) for a label being scanned past, `foreground` when it
+     * titles a card that has no other heading, `accent` when it names something
+     * the reader is being taught.
+     */
+    tone?: "muted" | "foreground" | "accent";
+    children?: React$1.ReactNode;
+}
+/**
+ * The smallest heading in the system: a label over the thing it names.
+ *
+ * `WHY IT MATTERS`, `1 · CONNECTED`, `OPTIONAL`, `REFERENCED COMPONENTS`. It
+ * titles a band of content without the weight — or the 35px and the rule — of
+ * a {@link SectionHeader}, so several can sit in one scrolling column and still
+ * read as subordinate to the panel's own title.
+ *
+ * Uppercase at `text-sm` with tracking, because at this size caps are what
+ * separate a label from the sentence under it; lowercase at 11px reads as body
+ * copy set small. That is also why it is a component rather than four utility
+ * classes: the treatment was being retyped, and a label that drifts a weight or
+ * a tracking step in one panel stops reading as the same kind of thing.
+ *
+ * `tone="accent"` is for a label that names something the reader is being
+ * *taught* rather than something they are scanning — a callout's kind, a
+ * concept's name. Use it rarely; muted is the default for a reason.
+ */
+declare const Eyebrow: React$1.ForwardRefExoticComponent<EyebrowProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface FilterBarProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** The filter controls. `FilterChip`s, a `SearchInput`, a toggle. */
     children?: React$1.ReactNode;
@@ -1522,6 +2014,316 @@ interface HeatStripProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "c
  */
 declare const HeatStrip: React$1.ForwardRefExoticComponent<HeatStripProps & React$1.RefAttributes<HTMLDivElement>>;
 
+interface LayerSectionProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    layer: Layer;
+    /**
+     * What this layer amounts to, in the reader's words — `permitted whole`,
+     * `4 of 5 models · sliced`, `closed · nothing but the two below`.
+     *
+     * **A closed layer says so here.** Closing a layer is what picking four
+     * models out of six means, and it is a stated field rather than something
+     * inferred from *there is an allow rule in this band* — so the band has to
+     * print it, or an auditor reads an allow-list as a list of exceptions.
+     */
+    summary?: React$1.ReactNode;
+    /** The layer's `RuleRow`s. None is a real state — see `summary`. */
+    children?: React$1.ReactNode;
+    /** How many participants the layer holds, shown on the chip. */
+    count?: number;
+    /**
+     * What the layer is painted with — only this band's own layer is read.
+     * Omitted, the chip draws in the neutral.
+     */
+    palette?: LayerPalette;
+    /** The layer is out of view for this lens: the whole band dims. */
+    dim?: boolean;
+}
+/**
+ * One layer's band of rules, under the layer's own name and summary.
+ *
+ * A lens reads as five of these stacked — graph data, llm, third party, cache,
+ * human — so *what is shut* is answered by scanning five summary lines rather
+ * than by reading every rule. That is the shape the Worlds and Guardrails
+ * drawers share, which is why the band is a component and not a heading each
+ * screen retypes.
+ *
+ * **A band with no rules still appears.** An absent layer and a layer with
+ * nothing in it are different facts: one is *this Graph has no third parties
+ * configured*, the other is *it has them and this lens admits none*. A band
+ * that vanished when empty would make the two look alike, and the second is the
+ * one worth seeing.
+ *
+ * The rule is subordinate to the band, so the band's label is a `LayerChip`
+ * rather than a heading — the panel's own title is the heading, and five
+ * headings under it would compete with it.
+ */
+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";
 interface LegendItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "color"> {
     /**
@@ -1558,6 +2360,75 @@ 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"> {
+    /**
+     * The lens in force. **`undefined` is a real, common state** and reads
+     * `Everything` — see below.
+     */
+    lens?: {
+        name: string;
+        kind?: "world" | "guardrail";
+    };
+    /** Open the picker. Absent leaves the chip as a statement. */
+    onPick?: () => void;
+}
+/**
+ * Which world a run is being read under — the header's right-hand chip, and the
+ * one on an agent's row.
+ *
+ * **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.
+ *
+ * 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.
+ */
+declare const LensChip: React$1.ForwardRefExoticComponent<LensChipProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+interface MatchCandidate {
+    address: string;
+    matched: boolean;
+}
+interface MatchPreviewProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The pattern as typed, wildcards and all — `graph_data/model/Deals@*`. */
+    pattern: string;
+    /**
+     * The catalogue, each entry saying whether this pattern reaches it. Both
+     * halves are needed: see the note on near-misses.
+     */
+    matches?: MatchCandidate[];
+    loading?: boolean;
+    /** Cap the list; the rest are counted. Default 8. */
+    limit?: number;
+}
+/**
+ * What an address pattern matches **right now**, resolved against the live
+ * catalogue as the pattern is typed.
+ *
+ * **Narrowing is picking, not writing.** Every control in the rule builder
+ * offers what the catalogue holds, so nothing can name something that is not
+ * there — and this is the surface that makes that true for the one control
+ * which *is* free text. A pattern is written against what it visibly bites, not
+ * from memory.
+ *
+ * **The near-misses are shown, greyed, not filtered out.** A preview listing
+ * only hits cannot distinguish *this pattern is precise* from *this pattern is
+ * wrong* — both render as a short list. Showing what it passed over is how a
+ * reader sees that `Deals@1.0.0` missed because they wrote the version out
+ * instead of `Deals@*`, which is the mistake that makes a bound quietly stop
+ * applying on the next publish.
+ *
+ * **Nothing matched is a first-class state**, and distinct from a layer with
+ * nothing in it. One means the pattern is wrong; the other means the Graph has
+ * nothing of that kind configured yet.
+ */
+declare const MatchPreview: React$1.ForwardRefExoticComponent<MatchPreviewProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface MenuItemProps extends MenuItem {
     level?: number;
 }
@@ -1580,7 +2451,12 @@ declare const MenuItem: React$1.FC<MenuItemProps>;
  * Omit it for an ordinary measurement. A grid where every tile is coloured
  * carries no signal, and a number that is merely large is not a warning.
  */
-type MetricTone = "running" | "success" | "warning" | "error" | "info";
+type KnownMetricTone = "running" | "success" | "warning" | "error" | "info";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type MetricTone = KnownMetricTone | (string & {});
 interface MetricTileProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** What is being measured — `accepted`, `served (plan.verified)`, `hit rate`. */
     label: React$1.ReactNode;
@@ -2277,44 +3153,6 @@ interface PropertyRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>,
 declare const PropertyList: React$1.ForwardRefExoticComponent<PropertyListProps & React$1.RefAttributes<HTMLDListElement>>;
 declare const PropertyRow: React$1.ForwardRefExoticComponent<PropertyRowProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface RecordHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
-    /**
-     * The record's state, as the dot on the left. Omit for a record that has no
-     * state of its own — a catalogue entry, a draft being edited.
-     */
-    tone?: StatusDotProps["tone"];
-    /**
-     * The record and its parents, outermost first. The **last** crumb is the
-     * record this surface is about and is set solid; the ones before it are the
-     * path to it and are muted.
-     *
-     * One crumb is the normal case — a run, a plan. Two is a child: `a run › the
-     * task inside it`.
-     */
-    crumbs: React$1.ReactNode[];
-    /** What is true about it — a `<BoundChip>`, a status `<Badge>`, a kind. */
-    chips?: React$1.ReactNode;
-    /** What you can do to it — prev/next, a view switch, buttons, a `…` menu. */
-    actions?: React$1.ReactNode;
-}
-/**
- * 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
- * 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
- * *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.
- *
- * It is not a `Breadcrumb` either, though it contains one shape of one. A
- * breadcrumb is navigation up a tree; these two crumbs are a record and its
- * parent, shown so the child is not read out of context.
- */
-declare const RecordHeader: React$1.ForwardRefExoticComponent<RecordHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
-
 interface ProposalCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
     /** What is being proposed — `Draft pattern`. */
     title: React$1.ReactNode;
@@ -2391,6 +3229,44 @@ declare const DotRating: React$1.ForwardRefExoticComponent<DotRatingProps & Reac
  */
 declare const RatingControl: React$1.ForwardRefExoticComponent<RatingControlProps & React$1.RefAttributes<HTMLDivElement>>;
 
+interface RecordHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    /**
+     * The record's state, as the dot on the left. Omit for a record that has no
+     * state of its own — a catalogue entry, a draft being edited.
+     */
+    tone?: StatusDotProps["tone"];
+    /**
+     * The record and its parents, outermost first. The **last** crumb is the
+     * record this surface is about and is set solid; the ones before it are the
+     * path to it and are muted.
+     *
+     * One crumb is the normal case — a run, a plan. Two is a child: `a run › the
+     * task inside it`.
+     */
+    crumbs: React$1.ReactNode[];
+    /** What is true about it — a `<BoundChip>`, a status `<Badge>`, a kind. */
+    chips?: React$1.ReactNode;
+    /** What you can do to it — prev/next, a view switch, buttons, a `…` menu. */
+    actions?: React$1.ReactNode;
+}
+/**
+ * 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
+ * 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
+ * *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.
+ *
+ * It is not a `Breadcrumb` either, though it contains one shape of one. A
+ * breadcrumb is navigation up a tree; these two crumbs are a record and its
+ * parent, shown so the child is not read out of context.
+ */
+declare const RecordHeader: React$1.ForwardRefExoticComponent<RecordHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+
 interface RepairNoteProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** What was wrong — `unknown property Theme.velocity5d`. */
     from: React$1.ReactNode;
@@ -2487,6 +3363,135 @@ 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;
 
+/** A slice along the axes the matched model **declared**. */
+interface RuleSelect {
+    time?: {
+        axis: string;
+        from?: string;
+        to?: string;
+    };
+    geo?: {
+        axis: string;
+        vocab?: string;
+        in: string[];
+    };
+    dims?: Record<string, string[]>;
+}
+/**
+ * What a published model version says may be narrowed.
+ *
+ * Empty is the default and means *nothing is selectable* — the model can still
+ * be allowed or denied whole, it simply cannot be sliced. Nothing is inferred
+ * from a property's name or type, because that would make *which rows did this
+ * run see* depend on a guess.
+ */
+interface DeclaredAxes {
+    time?: {
+        property: string;
+    };
+    geo?: {
+        property: string;
+        vocab?: string;
+    };
+    dims?: string[];
+}
+interface SliceLine {
+    /** `time` · `geo` · a dimension's own name. */
+    axisKind: string;
+    text: string;
+    /** The model declared no such axis — this slice would be refused at save. */
+    undeclared?: boolean;
+}
+/**
+ * One slice, as lines, with **the axis always named**.
+ *
+ * `time 2026-01-01 → 2026-06-30 · axis signed_at`. The axis is never implied: a
+ * model declares which property carries valid time, two models in one Graph
+ * declare different ones, and *which rows did this run see* must not depend on
+ * the reader guessing which was used.
+ *
+ * When `declared` is given, a slice along an axis the model never declared is
+ * marked — that is the refusal the authoring form has to show before a save,
+ * naming the model **and** the axis.
+ */
+declare function describeSlice(select: RuleSelect, declared?: DeclaredAxes): SliceLine[];
+interface SliceSummaryProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    select?: RuleSelect;
+    /**
+     * The matched model version's declared axes. Given, the summary can mark a
+     * slice the model cannot support; omitted, it states the slice and claims
+     * nothing about whether it is legal.
+     */
+    declaredAxes?: DeclaredAxes;
+    /** Which model is being sliced — named in the undeclared-axis refusal. */
+    modelLabel?: string;
+    /** `line` sits under a `RuleRow`; `block` stands alone on W3 and R2. */
+    variant?: "line" | "block";
+}
+/**
+ * What a rule narrows to, stated so the axis is never in doubt.
+ *
+ * **The axis is always named.** See {@link describeSlice} — this is the one
+ * rule the component exists to hold, and it is why a slice is a component
+ * rather than a template string at each call site.
+ *
+ * **An undeclared axis is shown, not hidden.** A lens asking for an axis a
+ * model never declared is refused at save naming the model and the axis, so the
+ * form has to render the illegal state on the way to being told about it.
+ * Silently dropping the line would make the refusal arrive from nowhere.
+ *
+ * `variant="line"` is what a `RuleRow` renders — the same description, so the
+ * two never drift into two accounts of one slice.
+ */
+declare const SliceSummary: React$1.ForwardRefExoticComponent<SliceSummaryProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/** Which properties of the matched participant survive into the answer. */
+interface RuleProperties {
+    /**
+     * Excluded by name. Exclusion is the only form: an allow-list of properties
+     * would silently drop a property added to the model later, which is the kind
+     * of bound that stops applying without anybody editing it.
+     */
+    exclude?: string[];
+}
+/** What may accompany a crossing to this destination. */
+interface RuleEgress {
+    may_send: string[];
+}
+
+interface RuleRowProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The address pattern this rule matches — `graph_data/model/Deals@*`. */
+    match: string;
+    /** `true` allows, `false` denies. Deny wins at any specificity. */
+    allow: boolean;
+    properties?: RuleProperties;
+    select?: RuleSelect;
+    egress?: RuleEgress;
+    /**
+     * The row is being read rather than authored. Read-only rows lose the hover
+     * affordance, so a guardrail somebody cannot edit does not look pressable.
+     */
+    readOnly?: boolean;
+}
+/**
+ * One rule, read as a sentence: what it matches, whether it allows, and what it
+ * narrows.
+ *
+ * It is the unit of a `LayerSection`, so a lens reads as five bands of these
+ * rather than a table of five columns most of which are empty — a rule that
+ * slices carries a select line, one that does not carries nothing.
+ *
+ * **Deny is the loud one.** An allow is the ordinary state and sits muted; a
+ * deny takes the destructive token, because [deny wins at any specificity] and
+ * a reader scanning a long lens for *what is shut* should find it without
+ * reading every row.
+ *
+ * The sub-lines are facts about the match, so they hang under it and inherit
+ * its indent rather than becoming columns. A row with none of them is one line
+ * tall, which is what most rows are.
+ */
+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.
@@ -2504,41 +3509,6 @@ interface SearchInputProps extends Omit<React__default.ComponentProps<'input'>,
 }
 declare const SearchInput: React__default.FC<SearchInputProps>;
 
-interface EyebrowProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    /**
-     * Right-aligned trailing text — a count, a position, a state. Kept separate
-     * from `children` so the label stays left and the fact stays right without
-     * every call site building its own flex row.
-     */
-    aside?: React$1.ReactNode;
-    /**
-     * `muted` (default) for a label being scanned past, `foreground` when it
-     * titles a card that has no other heading, `accent` when it names something
-     * the reader is being taught.
-     */
-    tone?: "muted" | "foreground" | "accent";
-    children?: React$1.ReactNode;
-}
-/**
- * The smallest heading in the system: a label over the thing it names.
- *
- * `WHY IT MATTERS`, `1 · CONNECTED`, `OPTIONAL`, `REFERENCED COMPONENTS`. It
- * titles a band of content without the weight — or the 35px and the rule — of
- * a {@link SectionHeader}, so several can sit in one scrolling column and still
- * read as subordinate to the panel's own title.
- *
- * Uppercase at `text-meta` with tracking, because at this size caps are what
- * separate a label from the sentence under it; lowercase at 11px reads as body
- * copy set small. That is also why it is a component rather than four utility
- * classes: the treatment was being retyped, and a label that drifts a weight or
- * a tracking step in one panel stops reading as the same kind of thing.
- *
- * `tone="accent"` is for a label that names something the reader is being
- * *taught* rather than something they are scanning — a callout's kind, a
- * concept's name. Use it rarely; muted is the default for a reason.
- */
-declare const Eyebrow: React$1.ForwardRefExoticComponent<EyebrowProps & React$1.RefAttributes<HTMLDivElement>>;
-
 interface SectionHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
     /** Sits before the title. A 14px lucide icon, usually. */
     icon?: React$1.ReactNode;
@@ -2852,6 +3822,10 @@ interface TaskNodeProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "ch
     taskKey: React$1.ReactNode;
     /** What it may spend. */
     bound: Bound;
+    /** The bound's swatch class, given directly — `bg-data-7`. */
+    boundSwatch?: string;
+    /** The bounds' palette, when a caller would rather state the map once. */
+    boundPalette?: BoundPalette;
     /**
      * How it went, when this node is painting a **run**. Omit when the node is
      * painting a plan or a draft, which have no status of their own.
@@ -2934,7 +3908,12 @@ type TerminalLineKind = "prompt" | "output" | "comment";
  * command you typed, what it printed, a comment. A run's log has no prompts and
  * no comments; every line is output, and what varies is how loud it is.
  */
-type TerminalLevel = "info" | "warn" | "error" | "debug";
+type KnownTerminalLevel = "info" | "warn" | "error" | "debug";
+/**
+ * The values the kit draws specially — **suggestions, not a limit.** Anything
+ * else renders with the neutral token and its own name.
+ */
+type TerminalLevel = KnownTerminalLevel | (string & {});
 interface TerminalLineProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
     kind?: TerminalLineKind;
     /**
@@ -3326,4 +4305,4 @@ interface UseOverflowItemsResult {
  */
 declare function useOverflowItems({ count, enabled, pinnedIndex, reserve, }: UseOverflowItemsOptions): UseOverflowItemsResult;
 
-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, type Bound, BoundChip, type BoundChipProps, 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, ClampedText, type ClampedTextProps, 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, 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, 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, type MetricTone, 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, 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, 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, Tour, type TourController, type TourProps, type TourReference, type TourStep, TreeItem, TreeView, type TreeViewProps, Typography, TypographyBlockquote, type TypographyBlockquoteProps, TypographyH1, type TypographyH1Props, TypographyH2, type TypographyH2Props, TypographyH3, type TypographyH3Props, TypographyH4, type TypographyH4Props, TypographyH5, type TypographyH5Props, TypographyH6, type TypographyH6Props, TypographyInlineCode, type TypographyInlineCodeProps, TypographyLarge, type TypographyLargeProps, TypographyLead, type TypographyLeadProps, TypographyList, type TypographyListProps, TypographyMuted, type TypographyMutedProps, TypographyP, type TypographyPProps, TypographyPre, type TypographyPreProps, TypographySmall, type TypographySmallProps, UnderDevelopment, type UnderDevelopmentProps, type UseOverflowItemsOptions, type UseOverflowItemsResult, type UseTourOptions, type Verdict, agentChipVariants, badgeVariants, SWATCH as boundSwatch, buttonGroupVariants, buttonVariants, chatSessionGutterClass, cn, navigationMenuTriggerStyle, statusDotVariants, toggleVariants, useOverflowItems, useSidebar, useTour };
+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 };