# @lotics/ui — where each entry does NOT go

<!-- Generated by `npm run generate:catalog-roles` from dev/contract_roles.ts. Do not edit. -->

Every component the kit publishes, with the one question that decides whether this is the entry for
the job. Asserted against `package.json#exports` both ways, so it cannot name a component the kit
does not ship or omit one it does. Read [`llms.txt`](../llms.txt) first — which entry answers which
data ROLE, its import, the worked screens — then check the entry you picked here. The props are
`dist/<module>.d.ts`.

| Entry | Never for |
|---|---|
| `Accordion` | Is the fold inside prose? A quiet reveal in a sentence is `TextDisclosure`, which draws no band. |
| `AccordionContent` | Is the body a whole screen? A fold hides content behind a press — a destination is a tab. |
| `AccordionHeader` | Is the content always open? A header that never collapses is a `SectionHeading`. |
| `AccordionMeta` | Is the detail the reason to open? Then it belongs in the title — a reader should not open a fold to find out whether to. |
| `AccordionTitle` | Is the title the section's? A page section's title is `SectionHeadingTitle`, at the surface's own rung. |
| `ActAsksDialog` | Is the act its section's one act, or its primary? Then its asks stand inline above its `ActGroup`, as more of the section's fields. This one is pressed from a header, a menu, the ticked rows' bar or beside a section's primary, and is titled with its verb and what it runs on. |
| `ActGroup` | Is it an act whose asks cannot stand inline — a menu's, the ticked rows', one that is not its place's primary? That is `ActAsksDialog`. Is it a correction of what is done — an undo, a cancel, a removal? It waits in the ⋯ of what it acts on (`ActionMenu`). Here, at a section's or a drawer's foot, every act one button form — a step's destructive outcome a danger-toned button — the destructive verb left and the primary right, each act's gaps said over the row before the press — `missing` holds the button, `blank` only says so; an act's `id` is where a `CalloutLink` lands. |
| `ActionMenu` | Is there one act? A ⋯ hiding a single verb costs a press and names nothing — put the verb on the row. |
| `ActivityIndicator` | Is the progress known? A determinate value takes `Progress` — a spinner over a measurable job hides the measure. |
| `ActivityIndicator variant="dots"` | Is this the only thing on screen saying so? The rhythm announces NOTHING — a region with nothing to show yet is `RegionState state="loading"`. |
| `AgentRun` | Is the run finished? A stored record filled by several writers is the record's own surface, not the feed. |
| `AgentRun variant="pane"` | Is the run incidental to the screen? A pane claims the screen's width for work the reader is only glancing at. |
| `AgentRun variant="pill"` | Is the run the screen's subject? The compact form hides the detail the reader came for. |
| `AgentRunActions` | Is the bar inside the feed? The feed follows its newest part, so a Stop rendered there scrolls away exactly while the run is doing the thing to stop. |
| `AgentRunDialog` | Does the surface have no footer? A standalone `AgentRun variant="pane"` keeps its own action row — the frame exists to move the verbs into a `DialogFooter`. |
| `Alert` | Is the act DESTRUCTIVE? `Alert.confirm` owns that one and everything a caller must not decide about it, leaving `Alert.alert` what destroys nothing. Is the decision already made? An outcome that needs nothing is `useToast`; a state to act on inside the flow is a `Callout`. |
| `Alert tone` | Is the act a delete? Leave the tone alone — `danger` is the default and speaks for the irreversible write. `primary` is for the blocking question a SPLIT, a promotion or a many-row post asks, without a commit painted the colour of a deletion. |
| `AppIcon` | Is the subject a record rather than an app? A record's mark is an `Avatar`; this is the tinted tile a workspace's apps are recognised by. |
| `AutoSizer` | Does the child already fill its parent? A measured box exists for a canvas or a virtualizer that needs numbers, not for ordinary layout. |
| `Avatar` | Is the subject a THING? A picture of goods is a `MarkStack` mark of kind `thing`, one holding no picture its placeholder — initials are a person's or an organisation's, never an order's; round is the shape the kit spends on a face. There is no HUE: a mark you wanted in a particular colour is a `Status` or a `Chip`. And no size picked by hand: `identityRung` of the text block beside it. |
| `BackButton` | Can the reader go back? Rendered where the stack is empty it is a control with nothing behind it — gate it on `canGoBack`. |
| `BarChart` | Do the parts make a whole? Parts of one total are a split `Progress` or a `PieChart`; bars compare independent categories. |
| `Box` | Is there more than one child to space? A run with a gutter is `Stack` — a `Box` full of hand-set margins is how a screen leaves the 8-grid. |
| `BrandMark` | Is the glyph the app's own language? Everything Lotics draws itself is `Icon` — this is the narrow allowlist of third-party marks, so a name outside it fails to typecheck rather than rendering the wrong company's. |
| `Breakdown` | Is the tail long? `maxRows` folds it — a card that grows with its data breaks a row of cards aligned to one height. |
| `Button` | Is the control icon-only? That is `IconButton` — a title-less `Button` is a type error, because a name is what a listener gets. |
| `CalendarView` | Are RESOURCES the rows — a chair, a machine, a room — with time along each? That is `LaneBoard`; a calendar's axis is days. |
| `CalendarView renderEvent` | Is the replacement a `Chip`? It fills the chip the grid already laid out and sized — a dismissible pill inside one says the reader put the event there, where this is the calendar's own datum. |
| `Callout` | Did a CHECK produce it? Two readings that disagree plus a magnitude is a `Finding`; a callout throws the ranking and the delta away. |
| `CalloutActions` | Is the outcome one the reader does nothing about? Queue it with `useToast` — it is gone in five seconds and holds no verb. Does the verb already stand where its work is done? Point there with a `CalloutLink` rather than draw it twice. |
| `CalloutDescription` | Does it carry a verb? An act belongs in `CalloutActions`, where it is reachable, not buried in the prose; and it never stands without the title it explains. |
| `CalloutLink` | Does pressing it write? A link only brings its place into view and rings it; a verb run from the callout itself is `CalloutActions`. It lands on an element by its id — an `ActGroup` act's `id` wears the landing ring. |
| `CalloutTitle` | Is it what the message means for the reader — what it refuses, what to do next? That is the muted `CalloutDescription` under it; the title is the message itself, and a one-line callout is its title alone. |
| `CaptureSources` | Is the reader starting agent work? That is `Composer`; this picks what a recording captures, and draws no Start of its own. |
| `Card` | Is the card a GROUPING device? The idiom is washes, rhythm and hairlines — a region of a page is a `Section`, and a card is a ROLE. |
| `CardBody` | Is the content the whole card? A card with only a body is a `Box` with a shadow. |
| `CardFooter` | Does the footer hold the primary act? The primary act rides the heading row; a footer closes with totals or secondary verbs. |
| `CardGrid` | Do the rows have nothing to be recognised BY? A register with no picture and no mark is a `Table`. |
| `CardGrid variant="tile"` | Is the card carrying facts? A tile is its picture with the name beneath, at the density a reader RECOGNISES at; three figures under a photograph is the card variant in smaller type. |
| `CardHeader` | Is the add verb elsewhere? A section's ADD rides the heading row, right edge — never below the content it adds to. |
| `CardHeaderMeta` | Is the detail a status? A state the item holds is a `Status` on the item, not a note in its heading. |
| `CardHeaderTitle` | Is the card a page section? A page's section title is `SectionHeadingTitle`, whose rung the surface decides. |
| `CellStack` | Is the second line a SENTENCE? A supporting line takes a reference, not prose — an explanation truncates to the clause the reader already knew. |
| `ChargeLine` | Is the derived amount on a second line? The arithmetic reads ACROSS the row and ends at the amount — hung underneath it lands in no column. |
| `ChargeLines` | Is the money already settled? A settled set is a `Table` totalled at its foot; this band exists to be typed into and closes on its own total. |
| `Checkbox` | Is the whole row the control? A settings row is a `SwitchRow`; a bare checkbox beside a label leaves the label unpressable. |
| `Checkbox without onChange` | Can the reader change it? Then pass `onChange` — without one the box is a DRAWN mark with no tab stop, which is what a read-only boolean in a row should be and what an operable control must never be. |
| `Checkbox shape="ring"` | Does ticking mean CHOSEN? A pick takes the square box — the ring says FINISHED, and the two readings are not interchangeable. |
| `Checklist` | Are the same four values compared across twenty rows? That is a `Table` — a checklist scans down one column of marks. |
| `ChecklistActions` | Is the verb about the whole list? A list-level act belongs on the section's heading row, right edge. |
| `ChecklistGroup` | Is the group a phase of a sequence? Then the list is `connected` — grouping alone claims no order. |
| `ChecklistItem` | Did an inspection SETTLE it? A settled row takes `verdict`, and `onToggle` beside it is withheld — neither mark has a fail-shaped state. |
| `ChecklistItem tone` | Is the row a TASK? A task's mark says done or not, in the run's ink. `tone` paints the mark in the data colour of the thing the row IS — for the one row a record stands in, where the same family the register's dot wears says 'here'. |
| `ChecklistNote` | Is the text a field's hint? A field's error, warning and description belong to the field — pass the three strings to `FormField` or `DetailRow` and let the row order them. |
| `ChecksCallout` | Is it one message about the page rather than the record's standing checks? That is a `Callout`. Here each check is its words over what it means — the blocking ones first, in the danger tone, naming what they refuse; a check refusing only edits or deletes is `tone: "lock"`, quiet and neutral, never red. |
| `Chip` | Is it a status? A chip is something the reader put there; a state the record holds is a `Status`. |
| `ChoiceList` | Do the options need no description? A plain list of labels is a `Select` — descriptions are what earn the vertical space. |
| `ChoiceList allowCustom` | Is the option set the whole answer? Then leave it off — an escape row invites a value nothing downstream can read back. |
| `ChoiceStrip` | Are there more than a few options? Past four cells the track runs off a phone and becomes a `Select`. |
| `ChoiceStrip variant="chips"` | Do the positions have to stay fixed? Chips wrap — a set read DOWN a column of rows is a `ToggleStrip`. |
| `ChoiceStrip overflow="scroll"` | Is this a required select in a form? Then leave it wrapping — a field that hides half its values behind a swipe is a worse `Select`, not a better one. |
| `ChoiceStrip variant="tiles"` | Is the choice a setting the reader comes back to? That stays a strip or chips. Tiles are for an ANSWER given once and moved on from — what happened, how it went — where the press is the whole act; an option's `shortcut` prints the key the surface binds to it. |
| `ClarifyWizard` | Is the question a CONFIRMATION of an act? Asking whether to let an act happen is an approval — this settles a parameter the run needs. |
| `ClarifyWizard questions` | Is there one question? Pass a run of one — the position overline and the Next are both absent, so a single ask reads as the plain question it is. |
| `ClarifyWizardActions` | Is there no `ClarifyWizardDialog` above it? It renders nothing without one, so the footer ships empty and the reader has no way forward. |
| `ClarifyWizardDialog` | Is there a second wizard inside? One wizard per frame — two would drive one footer bar from two positions. |
| `Combobox` | Is the set small and fixed? The root holds the query, the collection and the selection — over six options there is nothing to search. |
| `ComboboxContent` | Are the rows the caller's own JSX? It renders from the root's `options` — per-row content is the root's `renderOptionContent`. |
| `ComboboxContent footer` | Is the content pickable? The footer pins BELOW the listbox and outside its scroll, so the keyboard never reaches it — a row someone chooses is an `options` entry. |
| `ComboboxEmpty` | Is the field still empty? It renders only for a query that matched nothing — an untyped field browses the whole set. |
| `ComboboxInput` | Is the set small and fixed? A search field over six options asks the reader to type what they could have seen. |
| `CommentsButton` | Are there no comments? Show the count — a button that opens an empty thread promises a conversation. |
| `ComparisonBar` | Is the second number a CEILING? A value filling toward a maximum is `Progress`; a reference is a peer, and beating it is the point. |
| `Composer` | Is the field a record's? A composer is a command surface — a record's prose field is `MarkdownEditor surface="field"`. |
| `ContainerSizeContext` | Are you READING the size? `useContainerSize()` reads it, and null means the WINDOW is the container rather than that the read failed. |
| `ContainerSizeProvider` | Are you measuring here? `SizeBoundary` is the wrapper that reads the width — this one renders no box and takes the number already read. |
| `CopyButton` | Is the verb about the ROW? A reserved trailing column is paid by every row for the benefit of one, and a row carrying two values gives that column nothing to name. |
| `CopyButton variant="labelled"` | Is the copy riding a VALUE — a cell, a field's trailing slot? The glyph is the form there: a labelled button is wider than what it copies. Wear the words in a run of verbs where copying IS the job — still through this entry, never a `Button icon="copy"`, which hand-rolls the write and the report that follows it. |
| `Count` | Is the number a STATUS? A count is not a state — a mark in a status palette says the quantity means something it does not. |
| `Count more` | Is the number how many there are? That is the plain count; `more` is the REST beside the one drawn — `+2`, announced as the pack's "2 more". |
| `DangerSection` | Is the act reversible? A destructive frame around an ordinary setting spends the reader's alarm where nothing is at stake. |
| `DangerSection actions` | Is the act a `danger` `Button` passed as a child? A `DangerAction` carries the `ConfirmRequest` it raises, so declaring one here is what makes the fence ASK rather than merely warn; `children` is the non-standard body, where nothing is confirmed for you. |
| `DataGrid` | Is the set thousands of rows? It renders all of them — past ten thousand it lags, and paging does not compose with its groups. |
| `DateFilter` | Does the reader NAVIGATE the period rather than choose it? Stepping through months or weeks is `CalendarView`'s own toolbar; this is the range a register is read through. |
| `DateFilter variant="field"` | Is the filter always on screen? A panel that lives in a sidebar or a sheet is the default; the field is the trigger a toolbar has room for, and it carries the same panel in a popover. |
| `DatePicker` | Is the reader choosing a RANGE of days? A period is `DateFilter`; this states the date a record holds. |
| `DatePicker format="time"` | Does the record keep the DAY as well? A time without its day is ambiguous the moment the record crosses midnight — that is `format="datetime"`. |
| `DatePickerPanel` | Is there a field to anchor it? Standing alone the panel is a month grid with a field's chrome around nothing. |
| `DateStamp` | Is the date something a person ENTERS? A value to fill in is `DatePicker` inside a `FormField` — this is a readout that happens to be correctable. |
| `DetailRow` | Is the label a column heading? In a register the heading says it once; a label per cell prints it on every row. |
| `DetailTable` | Are the fields compared DOWN columns? A stack answers about one record; a comparison is a `Table`. |
| `Dialog` | Is it mounted while closed? Render it always and toggle `open` — a closed overlay that holds a body-level box is dead to every press. |
| `DialogFooter` | Is Save on the left? Cancel goes left, the commit right — the order is the kit's, not the call site's. |
| `DialogHeader` | Is there no title? `role="dialog"` is name-required — an untitled overlay announces as an unnamed dialog. |
| `DialogHeaderActions` | Is the primary act here? A dialog's commit sits in its footer, at the right edge. |
| `DialogHeaderTitle` | Is a size being passed? An overlay caps its own title rung, which is why a `##` inside one renders smaller than on a page. |
| `DialogNavigationProvider` | Is the dialog the kit's? `Dialog` and `MasterDetailDialog` provide it themselves — this is for a pane you assemble out of their parts. |
| `DialogScrollArea` | Does the body swap content? Pass `scrollKey` — a swapped record that keeps the old scroll opens halfway down. |
| `DiffMark` | Is the row unchanged and unremarkable? A mark on every row of a review makes the changed ones invisible. |
| `DiffValue` | Is the row's own change the point? What happened to the ROW is `DiffMark`; this is the before and after of one value. |
| `Divider` | Is it separating the rows of a register? Those carry their own rule — a divider added per row draws the line twice. |
| `Drawer` | Is the detail light? A fact one row needs expands in place — the drawer is for a heavy form. |
| `DrawerFooter` | Do the edits save on their own? A footer commit beside fields that already saved asks for a decision nobody has. |
| `DrawerScrollArea` | Does the panel step between records? Pass `scrollKey` so the next record opens at the top. |
| `EntryBody` | Is the entry only its words and its files? Then `renderContent` stays the default — this is what it RETURNS where an entry also shows or states, and its rungs are drawn in one order however they were written. `EntryBody.Words` is what the entry SAYS — its own words, or the consumer's editor over them — and under `onOpen` the three-line preview alone. `EntryBody.Evidence` is what it SHOWS — a recording through THE `MediaPlayer`, pictures, a chart, a diff — and a press on it acts on it rather than opening the band; a file that merely came attached is `files`. `EntryBody.Detail` is what it STATES or keeps behind a fold — the kit's own fact rows, a verbatim behind a `TextDisclosure` — and is not drawn inside a band that opens. No rung names a content kind; what the entry WAS goes on the supporting `lines`. |
| `FactGroups` | Is it a draft the reader may abandon? A new record is a `Dialog` of `FormField`s committed once; these are an existing record's fields, each resting as its control or as its value read (`readOnly`: text, at a control's pitch among controls), label above, and a group's own acts at its `foot`. A field a link lands on states its `id`, never a box wrapped round its value. |
| `FieldSurface` | Is the control a plain one? This is for the field that carries something beside it; a value that is not an editor is a `DetailRow`'s text. And is a FOOTER what commits the form the field sits in? Then the form owns the draft (`onValueChange`): `onSave` writes on the way past, which in a dialog saves twice. |
| `FileActs` | Is the file drawn by a kit file surface? `FilesEditor`, `FileRows` and `MediaView` stand one on every file already; this is for a row that IS one file and keeps its own entries (`items`), never a second ⋯ beside the row's. |
| `FileAddButton` | Does the set draw its own head? `FilesEditor` stands its add as its field's acts (`FormFieldActs`) — its label's line, else its own first line; this is for a heading the host draws over it (`addAt="host"`), never a second add beside that one. |
| `FileBadge` | Is the file an image? A photo's identity is its content — a type mark on a grid tile says nothing about which shot it is. Does it lead beside pictures and faces — a list's lead, a record's mark? It is a `tile`: a page edge to edge in a picture's square reads crammed into it. |
| `FileDropTarget` | Is the region a well? A dedicated well is `FileDropzone` — this wraps a region that already has content. |
| `FileDropzone` | Does the surface already hold files? The well is the EMPTY state, not the only way in — wrap the region in a `FileDropTarget` as well. |
| `FileGalleryDialog` | Is there one file? A gallery over a single file adds a next and previous that go nowhere — that is `FilePreview`. |
| `FilePreview` | Is the turn meant to stick? `rotation` is a VIEW — persist it through `rotateImageToBlob`, or it is gone on reload. |
| `FileRow` | Is the file a photo, a scan or a drawing? Those are identified by content and belong in a grid. Its air is the row's — a list's 72 floor, a register's own row — so its mark never stands flush with its press. |
| `FileRows` | Is it a record's files, pictures among them? That is `FilesEditor`: its pictures a grid, its documents these rows. Are they all pictures? A picture is known by its content, in a grid. |
| `FilesEditor` | Are the files one record ROW's? A row's attachments are `InlineFiles` on the inline grid, and on a line or in a cell a `MarkStack`. This one is a record's files, the value's width: its pictures a grid of previews, its documents rows by name, each opening in the viewer and each with its ⋯ (`onRename`, `onReplace`, `onRemove` add theirs), a drop zone with `onAdd` whose add stands at the end of its head line, the verbs in `FilesEditorBar`. |
| `FilesEditorBar` | Is the Add elsewhere? Files land three ways — the bar's CTA, a drag and a paste — and the bar is where the CTA belongs. |
| `FilesEditorBar verbs` | Is the act yours rather than the editor's? Drop the ELEMENT into the same list where it belongs in the order; it reads the selection through `useFilesEditorSelection()`, which is what a fixed toolbar had no room for. |
| `FileThumbnail` | Is the file one among documents read by name? That is a `FileRow`; here a document is its type — its badge, its card with its name at a tile's size — never a picture of its page. |
| `FileThumbnailGrid` | Are the files documents? Documents get a list, where the full name is the row. |
| `FilterBand` | Is the filter narrowed by daily? Only those belong here — a few, every one on a desk's line and none behind a press there (a phone's one Filters sheet holds them), the grouping one chip at their end; a facet with nothing to offer is left out, since an empty facet is a control the reader cannot use. |
| `FilterChip` | Does the editor commit on its own? `footer` adds a second band under an editor that already has one — reach for it only when a Save is real. |
| `FilterChip column` | Is the facet's editor the caller's own? Pass `label` and children instead — a column picks its control from `type`, so a rich face or a bespoke editor has nowhere to go. |
| `Finding` | Is there only one reading? A state with nothing to contradict it is a `Callout` — the discriminator is the shape of what was found, never who found it. |
| `FolderSwitcher` | Does the pick only narrow what is listed, with an "all" beside it? That is a `FilterChip` on the register's line. This names the row every read of the screen is scoped to, in the header, and leaving it is the list of those rows. |
| `FollowScroll` | Is the reader browsing rather than watching? Pinning a register to its end takes their place away on every push. |
| `FollowScroll showJumpToLatest` | Does the feed grow at the TOP? The disc names one direction and reads as a lie in a list that prepends. |
| `FormField` | Is the field in a record's value column? That column labels its rows itself — a form field's chrome prints the label twice. |
| `FormField layout="control-first"` | Does the control READ as the value? A switch or a checkbox does, so it leads and the label follows it; a field whose value is typed or picked stays stacked under its label. |
| `FormField layout="beside"` | Is it a form of a few fields in a dialog? Those stack. Beside is a long column read down its labels — a record's section, which `RecordFrame` sets itself. |
| `FormFieldActs` | Is the act the record's, or the section's? Those are an `ActGroup` or a `SectionHeading`'s add; this is drawn INSIDE a field's value, for what adds to that value alone — and a `FilesEditor` states its own. |
| `FormFieldLayoutContext` | Is the surface a record's section or a group of facts? `RecordFrame` and `FactGroups` publish it already — to their fields and to what an act asks under them — and a field's own `layout` wins over it. |
| `Funnel` | Do the stages partition one set? A funnel's stages are SUBSETS of the one before — a split whole is a split `Progress`. |
| `GroupByMenu` | Is the fold the author's rather than the reader's? This is a reader's choice among the register's filter fields, one at a time, cleared back to one run; a register the author folds is a `Table` of `TableGroup`s. |
| `HeadingSurfaceContext` | Is the pane one the kit renders? `DrawerScrollArea`, `DialogScrollArea` and `PopoverContent` publish it already, and the value is FLAT — providing it again claims a rung the ramp does not have. |
| `Icon` | Is the glyph the whole of a press? That is `IconButton`, which gives it the hit area and the name a bare mark has neither of. |
| `IconButton` | Would a word fit? A labelled act reads faster than a glyph a reader has to decode, so reach here only where the band has no room. |
| `ImageGallery` | Is the surface an overlay? The modal form is `FileGalleryDialog`, which brings its own chrome. |
| `InfoPopover` | Is there more here than a sentence? Anything interactive, or longer, is a `Popover` you compose. A hint a form always needs is the field's own description, visible by design. |
| `InlineButton` | Is the act outside a field? A standalone act is a `Button`; a jump or a reference is a `Link`; a row's act sits in the row's trailing slot. |
| `InlineFiles` | Are the files a whole SECTION? A section's attachments are the `FilesEditor` compound, with its own bar. |
| `Label` | Is it a heading? A region's title is `SectionHeading` — a label names a value or a block INSIDE one, and never in uppercase. |
| `Label over="block"` | Is the thing labelled a VALUE? A metric's caption, a field name in a cell and an artifact tag are the default rung — the block rung among dozens of siblings shouts. |
| `Landmark` | Is the region already one? A `main` inside a `main` and a nav inside a nav both leave the landmark list unreadable. |
| `LaneBoard` | Is each lane one RESOURCE whose free time is the answer — a chair's day, a machine's month? Only then: work read by its day is `CalendarView`, and a state per resource per day with no clock is `StateMatrix`. |
| `LineChart` | Is the last bucket partial? Count backwards from now — a half-finished final period draws a collapse that did not happen. |
| `Link` | Does the press stay here? An in-page act is a `Button`; the link ink promises a place to go. |
| `LinkValue` | Is the row opened from its register? That is the register's `Row`; this is the same recognition — picture, title, the line under it, the figure or meter — as a picker offers it and wherever it reads once chosen: the picker's field, a chip, a read fact, a child row's cell (`density="cell"`), a statement on a row's line (`density="line"`). |
| `List` | Are the rows columnar? Four values compared across twenty rows is a `Table`, where the columns are the reading. |
| `ListItem` | Is the row a RECORD in a register? That is `PressableRow` + `RowFocusEntry`; this is the lighter list row. |
| `ListItem variant="option"` | Does the right slot hold a CONTROL? A switch or a stepper needs the default `settings` row, whose 64px band presses BESIDE the slot — an option IS the button, and a button may not contain one. |
| `ListItem overline` | Is the line the subject's STATE? A lifecycle word goes in `right`; the overline names what KIND of thing the title is — the table a linked record lives in, the group a value belongs to. |
| `LoticsLocaleProvider` | Is one instance the odd one out? Every wired component takes `labels` — the provider is the whole tree's language, not one control's. |
| `Markdown` | Is the prose editable here? An editable markdown field is `MarkdownEditor`, which stays selectable at rest. |
| `MarkdownEditor` | Is the prose read-only here? A stored note nobody edits is `Markdown`, which renders it and nothing else. |
| `MarkdownEditor surface="field"` | Is the whole surface the document? A field drops the toolbar, so the writer types the syntax by hand on a screen that had room for the band — that is the default `document`. |
| `MarkStack` | Is the stack the row's door? It is inert by design — a second destination inside a pressable row is a button in a button. Is the STATE the row's rather than each mark's? A record wears one `Status`; a mark's `state` dot is for a set whose members are each somewhere different, it comes with the word that says what it means, and a set carrying it stops overlapping, because the tuck hides the corner the dot is drawn in. Are its documents read here? On a line or in a cell a set is one run — a lone document its chip, several one mark and a count; the whole set is `FileRows`. |
| `Matrix` | Is the cell a STATE rather than a number? A glyph per cell is `StateMatrix`, where a blank means nothing was due — here it means zero. |
| `MatrixGrid` | Are the totals inside it? Totals are `MatrixTotals`, laid out in the same columns so they cannot drift. |
| `MatrixHeader` | Are the columns the subject? The heading names the axis; the subjects run down the side. |
| `MatrixLegend` | Is there no wash behind the numbers? A legend for a heat scale nothing uses explains an absent encoding. |
| `MatrixTotals` | Is the total computed off another array? It closes the cells on screen — anything else cannot be checked. |
| `MediaPlayer` | Is the file an image? An image is shown, not transported — the controls have nothing to move. |
| `MediaPlayer fit="cover"` | Is the clip EVIDENCE — a recording, a file being previewed? It stays whole: a crop hides part of what was on screen and says nothing. Fill only where the surface is ITSELF a crop — a feed card, a tile — and a letterboxed still would misrepresent it. The poster follows the frames either way. |
| `MediaView` | Does the field hold several files, or is the file one of a list? Many are `FileThumbnailGrid`, a mark beside a name is `Avatar` with its file — this is the record's own picture or clip, read whole and replaced in place. |
| `MemberChip` | Is the person one column of a register? That is `chrome="cell"`, at the register's own rung. Inline, the face is its text block's rung (`identityRung`); `dense` is a person on a line of words — a row's supporting line, running text — never a record's band. |
| `MemberChip chrome="cell"` | Is the person the row's SUBJECT — a roster, a directory? That name is the row's own `CellStack` with a person's mark; the cell is who a row is ON — an owner, an assignee — beside its subject, every one it names in `members`. |
| `MemberPeek` | Does the row already press? Two destinations behind one object — a picker option and a row that opens keep the plain `MemberChip`. |
| `MemberSelect` | Is the filter meant to match UNASSIGNED rows too? Pass `clearable` with an `emptyLabel` rather than hand-rolling a mixed member-and-none `Select`. |
| `MenuButton` | Does the press DO something? A trigger opens a list; an act with one outcome is a `Button`. |
| `Metric` | Is the figure one of a band? A band of figures is `MetricStrip`, which aligns them; a row of loose tiles does not. |
| `Metric unit` | Is the figure preformatted words? A quantity stays a number with its `unit`, so `compact` reads it in the rung it reaches (12,5 tấn) and a goal still draws its ring. |
| `Metric also` | Is it one sum over rows held in different units or currencies? Each unit's total is its own figure, stacked under the first — most rows first — never one number. |
| `MetricStrip` | Is the band over a REGISTER's rows? Its figures stand in `ReadingGrid form="band"` beside its pictures, and the rows' count and total are the `TotalsLine` over them; this boxed grid heads a DASHBOARD. A strip of one is a `Metric` wearing a band's chrome. |
| `NumberFilter` | Does the figure live in a small known domain — a percent, one against a fixed bound? Pass `bounds` for the slider over it; an open-ended amount is typed into the ends alone, and a threshold the business names is a yes/no, never a range. |
| `NumberInput` | Is the reader choosing from the SHAPE of a continuous range? A value swept along a track is `Slider`; a field states a figure. |
| `NumberInput stepper` | Is the target more than a few steps away? The discs are for a quantity that moves by one — nudging to 470 is not an input method, and the plain box is what a figure with no ceiling in sight takes. |
| `NumberInput format` | Is the figure a quantity in a unit — kg, CBM, kiện? That is `unit`. This is ONE statement of what the box prints and what it will read back: money's code, a percent. |
| `NumberInput unit` | Is the figure money or a share? Those are `format`'s. A unit stands inside the field after the figure, and an entry in another unit it names converts ("12,5 t" into kg is 12 500) — never a second field or a word typed beside the box. |
| `OptionList` | Is there a field above it? `Select` and `Combobox` host this in their own popup — reach for it bare only for a command palette. |
| `OptionToggles` | Is it a parameter of the VIEW rather than the record? A mode, a density or a hot filter is `ChoiceStrip`; whether a field's set is chips at all is `choiceControl`'s answer — never on a record at rest — and a set read DOWN a register column is a `ToggleStrip`. |
| `OptionToggles multi` | Is the arity a display choice? It is the ANATOMY — several at once is a checkbox group each chip of which Tab reaches, one of N is a radio group the arrows move within — so it follows the FIELD and never the room on screen. |
| `OptionToggles mark` | Did the call site pick it? A chip leads with its OPTION's own mark — the one `Status` draws for the option once stored, so the chip ticked is the chip read; a mark chosen per screen is a second identity for the option. |
| `PageContent` | Is this inside an overlay? A `Dialog` or `Drawer` publishes its own body region and its own gutter. |
| `PageContent size` | Is the cap a number of your own? It names the JOB and `PAGE_SIZES` owns each width, so every register lands on one left edge and every record on its own, wide enough for its rail and comments. |
| `PageHeader` | Is the subject a RECORD? A record's head is `RecordHeader`; this names the screen. |
| `Pagination` | Is there a second pager below the rows? There is ONE per register, above them, on the summary row. |
| `PieChart` | Are there many slices? Past a handful the slices are unreadable and the ranked rows of `Breakdown` say it better. |
| `Popover` | Is the panel anchored to nothing? The root positions against the `PopoverTrigger` inside it — with no trigger there is no box to measure from. |
| `PopoverContent` | Is the content a form? A panel with a commit is a `Dialog` — a popover dismisses on an outside press. |
| `PopoverFooter` | Does the editor commit on its own? A second band under an editor that already has one asks the reader which is real. |
| `PopoverHeader` | Is the popover one line? A heading over a sentence spends two rows saying one thing. |
| `PopoverNavContext` | Are you reading the route? `usePopoverNav()` reads it and throws outside a `Popover`, where a `PopoverScreen` would otherwise render nothing forever. |
| `PopoverNavHeader` | Can the reader go back? Rendered with an empty stack it is a control with nothing behind it. |
| `PopoverScreen` | Is there one panel? A single view needs no route — the screens exist so the back chevron has somewhere to go. |
| `PopoverTrigger` | Does the child install an `onClick` of its own? The press arrives as `onPress`, and a control that overwrites the DOM handler swallows it — the panel then never opens, with nothing to see. |
| `Portal` | Is there no host above it? It renders NOTHING rather than escaping to `document.body`, which lands outside the focus trap that owns the overlay. |
| `PortalHost` | Is the overlay the kit's? Kit overlays portal themselves — mount this at the root and inside a takeover, whose stacking context would otherwise trap what escapes it. |
| `PressableRow` | Does the row carry its own controls? Then this is the SURFACE only and the tab stop is a `RowFocusEntry` sibling — never one pressable wrapping the lot. The one exception is `variant="card"`, whose content is a label by construction and which therefore IS the button. |
| `Progress` | Is there no maximum? `max: null` is the unbounded form with an `unboundedLabel` — an invented ceiling reports a share nobody set. |
| `Progress shape="ring"` | Is the reading taken as a LENGTH, down a column or across a band? Lengths compare only against each other, so that is the bar, and a level read against its limit is the compact inline bar; the ring is the reading that IS its whole cell beside other values. |
| `Progress compact="inline"` | Is the meter in a COLUMN? That is `compact`, whose track takes the width it is given; `inline` is a meter inside a line of text, a short fixed track at the line's rung. |
| `Progress caption` | Does the bar NEVER print a figure? Then `format="none"` alone, and no slot is seated. `caption={null}` is one row saying nothing in a column whose other rows print theirs: the compact figure's slot stays, empty, so every track in the column is one length. |
| `Progress pace` | Is the bound a CEILING? A ceiling does not pace — past it is past it on any day. `pace` is the share of a FLOOR due by now, a caret over the track that judges nothing: the `tone` is the caller's, read against the same share. |
| `Progress gate` | Is the reading passed short of `max`? Only then — `gate` is where it passes as a share of `max`, 0..1 like `pace`: a solid mark proud of the track, spoken beside the reading and printed under a stacked bar after its name (`gateLabel`, else the kit's word for a pass mark), and a fill short of it warns (a minimum not yet reached) while one at or past it reads calm. A target passed whole is `max` itself, and a verdict against the paced mark stays the caller's `tone`. |
| `RawPayload` | Is the reader not a developer? A wire payload on a business surface says the screen ran out of language. |
| `ReachButton` | Is the act done here, in the app? That is a `Button`. This opens a call, a message or a thread and knows when the reader is back, when `onReturn` asks what happened — never a bare `tel:` link, which learns nothing of the return. A record's head act, a queued act and a row's verb leave through it alike. |
| `ReadingGrid` | Are the readings a register's own, over its rows? They are `form="band"` — one low line under the title, always drawn, each picture drawn to `READING_BAND_BODY` — since the grid's full cards push the rows off the first screen, and a press hiding them hides what the owner reads first. A card given its own width beside another leaves a ragged row; here each states its units and the row fills. |
| `RecordFrame` | Are you placing the record's parts yourself, or deciding when its sections get a rail or tabs? The frame owns where the header, the checks, the sections — each its fields, its acts under them (at its foot under what they read, `actsLast`) and what it holds, in the order of the work, a step holding nothing yet saying what it waits on (`note`) — and the comments go; from three sections, a page's rail and a drawer's tabs. A section that is a workspace of its own is `onOpen`, drawn on its own page with no `header`. What a record needs beyond that is a block whose body is a component. |
| `RecordHeader` | Is a badge or a verb going beside the title? The title stands alone and takes the width first — the figure rides the status line where the title would wrap beside it; the status leads the line under the title, the figure stands at the right. No act is a button here: an act stands at the foot of the section it works in (`ActGroup`), and what corrects or removes the whole record waits behind the ⋯. |
| `Recording` | Is it one media file with no transcript? That is `MediaPlayer`; this one draws one player for a capture that kept both video and audio, and badges what was captured. |
| `RecordingRun` | Is the run an agent's? That is `AgentRun`; this one captures sound, and its verbs are Stop, Retry and Resume. |
| `RecordingRun variant="pane"` | Has the person moved on to other work? The pane takes the surface it was started from; a recording that outlives that screen is the panel. |
| `RecordingRun variant="panel"` | Is the recording the screen's subject? The panel floats over other work; where the recording is the subject, the pane takes the surface. |
| `RecordingRun variant="pill"` | Has the person not asked to fold it away? The pill is the panel minimized; a recording floating over other work opens as the panel, so nobody misses it. |
| `ReferenceField` | Are the other record's fields on this one? A reference is a FIELD that peeks — never its own section, never a card. |
| `RegionState` | Is there still content in the region? This REPLACES it — a message beside working content is a `Callout`, and a read whose shape is known is a `Skeleton` rather than the loading state. |
| `RegionState compact` | Is the empty thing the whole SCREEN? Then it is the region-wide form, which sets its block in 48 and centres it. This one is a BAND inside something already named — one line, set left, its act on that line. Its act goes only where the band has no heading row to carry one. |
| `RemoveButton` | Is the tile in a selection surface? A selection's removes belong to the bar, applied to the set the reader built. |
| `ReorderItem` | Is the position stored on the row? Derive `positionLabel` from the index — a stored position lies the moment the list is reordered. And is the whole row draggable? The grip exists so the row's own text stays selectable. |
| `ReorderList` | Does the order survive a reload? Without a persisted rank the reader arranges, leaves and finds it rearranged. |
| `ReorderList reorder="buttons"` | Is the number of positions FIXED? Origin and destination are two fields; the rail exists for a variable middle, and the pair is for a run of three-to-six that does not need a drag's expressiveness. |
| `ResultHeader` | Is the subject the record rather than what just happened? A record's head is `RecordHeader` — it names an identity at `#` and pins a figure, where this names an EVENT at `##` and pins the way out. |
| `Row` | Does a surface already draw these rows? A register's cell is `CellStack`, a set of records `CardGrid`, a log or a schedule `Timeline` — each IS this row; compose `Row` by hand only where none fits, and never to restyle one of theirs. |
| `RowFocusEntry` | Does the row hold nothing but text? A plain row is its own button; the door exists to keep a button out of a button. |
| `Screen` | Is there only one screen? A router around a single surface adds a stack nobody pushes onto. |
| `ScreenRouter` | Does the surface bring dialog chrome? `Dialog` and `MasterDetailDialog` provide the stack themselves — this is the bare one for a container that has neither. |
| `ScreenRouterContext` | Are you READING the stack? `useScreenRouter()` reads it and throws outside a router, which is the failure you want rather than a null nobody checks. |
| `ScreenRouterInternalContext` | Is a screen being registered? `Screen` registers its own pattern — the registry is the router's wiring, published only because `Screen` lives in another module. |
| `ScrollArea` | Is the page itself the scroller? Wrapping the page body in one takes the browser's own scrolling away and strands the reader's position. |
| `Section` | Is the region INSIDE another section? A named group within one is a `Subsection`, at the lower rung. |
| `SectionHeading` | Is the rung picked at the call site? There is one heading component and the CONTAINER publishes the surface. |
| `SectionHeadingAdd` | Is the add an opener inside the body — under the last row, at the foot of a queue, above a composer? Its one place is the heading row's trailing slot; the composer or draft it opens stands in the body, and `expanded` says so. |
| `SectionHeadingMeta` | Is the act in the meta slot? A section's ADD is `SectionHeadingAdd`, at the heading row's right edge. |
| `SectionHeadingTitle` | Is a size being passed? It takes none — `##` on a page and `####` in a pane, decided by the surface. |
| `SectionNav` | Is the surface a RECORD? `RecordFrame` draws its sections' rail and strip itself. This one is for a document or a settings surface that is long because its CONTENT is: a rail in the gutter, a pinned strip on a narrow column, the section in view highlighted. |
| `SectionNav items` | Is the item a step of work that progresses? Then it carries `step`, never a glyph; any other item may carry `icon`, the glyph of what its section holds, in the same slot. An item that leaves for a page of its own is `page`, a link ending on a chevron that `onOpen` follows. |
| `SectionStack` | Are these the groups INSIDE one section? That is `SubsectionStack` — this owns the 48px beat and hairline between top-level blocks. |
| `Select` | Does the reader type to find the value? Search-as-you-type, async or create-new is `Combobox`. |
| `Select native` | Does an option need a colour or a face? Native options render text only — a status swatch, an avatar or a two-line row needs the kit's own listbox, which is the default. |
| `Select size="md"` | Is this a form field, a value column or an option list? Those are one 40px band and the default holds it — `md` is the dense strip a document toolbar draws, where the discs beside it are already 28. |
| `Select layout="grid"` | Is the choice made by reading its name? A status, a person or a category keeps the list, where the words are the value — `grid` is for a set told apart by SHAPE (a glyph, a channel's mark, a swatch), drawn as tiles the arrows walk by row and column. |
| `Select chrome="cell"` | Is the column a READING? A value nothing writes is its own cell — a `Status`, a `Text` — and this is the same drawing with the press, in the field's hairline frame hugging it so it reads as editable at rest: no chevron, none of the field's height or ground. A column of full fields is a form, so `cell` belongs wherever a register lets the reader decide from the row. |
| `SelectionBar` | Is nothing selected? The bar exists for a set the reader built; a permanent action bar is the screen's own header. |
| `SelectionBar danger` | Is the bulk delete one of the `children`? Declared here it lands rightmost in `danger-secondary` and is handed the bar's OWN count, so the question cannot name a number the act does not run over. |
| `ShortcutBadge` | Is there a keyboard? On a phone it prints a key nobody can press — the entry renders nothing at narrow widths for that reason. |
| `SizeBoundary` | Is the question about the DEVICE? That is `useScreenSize`; this reports the nearest container. |
| `Skeleton` | Is the shape unknown? A skeleton that does not mirror the layout swaps for content of a different size and shifts the page. |
| `SkipLink` | Is there a landmark to skip TO? Without a target region the link moves focus nowhere; it belongs beside a `Landmark`. |
| `Slider` | Does the exact number matter? A slider is for a rough magnitude; an exact figure is typed into `NumberInput`. |
| `SocialPostPreview` | Is the network a guess, or does no API reach it? A post a person pastes by hand is its words in a `CopyButton` — this card folds at a network's fold and counts against its limit, both promises a destination with no feed cannot keep. |
| `SortHeader` | Does the set arrive sorted by the server? A control that reorders one page lies about the whole register. |
| `SortMenu` | Do the rows stand under a header row that seats every column? Its headers are the order; this is for rows with none (cards, a calendar) and a phone's two columns, in the Filters dialog. |
| `Sources` | Are the sources already the content? A `Finding`'s readings ARE its provenance — chips under it repeat the same names. |
| `Spacer` | Is the gap between every child of one run? Then it is the parent's `gap` — a spacer per child is the gutter written N times. |
| `Sparkline` | Are the values to be read? A sparkline has no axis — a figure someone quotes needs `LineChart`. |
| `SplitPane` | Is it standing alone? A weight outside a `SplitRow` divides height instead of width and clips the lighter pane. |
| `SplitRow` | Is the pair meaningless apart — a value and its unit? Those are one thing; this is for two CARDS. And does the box around it have a width of its own? A row inside a `max-content` panel takes its width FROM the panes and then re-divides that by weight. |
| `Stack` | Is the run a screen's whole body? A page's column, gutter and cap are `PageContent`'s — a `Stack` knows nothing about the edge it sits on. |
| `Stack columns` | Are the children unequal? Columns make them PEERS of one width — a list of rows that size to their own content stays on the axis, where `divided` and `direction` live. |
| `StackedBarChart` | Is there ONE whole? A single stacked row is a split `Progress`, which fills its own track. |
| `StateMatrix` | Does a blank cell mean zero? Here it means nothing was DUE — a count belongs in `Matrix`. |
| `StateMatrix cells="words"` | Does the reader need WHO or WHERE inside the cell — a week's roster? Only then: a month read at a glance keeps the mark, which a worded column's width would push off the screen. |
| `StateMatrix axis="none"` | Are the positions named? Dated columns keep the default axis — dropping it takes away the header a reader runs a finger down. |
| `StateMatrix mark="intensity"` | Does the reader need the NUMBER? Density is colour-only — a figure someone quotes belongs in `Matrix`. |
| `StateMatrix onSelectState` | Is the legend informational? Leave it off — a pressable legend promises a drill, and only the host narrows: the matrix marks the pressed entry, nothing more. |
| `StateMatrix onAddCell` | Does the reader write the rows the cells stand for — a shift, a trip, a booking on a resource's day? Only then: it turns every blank into the press that adds one there, which a read-only roster's blanks must not be. |
| `Status` | Is it a type, a category or a count? Supporting detail is the muted second line under the identity, never a second chip. And is the state SETTLED? `activity="live"` belongs to a state that is still moving. |
| `Status mark` | Did the call site pick it? `mark` is the OPTION's own — a channel's `BrandMark` or a kit glyph, stored on the option beside its colour — and stands in place of the dot with the label kept, on every surface drawing that option; a mark chosen per screen marks one option two ways. |
| `StatusChips` | Is the field not the register's status? Any other narrowing is a `FilterChip`; the status alone stands as chips with counts, opening on the work that is not closed. |
| `Step` | Is the step a task? A task is a `ChecklistItem`, which carries a mark and a verdict. |
| `Step status` | Is the run PROGRESS? Only then do the reporting faces apply — `done` ticks a rung somebody finished, and on a run that is merely ordered (a trip's stops, a round's drops) a tick says every one of them already happened. Those rungs are `mark` — the run's own node, filled, carrying its `ordinal` — and a rung that CONTINUES the one above is `through`: no node, the line unbroken. The ink is the RUN's; the one rung the run stands IN may carry the thing's own (`tone`). |
| `Step tone` | Does every rung have a colour? Then the run is several runs — a hue per rung is what the eye reads instead of the position. `tone` is the data colour of the ONE thing the run is at (a record option's family, the register's own dot), on that rung alone; the rest wear the run's ink. |
| `Stepper` | Do the rows get MARKED by the reader? Anything ticked is `Checklist` — a stepper reports a position, it does not take one. |
| `Subsection` | Is it a top-level block? Those are `Section`s — nesting the wrong one swaps the heading rung and the beat. |
| `SubsectionHeading` | Is the group a page section? A top-level block's heading is `SectionHeading`. |
| `SubsectionHeadingTitle` | Is a weight being passed? Semibold is the heading rung — a labelled BLOCK that is not a heading is a `Label over="block"`. |
| `SubsectionStack` | Are these top-level page blocks? Those take `SectionStack`; nesting the two swaps a 48px beat for a 24px one. |
| `Summary` | Do the buckets overlap? They must PARTITION the set — an aggregate beside them makes the headline the sum of a set that does not exist. |
| `Summary total` | Is the figure a literal? `total.value` is for a count something ELSE made over the same rows; omit it and the buckets are summed, which is the only way the headline cannot drift from the bar under it. |
| `Summary metrics` | Is the figure a slice of the set? A slice is a bucket — a metric is what the same rows are WORTH, and the bar must not carry it. |
| `Summary distribution=false` | Do the buckets add up to the whole? Then draw the bar — dropping it leaves a legend of counts with no shape, which is `TotalsLine`. |
| `Switch` | Does the change need saving? A switch that waits for a Save button says it already applied. |
| `SwitchRow` | Does the row hold a second control? The row IS the switch, so its children are inert — anything pressable inside is unreachable. |
| `TabItem` | Are you rendering a strip the kit ships? `Tabs` renders its own items off the strip's part accessor — this is for a strip you draw yourself. |
| `Table` | Are all the columns measures you came to COMPARE? That is `DataGrid`, which sheds nothing; a register indexes objects and drops columns by priority. |
| `Table priority="never"` | Is the column merely important? `priority: 1` ranks it and it still drops last rather than never — `"never"` takes the whole register to the pile when the kept set will not fit, so marking most of the columns says nothing and stacks a desk that had room. |
| `TableCell` | Is the column hidden on narrow screens? The cell and the `columns` entry are two edits — derive both from one value or they drift apart. |
| `TableGroup` | Does the register PAGE? Grouping and paging do not compose — a group band over one page names a set the reader cannot see. |
| `TableGroup head` | Is the band a state rather than a record? A record the rows belong to — an invoice over its lines — heads them as a row with `head`: its file, line, stage, figure and acts; a state is a label. |
| `TableRow` | Is the extra fact needed by EVERY row? Then it is a column — the `detail` fold is for what one row needs. |
| `Tabs` | Do the tabs have an ORDER the work follows? A lifecycle takes `order="sequence"`, where the array is the process. Does picking one LEAVE what the reader was reading? Those are the app's own screens — they are another app. |
| `Text` | Does the surface decide its size? A section's title does — that is `SectionHeadingTitle`, which reads the surface the container publishes. |
| `TextDisclosure` | Does the reveal need a heading and a body? A titled fold is `Accordion`; this is a quiet marker inside prose. |
| `TextInput` | Is the value a number? A numeric field is `NumberInput`, which brings the keypad and the alignment. |
| `TextInput type="search"` | Does the field hold a value the record keeps? A search box filters what is on screen and nothing stores it — that is what earns the glyph, the clear affordance and Escape, and a pasted list kept as its lines, one token naming how many. |
| `TextInput font="mono"` | Is the value language a person wrote? Mono is for CODE a machine reads back — a template, a workflow source, a field key — and prose in it is a field pretending to be a terminal. |
| `TextInput reading="struck"` | Is the value ITSELF struck, or is the ROW done? This marks the value a completed item still carries; a row's own state is the register's, and `link` is the other reading — an address. |
| `TextLink` | Is it the row's own destination? It does not act — it has no `onPress`; a whole-row door is `RowFocusEntry`. |
| `Timeline` | Is the question where the RECORD stands in its sequence? That is its status, a `Status` in `RecordHeader`, or a `Stepper`. Is the feed the agent's? A run's feed is `AgentRun`. This one holds what happened or what is planned, in order: a log read newest first, a thread read oldest first, a schedule numbered down its days, an agenda counted from its first day (`day.from`). |
| `Timeline answer` | Is the mark a per-entry yes/no — read, pinned? That is the row's own control: this one is EXCLUSIVE, so it takes the id of the one entry that answers and offers the move on the others. |
| `Timeline title` | Is the entry a NAMED thing — a notice sent, a call logged? Then it carries a `title` and the name leads, who and when moving to the line under it. An entry that is only its words — a comment, a reply — has none, and leads with who wrote it. |
| `Timeline onOpen` | Are the entries read HERE, whole — a discussion? Then nothing opens. A log whose entries are read on their own screen takes `onOpen`: the band is the door, the words a three-line preview, and the body's detail is left to the open. |
| `Timeline group` | Do the entries run across days the reader files them by? Only then `group="day"` — a head per day in the list's order with its count, the when on each entry the time alone. Three replies under one question want no heads. |
| `Timeline rail` | Is the ORDER the point — a schedule's stops? Then a rail: `dots` for the run's plain node, `numbered` for the entry's ordinal within its day. A thread is ordered by nothing but time, and a rail would claim it is. The node is the kit's own — `Stepper`'s — never a hue per entry. |
| `Timeline mark` | Did a PERSON or a PARTY write it? That is `author`, and the face is theirs. A mark stands where a face would on an entry nobody wrote — a glyph in a tinted disc for a notice sent or a change recorded, a picture for a thing the entry IS. Never both. |
| `Timeline stage` | Is the stage the RECORD's? That is its status in `RecordHeader`. This is the entry's own — a stop booked or cancelled — standing where the row's stage stands, the option's dot beside its word exactly as the register states the field; `stageOn="line"` folds it onto the last supporting line at that line's own type instead. |
| `Timeline event` | Did someone WRITE it? Then it is one of the list's entries. A thing that happened to the subject — a stage reached — drawn by date among what was written is an `event`: a quiet line in its place, never a door nor an answer. |
| `Timeline at` | Is the entry's moment known? One with no `at` is a plan: first, under the pack's 'Upcoming', quiet, its way to a time its own act (`renderActs`) — never a head of its own after the days, nor a moment made up to file it. |
| `Timeline lines` | Is it a sentence? A supporting line takes a reference — a slot, a kind, a place, a price — one run of statements each, two lines at most, and who wrote a named entry and when open the first. Money goes here unless it is the ONE figure the reader compares down the list, which is `figure`, on the row's right edge. |
| `Timeline day` | Is the figure the LIST's total? Close the section with it. `day` is each day's own — its sum on the head's right edge, and the verb that adds to THAT day, handed the day it was pressed on — and exists only under `group="day"`. |
| `Timetable` | Do the slots fall on DATES? A dated week is `CalendarView view="week"`; a timetable has no dates at all. |
| `ToastProvider` | Is the strip meant to sit inside the page? It is fixed above every overlay by design — a toast reports the outcome of the act an `Alert` just confirmed. |
| `ToggleStrip` | Is the choice exclusive? An exclusive pick is `ChoiceStrip` — each cell here is a checkbox, and chips would wrap and destroy the column reading. |
| `Tooltip` | Is the hint what the control is FOR? A trigger whose whole purpose is the popup is an `InfoPopover`, which a touch reader can open. |
| `TooltipContent` | Is the hint needed to act? A tooltip never reaches a touch reader — anything required is visible text. |
| `TooltipProvider` | Is a `Tooltip` missing without it? Every kit tooltip portals and times itself — this only reaches a RAW Base UI tooltip in the same tree. |
| `TooltipTrigger` | Does the child drop the props it is handed? It is rendered AS the trigger rather than wrapped in one, so nothing is added to the layout to catch them. |
| `TotalsLine` | Does it describe the UNFILTERED set? A summary that keeps counting rows the filter removed contradicts the register beneath it — and a row whose subject is a CATEGORY rather than the view belongs to the chart. |
| `WaterfallChart` | Are the steps independent? A bridge claims each step MOVED the total — unrelated categories are a `BarChart`. |
| `Well` | Is the content a MESSAGE? A well of fields inside a `warning` `Callout` announces the whole form as one live alert — content and fields go here, a message goes there. |