# @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. |
| `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`; round is the shape the kit spends on a face. And there is no HUE: a mark you wanted in a particular colour is a `Status` or a `Chip`. |
| `Awaiting` | Is nobody owed anything by that date? A record's own deadline is a `MoneyBand` `countdown` cell or `deadlineAnnotation` on the field holding it — this one names a PARTY. And is the obligor the same on every row? Then it is not a ball in court: state it once above the set. |
| `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. |
| `Board` | Are the columns bands of rows? A board's columns are one field's VALUES and the act it exists for is sending a card to another one. |
| `BoardCard` | Does the card repeat the column it sits in? The face states the record; the MOVE menu states the destinations. |
| `BoardColumn` | Is the count formatted into the heading? `count` is a prop — folded into the name the number becomes part of the column's identity. |
| `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 axis — a vehicle, an owner, a channel? That is `GanttView`; a calendar's axis is time. |
| `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. |
| `CalloutText` | Does the text carry a verb? An act belongs in `CalloutActions`, where it is reachable, not buried in the prose. |
| `CalloutTitle` | Is the headline the whole message? A title with no body under it is a sentence wearing a heading's weight. |
| `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` or a `ListRows`. Is the job to MOVE a row between named places? That is `Board`. |
| `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 `Ledger`; 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. |
| `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. |
| `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. |
| `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. |
| `ColumnMap` | Is the reader picking ONE thing? That is `Select`. This exists for a set of names somebody else wrote that must each find a home. |
| `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. |
| `CommentThread` | Is the feed the agent's? A run's feed is `AgentRun` — comments are people talking to each other. |
| `CommentThread answer` | Is the mark a per-entry yes/no — read, flagged, 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. |
| `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"`. |
| `ConfidenceCallout` | Are the reasons missing? The basis is required — a level without what was checked is a number the reader cannot weigh. |
| `ContactCell` | Is the subject a person rather than a way to reach one? Who someone IS is a `MemberChip`; this is the number or address, with the control that hands it over. |
| `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. |
| `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. |
| `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. |
| `DateCell` | Is the date the system's own stamp? A recorded moment is a `DateStamp`, which says how long ago; this draws a field's value in the reader's own order. |
| `DateCell due` | Is the date a RECORD rather than a promise — issued on, received on? Passing `due` at all makes the column a deadline and judges every row against today; where the date IS a deadline, pass it on every row, `false` included, or the rows that left the flow lose the column's alignment. |
| `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 to report over? 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. |
| `DaySheet` | Are the rows the ENTRIES rather than the days? A book of dated movements is a `TransactionLedger` and a trip's stops are an `Itinerary`; this one runs over every day of the window, because the day nobody wrote up is what it is read for. |
| `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. |
| `EntryGrid` | Is the cross-tab computed rather than filled in? A pivot of counts is `Matrix` and a grid of states is `StateMatrix`. |
| `EntryMatrix` | Does the row stand for one record? Every register shape lists the entity's own rows; here the rows are SUBJECTS and the cell is the record. |
| `ExpectedSetCell` | Is the row's set the whole SECTION? A record's own desk is `RecordExpectedSet`, which names each missing item; this is the one-glance meter a register column has room for. |
| `FieldSurface` | Is the control a plain one? Without verbs the control paints its own box — this is for the field that carries something beside it, and a value that is not an editor is `InlineValue`. 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. |
| `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. |
| `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. |
| `FileRows` | Is the pile mostly images? A mixed set follows its majority and stays whole — splitting it by type gives the reader two places to look. |
| `FilesEditor` | Are the files one record ROW's, or a RECORD's own pile? A row's attachments are `InlineFiles`, on the inline grid; a record's are `RecordFiles`, read before they are managed. This one is the section that owns its 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 a document? A PDF's thumbnail is a grey page identical to every other one — its name is the identity. |
| `FileThumbnailGrid` | Are the files documents? Documents get a list, where the full name is the row. |
| `FilterBand` | Is a facet empty? A chip with nothing to offer renders `null` — 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. |
| `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. |
| `FormMarksContext` | Is the question whether THIS field may be empty? That is `FormField.optional` — this says which of the two answers gets a word, and the answer is whichever is the minority. |
| `Funnel` | Do the stages partition one set? A funnel's stages are SUBSETS of the one before — a split whole is a split `Progress`. |
| `GanttView` | Is time the only axis? Days on the axis is `CalendarView` — a Gantt's lanes are who or what does the work. |
| `GroupRegister` | Is the row a RECORD? A register whose rows are the entity's own is the shape that lists them, with the fold offered as a `group`; this one's rows ARE the fold, and pressing a row opens the SET behind the figure rather than a record. |
| `GuidedRun` | Are the rows a SET the reader works in any order? Anything ticked off as it is met is a `Checklist`; this one puts one step on screen, gates Next on what that step captures, and resumes where the reader stopped. |
| `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. |
| `IdentityCell` | Is the mark the whole cell? A run of marks is a `MarkStack`; this one is the NAME, its supporting line and at most one mark, clamped so the rows keep the rhythm a column is scanned down. |
| `IdentityCell lines` | Is the name the same length on every row — a code, a reference? One line is the register's rhythm; reach for two where the identifying words come at the END of the name, which is where a clamp cuts them. |
| `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. |
| `InlineValue` | Does the value edit? A disabled editor still draws a control; this draws none and lines up pixel-for-pixel. And is the row a TABLE's? A table sets its own rhythm, and a 40px control band inside one only makes the rows taller. |
| `Itinerary` | Does every stop answer the same facts? Facts every row carries are COLUMNS, and columns are `RecordChildren`. Is the run already OVER? A spine under things that happened is `Timeline`; this one is planned. |
| `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. |
| `Ledger` | Is anything typed into it? Priced lines are `ChargeLines`; a ledger closes a settled set and has nothing to edit. |
| `LedgerBasis` | Is the figure part of the sum? The basis states what the group is computed FROM; putting a charge here leaves it out of the total. |
| `LedgerGroup` | Is there one side? A group per row turns a two-sided statement into a list of headings. |
| `LedgerRow` | Does the line need editing? A settled line is read; an editable one belongs on the charge band. |
| `LedgerTotal` | Is it computed off a different array? A total that is not the sum of what is on screen cannot be checked. |
| `LevelCell` | Is there no limit? A level nobody can act on is a `NumberCell` — this cell exists for the threshold and for which SIDE of it needs attention. |
| `LifecycleDesk` | Does the record have no stages? A party or an offering is a register, not a desk — a strip of segments over people buries the ones the reader did not pick. |
| `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. |
| `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. |
| `ListRows` | Do the rows carry three or more figures the reader compares ACROSS them? That is the register's `Table`. Is the run ordered in TIME, with a day stated once above it? That is `Itinerary`. |
| `LiveBoard` | Is the reader asking about a PERIOD? How it went is a `TrendDeepDive`; this one has no period at all, and its order is the exceptions rail. |
| `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. |
| `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. |
| `MediaSet` | Is the picture beside the row rather than the row itself? A thing you SELL with a photograph is an `OfferingRegister`; this one is tiles. |
| `MemberChip` | Is the member one field among columns? Pass `showAvatar={false}` — a supporting column of repeated faces competes with the row's own subject. |
| `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. |
| `MetricStrip` | Is the band over a REGISTER's rows? Those are the shape's `above`, counts and sums the frame draws as its own inline band; this boxed grid heads a DASHBOARD. A strip of one is a `Metric` wearing a band's chrome. |
| `MoneyBand` | Is there ONE figure? That is the header's `metric`, and a band of one is the identity written twice. Is the SCREEN about them? A dashboard's figures are a `MetricStrip`. |
| `MoneyCell` | Is the amount TYPED here? A priced line is `ChargeLines` — this is a read figure, right-aligned and formatted by the reader's locale, never a hand-joined currency mark. |
| `MonitoredAssetSet` | Is there no limit beside the level? A level nobody can act on is a column in a register; this shape exists for the threshold and the shortfall it derives, and its strip is by responsibility, never by state. |
| `NumberCell` | Is the quantity read against a limit? That is a `LevelCell`, whose meter is the comparison — a bare number beside a threshold makes the reader do the subtraction. |
| `NumberInput` | Is the quantity continuous, and is the SHAPE of the range what the reader is choosing from? 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 notation a unit `Intl` cannot write? It is ONE statement of what the box prints and what it will read back, so a free-text unit belongs BESIDE the field — inside the value it commits 8.2 for "8,200 kg". |
| `ObligationDesk` | Is the row the RECORD? A job with one date is a lifecycle desk, ordered by that date; this one fans several dates out of each record so the desk can be ordered by what runs out first. |
| `OfferingRegister` | Is the row a counterparty? A customer or supplier is a `PartyRegister`, whose mark is a face and whose figure is worth, not price. |
| `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. |
| `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 a list and the record it opens land on one left edge. |
| `PageHeader` | Is the subject a RECORD? A record's band is `RecordSummary`; this names the screen. |
| `Pagination` | Is there a second pager below the rows? There is ONE per register, above them, on the summary row. |
| `PartyRegister` | Is the subject sold rather than dealt with? What you sell is an `OfferingRegister`, image-led and priced. |
| `Peek` | Does the row already press? Two destinations behind one object — inside a pressable row the reference stays inert. |
| `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 of them, 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 bar `LevelCell` draws; the ring is the reading that IS its whole cell beside other values. |
| `RawPayload` | Is the reader not a developer? A wire payload on a business surface says the screen ran out of language. |
| `ReconciliationDesk` | Is the row one book's line? A ledger draws ONE signed amount; this row is a PAIRING, it derives the difference rather than storing it. |
| `RecordChildren` | Are the rows the record's SIBLINGS? Those are the register it was opened from, printed twice. Its ADD is the section's heading-row act, never a prop here. |
| `RecordChildren rowActions` | Is the drawer the row's only door? A child line whose one destination is the record it opens can never be removed — the ⋯ in the trailing gutter is where a `danger` item lives, and it is the minimum act a row may have beyond opening it. |
| `RecordChildren group` | Can the reader already read the key down a COLUMN? Then it is a sort. A run earns its subhead where the key answers the question before any row does — the days of an itinerary — and the column for it then goes. |
| `RecordExpectedSet` | Is the list what was FILED? Absence is the information, and a run of what arrived names none of what is missing — a pile nothing is required of is `RecordFiles`. |
| `RecordExpectedSet kind` | Are the required things DOCUMENTS? `files` draws each one as a file row and each gap as a GHOST one; `items` is for things with no face — services sold, checks carried out — and stays a checklist. |
| `RecordExpectedSet onRemove` | Can a document filed against the wrong slot stay there? Without this there is no way back; with it the slot becomes the ⋯, the removal confirms, and un-filing the last item returns the row to its GHOST — the option belongs to the field and is never deleted with the item. |
| `RecordFacts` | Is the record a DRAFT the reader may abandon? A new record is a `FormField` fieldset, which commits once — these are an existing record's resident fields. |
| `RecordFacts onSave` | Is there an Edit mode to enter first? THE FRAME IS THE PERMISSION — a fact carrying `onSave` draws its field at rest and an empty one draws a placeholder, while a fact without it is read-only by construction. |
| `RecordFigure` | Does the surface also draw the record's NAME? Then the band is `RecordSummary`, which pins this figure beside the identity. Reach for this one where the name is already up in a panel's own bar. |
| `RecordFiles` | Is it ONE file, or does the section own a verb BAR? One file is a `FileRow` or a `FileThumbnail`, and a surface whose acts you compose is a `FilesEditor`; this is the record's whole pile, read. Is the pile a required set? `RecordExpectedSet`, where a gap is the information. |
| `RecordFiles onRemove` | Is the removal wanted on the TILES? It is offered in the named rows' ⋯ and in the viewer's toolbar, and it confirms in both — a one-press irreversible act on a 32px thumbnail is a bare glyph with no name beside it. |
| `RecordPage` | Is the subject the LIST? A register is one of the registry's shapes, and this is what its door opens onto — ONE reading column; the only thing beside the column is a rail that NAVIGATES. |
| `RecordPage danger` | Is the delete a `danger` `Button` handed in? It is `DangerAction`s — a fence that is genuinely not a row of confirmed buttons is a `DangerSection` written out in a section of its own. |
| `RecordProgress` | Is the stage PICKED here? A stage is derived and the act moves it; a select over the lifecycle lets a reader claim a state the work has not reached. The outcome a record did NOT leave by is never listed. |
| `RecordProgress confirm` | Is every stage move worth stopping for? Most are passed constantly, and a dialog on all of them is the cry-wolf failure — name only the transition that issues a document, sends the mail or posts the figure. |
| `RecordRelated` | Do the rows BELONG to the record? Then it acts on them and they stand open under a `SectionHeading` carrying the add verb — `RecordChildren`. This is the other direction: one short section of links, never a register standing open. |
| `RecordSummary` | Is the subject the screen, or what just happened? A screen's band is `PageHeader` and a save's outcome is `ResultHeader`; this one names the record and pins ONE figure, and its fields are a `RecordFacts` in a section of `RecordPage`'s column. |
| `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. |
| `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. |
| `ResourceSchedule` | Is the register the WORK rather than the resources it is put on? A queue of jobs walking stages is a `LifecycleDesk` and a chart of when each one runs is `GanttView` — neither can say what a van is still free for. |
| `ResultHeader` | Is the subject the record rather than what just happened to it? A record's band is `RecordSummary` — it names an identity at `#` and pins a figure, where this names an EVENT at `##` and pins the way out. |
| `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. |
| `RunningLedger` | Is the balance supplied by the caller? The component computes it — a passed-in running total is the one figure a reader cannot check. |
| `ScopeSwitcher` | Is there one scope? It renders nothing below `minItemsToRender` — a switcher over a single entity is clutter. |
| `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. |
| `SectionHeadingMeta` | Is the act in the meta slot? A section's ADD is a `Button` 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? `RecordPage` draws this itself, and a hand-written second outline can disagree with the page it outlines. This one is for a document or a settings surface that is long because its CONTENT is. |
| `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. |
| `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. |
| `ShapeFrame` | Is the screen one the registry names? Reach for that shape — it binds the slots by field role and owns the strip, the columns and the door; the bare frame is the NEXT shape's, and a new shape is a registry entry rather than a call site. |
| `ShapeFrame rowActions` | Is the row's verb a glyph in a column of its own? A trash mark repeated down a register is a destructive act with no name and no menu — the ⋯ is the visible sibling, and a row given no items leaves its gutter blank rather than taking the column away from the rest. |
| `ShapeFrame danger` | Is the bulk delete inside `selection.actions`? `selection.danger` is handed the PICKED ROWS, so the question counts exactly what the act runs over; the same delete among the other verbs confirms only if the app remembered to. |
| `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 unstated? The preview draws one network's rules — a generic preview promises a rendering nobody will see. |
| `SortHeader` | Does the set arrive sorted by the server? A control that reorders one page lies about the whole register. |
| `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, a control and its field? 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. |
| `StageCell` | Is the stage SET here? A stage is derived and an act moves it — and the colour is the option's, so a cell that picks its own says a state means something the model never said. |
| `StateMatrix` | Does a blank cell mean zero? Here it means nothing was DUE — a count belongs in `Matrix`. |
| `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 without `selectedState` coming back nothing narrows. |
| `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. |
| `Step` | Is the step a task? A task is a `ChecklistItem`, which carries a mark and a verdict. |
| `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. |
| `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. |
| `TextCell` | Does the value have a KIND? Money, a date, a stage and a contact each have their own cell — routing them through the plain one is what loses the alignment, the format and the copy control. |
| `TextCell grow` | Is the value in a REGISTER? A cell there clamps, and `lines` is the ceiling — the rhythm a column is scanned down is the register's; `grow` is the RECORD's spelling, where the surface exists to hold the whole value. |
| `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. |
| `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 run PROGRESS? Done, current and upcoming is `Stepper`; a timeline is heterogeneous and finished. |
| `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. |
| `TransactionLedger` | Is the money PRICED here rather than read? A charge you are still writing is `ChargeLines`; this is a book of settled lines, one signed amount each, and its strip is the books, never the periods. |
| `Trend` | Is the direction meaningless? Without `goodDirection` a fall in cost reads as a loss — state which way is good. |
| `TrendDeepDive` | Is the question about NOW rather than a period? A live board has no period control; this one's period governs every figure. |
| `VerdictCell` | Is the answer a STATE rather than a verdict? A stage a record is in is a `StageCell` in the option's own colour; this is the one flag or check the row is scanned for, and it never prints its own label — the column head is already that. |
| `VerifyField` | Is there nothing to match against? Without an expected value the match states are dead and the field is a text input. |
| `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. |
| `Worksheet` | Has the money already moved? A book of dated movements is a `TransactionLedger` and a record's own charges are `ChargeLines`; this one is still being priced. |