@ai-matrx/records-ui 0.84.8 → 0.85.6

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import * as react from 'react';
 import { ReactNode, ComponentType, RefObject } from 'react';
 import * as _ai_matrx_records from '@ai-matrx/records';
-import { PermissionLevel, Table, RecordScopeContext, EnrichCell, RecordsError, Uuid as Uuid$1, RecordFilter, AggregateFilter, Field, RecordDocument, ReadRow, RelationDisplay, WriteConflict, RecordsErrorCode, DeclarableFieldKind, ParityFieldType, NewFieldDeclaration, RuleExpression, ValueEnvelope, ChecklistRequirementKind, ContextPolicy, WorkDueState, FieldSensitivity, StageRuleOnFail, SubscriptionCadence, WorkInboxKind, FieldKind, RecordsResult, ArchiveLane, ArchivedRow, FormSummary, PortalCard, PortalPrincipal, PortalPreviewRow, MySubscription, DashboardBlockKind, AggregateBucket, AggregateMeasure, DashboardBlock, DashboardSummary, DocTemplateRow, DocRenderRow, QuietHours, DashboardBlockResult, ChecklistRunStep, BookingSummary, CaptureSheetFace, CaptureField, AnonTokenBinding, RecordsConfig, RecordsActor, RecordsDataSource, HistoryActor, FieldHistoryEntry, FieldTypeWord } from '@ai-matrx/records';
-import { Uuid, RecordFilter as RecordFilter$1, Field as Field$1, ReadRow as ReadRow$1 } from '@ai-matrx/records/react';
+import { PermissionLevel, Table, RecordScopeContext, EnrichCell, RecordsError, Uuid as Uuid$1, StoreFilter, AggregateFilter, Field, ReadRow, RecordDocument, RelationDisplay, WriteConflict, RecordsErrorCode, TableDecorations, DeclarableFieldKind, ParityFieldType, NewFieldDeclaration, RuleExpression, HiddenFieldNotice, ValueEnvelope, ChecklistRequirementKind, ContextPolicy, WorkDueState, FieldSensitivity, StageRuleOnFail, SubscriptionCadence, WorkApprovalState, WorkInboxKind, FieldKind, RecordFilter, RecordsResult, SavedViewRow, ArchiveLane, ArchivedRow, WorkInboxItem, FormSummary, PortalCard, PortalPrincipal, PortalPreviewRow, MySubscription, DashboardBlockKind, AggregateBucket, AggregateMeasure, AggregateCompare, DashboardTarget, DashboardBlock, DashboardSummary, DocTemplateRow, DocRenderRow, QuietHours, DashboardBlockResult, ChecklistRunStep, BookingSummary, CaptureSheetFace, CaptureField, AnonTokenBinding, RecordsConfig, RecordsActor, RecordsDataSource, HistoryActor, FieldHistoryEntry } from '@ai-matrx/records';
+import { Uuid, StoreFilter as StoreFilter$1, Field as Field$1, ReadRow as ReadRow$1 } from '@ai-matrx/records/react';
 import { RecordsClient } from '@ai-matrx/records/core';
+export { DEFAULT_FIELDS, DeclareResult, NewFieldSpec, NewTableSpec, addFields, declareTable, fieldDeclarationFor, tokenFor } from '@ai-matrx/records/core';
 import { FieldFormatConfig } from '@ai-matrx/design-system/field-formats';
 import { MatrxColumnDef } from '@ai-matrx/design-system/data-table/types';
 import { TableStyle, GroupAggregateSpec, GroupOrder, ChoiceColorLookup } from '@ai-matrx/design-system/data-table';
@@ -246,7 +247,13 @@ interface HostLayout {
     /** Draw it for this table, with the question the address asked when there is one. */
     render: (args: {
         tableId: Uuid$1;
-        filter?: RecordFilter | undefined;
+        filter?: StoreFilter | undefined;
+        /**
+         * Opens the page's own export (CSV, XLSX, copy and transform) — the one export a table has,
+         * so a host layout's "Export this table…" never needs a second one or a hunt for a button.
+         * Absent on a page that draws no export.
+         */
+        openExport?: (() => void) | undefined;
     }) => ReactNode;
 }
 interface RecordsUiHost {
@@ -359,6 +366,25 @@ interface RecordsUiHost {
         recordId: Uuid$1;
         title: string;
     }) => void;
+    /**
+     * OPTIONAL. A TABLE'S AGENT BUTTON, PRESSED (TABLE-PARITY M3, lane DEFAULT-GRID-PARITY).
+     *
+     * A row action of kind `agent` ("Ask Dr. Whitfield") hands the row to an agent with the
+     * action's own `prompt`. Only the host can start that conversation — this package ships no
+     * chat — so the grid hands the row, the action's name and its prompt here, and the host
+     * opens its one chat surface bound to the record with that prompt as the opening ask. It is
+     * a separate port from `talkToRecord` because that one carries no prompt: a host that bound
+     * only `talkToRecord` would open an empty chat and silently drop what the button was for.
+     *
+     * ABSENT, NEVER DEAD: unbound, agent buttons are not drawn.
+     */
+    runAgentAction?: (target: {
+        tableId: Uuid$1;
+        recordId: Uuid$1;
+        title: string;
+        action: string;
+        prompt: string;
+    }) => void;
     /**
      * OPTIONAL. THE SERVER'S `records` TOOL (SCR-27).
      *
@@ -731,6 +757,15 @@ declare function rowNameIn(table: TitledTable, row: ReadRow | undefined, fallbac
  * 2026-09-20).
  */
 declare const WITHHELD_RECORD_LABEL = "A record you have not been given access to";
+/**
+ * THE FIELD A CARD IS TITLED BY — kanban, calendar, gallery and pipeline alike.
+ *
+ * Order: the Table's `title_field` → a conventional name key (`title`, `name`, …) → the first
+ * text column in declared `sort` order → the first other column that can title (never a
+ * checkbox, never the group column, never a system stamp). `undefined` when nothing can, and
+ * the card falls back to `rowName`, which says "Untitled" rather than "false".
+ */
+declare function cardTitleField(fields: readonly Field[], titleKey: string | null | undefined, exclude?: readonly (string | null | undefined)[]): Field | undefined;
 
 /** What a person has chosen: the table, and optionally which of its columns to show. */
 interface ReferenceChoice {
@@ -1031,6 +1066,18 @@ type GridGrouping = {
     order?: GroupOrder;
     /** The sections this view keeps shut, by the primitive's own group key. */
     collapsed?: string[];
+    /**
+     * SUB-GROUPS (lane S1-PRIME VIEW-KEYS; ui-bench LISTS "sub-grouping"): up to two more levels
+     * inside each section, by Field key. At most three levels in all — the store refuses a fourth
+     * (`custom.view_declare`). A layout that draws one level ignores the rest; it never drops them,
+     * because this list is parsed and written back whole with the rest of the look.
+     */
+    then?: GridSubGroup[];
+};
+/** One sub-group level: a Field key and its section order. */
+type GridSubGroup = {
+    field: string;
+    order?: GroupOrder;
 };
 /** Everything a view says about how its table LOOKS. */
 type GridPresentation = {
@@ -1055,6 +1102,33 @@ type GridPresentation = {
     widths?: Record<string, number>;
     /** The body row height this view remembers, in px. */
     rowHeight?: number;
+    /**
+     * Field keys hidden from this view — the SAME hidden-column list the grid's
+     * own column picker holds, now given a place on the view so it survives a
+     * reload and a layout switch reads the identical set gallery and grid agree
+     * on, rather than a second "fields shown" list nobody kept in sync.
+     */
+    hiddenFields?: string[];
+    /**
+     * The gallery's card size, remembered the same way the grid remembers its
+     * row height — a per-view look, not a global default.
+     */
+    gallerySize?: "small" | "medium" | "large";
+    /**
+     * THIS VIEW'S OWN LAYOUT CHOICES, over the organization's `custom/grid_layout` knob (lane
+     * DEFAULT-GRID-PARITY, TABLE-PARITY D1 D5 D6). Absent means "whatever the organization
+     * says"; present is the view's word. `freezeFirst: false` is an explicit NO over an
+     * organization that freezes the first column — an empty `frozen` cannot say that.
+     */
+    wrap?: boolean;
+    fit?: "auto" | "fit" | "scroll";
+    freezeFirst?: boolean;
+    /**
+     * THE SUMMARY BAR (TABLE-PARITY F1): Field key → the store measure shown under that column
+     * (`count`, `sum`, `avg`, `min`, `max`, `median`, `filled`, `empty`, `unique`), worked out
+     * by `custom.record_aggregate` over the whole table.
+     */
+    summaries?: Record<string, string>;
 };
 declare const EMPTY_PRESENTATION: GridPresentation;
 /** A frozen column needs a known width, or the table declines to freeze at all. */
@@ -1103,6 +1177,42 @@ declare function currencyCodeFor(unit: string | null | undefined): string;
  * that changes and every screen follows.
  */
 declare const colorFromTheValue: ChoiceColorLookup;
+/**
+ * G1's TABLE-LEVEL COLORS (`custom.table_decorations` / `client.tableDecorations`),
+ * TRANSLATED INTO A `TableStyle` — the same document a saved view's own `presentation.style`
+ * is, so one resolver (`resolveTableStyle`, below) can treat "the table's colors" and "this
+ * view's colors" as two layers of the SAME thing instead of two unrelated systems.
+ *
+ * THE TRANSLATION IS NECESSARY AND IT IS THE ONLY ONE. G1 addresses a Field by its ID
+ * (REC-17 — a column renamed keeps its color), because it is the STORE's own door; a
+ * `TableStyle` addresses a Field by its KEY, because it reads straight off `row.document`,
+ * which is keyed by Field key. A rule or a color-by whose Field has been deleted (its id no
+ * longer resolves to a key) is dropped rather than crashing the whole style — a defect in
+ * one rule costs that rule, never the read.
+ */
+declare function styleFromDecorations(decorations: TableDecorations | null | undefined, fields: readonly Field[]): TableStyle;
+/**
+ * THE ONE PRESENTATION RESOLVER every colored surface in this package reads —
+ * `Grid`, and (via `Card`) the kanban board, the calendar and the gallery.
+ *
+ * THE CLASS THIS CLOSES (lane UI-QUICK-1, TABLE-PARITY review, 2026-09-24). Threading
+ * `view.presentation.style` into `Card` closed the instance the CALENDAR-GALLERY bench
+ * found — a VIEW that had its own color-by looked right everywhere — but it left the
+ * class open: a table whose colors are the ORGANIZATION's decorations (G1's
+ * `custom.table_decorations` — "color rows by Account Type", "MAXED and NEAR rules" on
+ * Arman's own Coding Accounts table) and whose views never set a `presentation.style` of
+ * their own drew NOTHING, on the grid exactly as much as on every other layout, because
+ * nothing in this package had ever read G1's door at all.
+ *
+ * TWO LAYERS, ONE DOCUMENT. The table's decorations are the base coat — what every view
+ * of this table shows until a view says otherwise. A view's OWN `presentation.style` is
+ * an override, piece by piece: a view that only ever set manual row highlights still
+ * inherits the table's color-by and rules for everything it never touched, and a view
+ * that fully redecorated (its own `colorBy` AND its own `rules`) is not haunted by a
+ * table rule it meant to replace. Per-piece, never all-or-nothing, because a view is a
+ * LOOK on top of the table, not a wholesale substitute for it.
+ */
+declare function resolveTableStyle(decorations: TableDecorations | null | undefined, fields: readonly Field[], viewStyle: TableStyle | undefined): TableStyle;
 
 /**
  * WHAT A TABLE WITH NO COLUMNS SAYS. Named here because the gate asserts on it:
@@ -1122,8 +1232,11 @@ interface GridProps {
      * own query. Never filter `rows` here: this grid only ever holds one page,
      * so filtering in the browser would drop every matching record on page two
      * and call the result the answer.
+     *
+     * S2-PRIME: either shape — the flat map, or a view's own nested question (the Rule shape);
+     * the store compiles both into the one WHERE clause.
      */
-    filter?: RecordFilter$1 | undefined;
+    filter?: StoreFilter$1 | undefined;
     /** Opened when a row is clicked. A host that has a record page passes its own. */
     onOpenRecord?: ((recordId: Uuid) => void) | undefined;
     /** SCR-2. Called when an admin clicks the "+" at the end of the headers. */
@@ -1200,6 +1313,36 @@ enrich?: {
     onPin?: ((recordId: Uuid, fieldKey: string, pinned: boolean) => void | Promise<void>) | undefined;
 }): MatrxColumnDef<ReadRow$1>;
 
+/** Answers "what is the record with this id called", for one Field's values. */
+type LabelLookup = (field: Field$1, id: string) => string | null;
+/**
+ * HOW LONG A CELL MAY SAY "Loading…" BEFORE IT HAS TO SAY WHAT IT IS WAITING
+ * FOR. One second is the span at which a person stops reading a word as "this
+ * is about to happen" and starts reading it as "this is stuck" — the same line
+ * Nielsen's response-time work draws and the one Linear and Stripe design to.
+ */
+declare const SAY_WHAT_YOU_ARE_WAITING_FOR_AFTER_MS = 1000;
+/** Which ids a Field's stored value refers to. */
+declare function idsOf(value: unknown): string[];
+declare function isId(value: unknown): boolean;
+/** True when this Field's values are ids of other records rather than values. */
+declare function pointsAtRecords(field: Field$1): boolean;
+declare function RecordLabelProvider({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+/**
+ * The hook a surface uses: it declares the Fields it is about to draw, and gets
+ * back the lookup. Declaring is what makes one request per Field instead of one
+ * per cell, and it is why a grid of 200 rows asks the store twice.
+ */
+declare function useRecordLabels(fields: readonly Field$1[] | undefined): LabelLookup;
+/**
+ * WHAT THIS COLUMN IS STILL WAITING FOR, or null while "Loading…" is still an
+ * honest word. A cell draws this INSTEAD of "Loading…" once the resolver has
+ * been looking for a second — see `SAY_WHAT_YOU_ARE_WAITING_FOR_AFTER_MS`.
+ */
+declare function useLabelWait(field: Field$1 | undefined): string | null;
+
 interface ExportMenuProps {
     tableId: Uuid;
     /** The rows on screen. Absent means "this table's first page", read the same way. */
@@ -1314,7 +1457,18 @@ type RelationFieldType = "relation";
  * `FIELD_TYPE_CHOICES`'s coverage and as a red `kindsWithNoChoice()` below — never as a
  * silence.
  */
-type PickableFieldType = DeclarableFieldKind;
+type PickableFieldType = DeclarableFieldKind | SystemFieldKind | "entity_reference";
+/**
+ * THE STORE'S OWN STAMPS AS COLUMNS (GRID-PRIMITIVES G5; TABLE-PARITY H2 H3, lane
+ * DEFAULT-GRID-PARITY). `custom.field_declare` takes these three WORDS and makes each a formula
+ * Field whose expression is the system node (`fx.autonumber`, `fx.created_time`,
+ * `fx.modified_time`, `config.system` naming which), so nobody types into them and every reader
+ * that serves a worked-out value serves them. `custom.field_kinds()` does not publish them,
+ * because each is a formula, not a behaviour of its own. So they are named here, sent as their
+ * word through the `{ type }` arm, and a new autonumber column numbers the records already in
+ * the table through `custom.autonumber_backfill`.
+ */
+type SystemFieldKind = "autonumber" | "created_time" | "modified_time";
 interface FieldTypeChoice {
     id: PickableFieldType;
     /** The word on the menu. */
@@ -1412,6 +1566,8 @@ declare function whatIsMissing(state: {
     formulaFields: string[];
     /** Only a link asks for one, so a caller about any other kind leaves it out. */
     relationTarget?: string;
+    /** Only an entity-reference column asks for these (SC-R). */
+    allowedTypes?: readonly string[];
 }): string | null;
 
 declare const NO_RULES_YET = "Nothing has to be true to get here yet.";
@@ -1499,29 +1655,37 @@ declare function ConditionRow({ lead, expr, fields, onChange, emptyLabel, classN
  * CAN THE BUILDER DRAW THIS CONDITION? — the question every caller asks before it renders,
  * and the reason a rule somebody cannot see is never silently saved over.
  *
- * Drawable means: nothing; one clause; or an ALL/ANY of clauses, where a member may itself
- * be one ALL/ANY of clauses and no deeper. `conditionIsSimple` is still the leaf test and
- * still exported — `ConditionRow` alone is a legitimate mount (the form builder's one row).
+ * Drawable means: nothing; one clause; or a group of drawable members, to any depth. `depth`
+ * still limits it for a caller that wants a shallower builder (0 = one level of clauses and no
+ * nested group). `conditionIsSimple` is still the leaf test and still exported.
  */
 declare function conditionIsDrawable(expr: RuleExpression | Record<string, unknown> | null | undefined, depth?: number): boolean;
 interface ConditionGroupProps {
-    /** The words before the condition: "When", "Ask only when". */
+    /** The words before the condition: "When", "Ask only when", "Show jobs where". */
     lead: string;
     expr: RuleExpression | Record<string, unknown> | null | undefined;
     fields: ConditionField[];
     onChange: (next: RuleExpression | null) => void;
     /** What the empty option says: "always", "every card". */
     emptyLabel?: string;
-    /** false inside a nested group — one level of nesting, and the screen says so by omission. */
+    /**
+     * false draws one level of clauses and no "Add a group". Left out, groups nest as deep as a
+     * person builds them — the depth the store compiles.
+     */
     allowNesting?: boolean;
+    /** How deep this group sits (0 = the whole condition). Set by the builder itself. */
+    depth?: number;
+    /** A nested group can take itself away; the outermost one cannot. */
+    onRemove?: (() => void) | undefined;
     className?: string | undefined;
 }
 /**
  * THE ONE CONDITION BUILDER. One clause reads exactly as it always has — a single row, no
- * joiner, no chrome — and the joiner appears only once there is something to join, so a
- * person writing one condition never meets a control for a problem they do not have.
+ * joiner, no chrome — and the joiner appears once there is something to join, so a person
+ * writing one condition never meets a control for a problem they do not have. A nested group
+ * always shows its joiner: it is a box with its own and / or, and that is the whole point of it.
  */
-declare function ConditionGroup({ lead, expr, fields, onChange, emptyLabel, allowNesting, className, }: ConditionGroupProps): react.JSX.Element;
+declare function ConditionGroup({ lead, expr, fields, onChange, emptyLabel, allowNesting, depth, onRemove, className, }: ConditionGroupProps): react.JSX.Element;
 
 interface FieldProposalRow {
     id: string;
@@ -1594,6 +1758,40 @@ interface RelationPickerProps {
 }
 declare function RelationPicker({ field, value, onChange, disabled, id, className, allowCreate }: RelationPickerProps): react.JSX.Element;
 
+/** What the panel says while the chosen list is empty. */
+declare const ENTITY_REFERENCE_KINDS_MISSING = "Choose at least one kind of thing this column points at.";
+/**
+ * The declaration an entity-reference column is sent as — the words `custom.field_declare`
+ * reads (`type: "entity_reference"`, `allowed_types`, `multi`). One place builds it, so the field
+ * editor, a table template and an agent never disagree on the shape.
+ */
+declare function entityReferenceSpec(input: {
+    label: string;
+    allowedTypes: readonly string[];
+    multi?: boolean;
+    required?: boolean;
+}): {
+    label: string;
+    type: "entity_reference";
+    allowed_types: string[];
+    multi: boolean;
+    required: boolean;
+};
+/** The sentence the panel shows before it lets a person save, or `null` when nothing is missing. */
+declare function whatIsMissingForEntityReference(allowedTypes: readonly string[]): string | null;
+interface EntityReferenceKindPickerProps {
+    /** The chosen entity tokens (`config.allowed_types`). */
+    value: readonly string[];
+    onChange: (next: string[]) => void;
+    /**
+     * An existing column: the store keeps its kinds and this panel sends no change to them,
+     * so the list is shown read-only rather than as a control that silently does nothing.
+     */
+    locked?: boolean;
+    className?: string;
+}
+declare function EntityReferenceKindPicker({ value, onChange, locked, className }: EntityReferenceKindPickerProps): react.JSX.Element;
+
 interface FieldEditorControlProps {
     field: Field;
     value: unknown;
@@ -1615,36 +1813,6 @@ declare function RecordChip({ title, onRemove, className, }: {
     className?: string | undefined;
 }): react.JSX.Element;
 
-/** Answers "what is the record with this id called", for one Field's values. */
-type LabelLookup = (field: Field$1, id: string) => string | null;
-/**
- * HOW LONG A CELL MAY SAY "Loading…" BEFORE IT HAS TO SAY WHAT IT IS WAITING
- * FOR. One second is the span at which a person stops reading a word as "this
- * is about to happen" and starts reading it as "this is stuck" — the same line
- * Nielsen's response-time work draws and the one Linear and Stripe design to.
- */
-declare const SAY_WHAT_YOU_ARE_WAITING_FOR_AFTER_MS = 1000;
-/** Which ids a Field's stored value refers to. */
-declare function idsOf(value: unknown): string[];
-declare function isId(value: unknown): boolean;
-/** True when this Field's values are ids of other records rather than values. */
-declare function pointsAtRecords(field: Field$1): boolean;
-declare function RecordLabelProvider({ children }: {
-    children: ReactNode;
-}): react.JSX.Element;
-/**
- * The hook a surface uses: it declares the Fields it is about to draw, and gets
- * back the lookup. Declaring is what makes one request per Field instead of one
- * per cell, and it is why a grid of 200 rows asks the store twice.
- */
-declare function useRecordLabels(fields: readonly Field$1[] | undefined): LabelLookup;
-/**
- * WHAT THIS COLUMN IS STILL WAITING FOR, or null while "Loading…" is still an
- * honest word. A cell draws this INSTEAD of "Loading…" once the resolver has
- * been looking for a second — see `SAY_WHAT_YOU_ARE_WAITING_FOR_AFTER_MS`.
- */
-declare function useLabelWait(field: Field$1 | undefined): string | null;
-
 /** The envelope for one key, when the document carries one. */
 declare function envelopeFor(document: RecordDocument | undefined, key: string): ValueEnvelope | undefined;
 declare function renderValue(field: Field, value: unknown, document?: RecordDocument, labels?: LabelLookup, stillWaitingFor?: string | null): react.JSX.Element;
@@ -1682,7 +1850,7 @@ declare function ProvenanceBadge({ document, fieldKey }: {
  * export, a chat line) keeps calling `renderValue` with no resolver and says
  * "Loading…" rather than printing an id.
  */
-declare function RecordValue({ field, value, document, format, }: {
+declare function RecordValue({ field, value, document, format, withheld, }: {
     field: Field;
     value: unknown;
     document?: RecordDocument | undefined;
@@ -1699,12 +1867,35 @@ declare function RecordValue({ field, value, document, format, }: {
      * blank.
      */
     format?: FieldFormatConfig | undefined;
+    /**
+     * THE STORE'S REASON, when it withheld this value from the reader (`ReadRow.hidden[key]`).
+     * A withheld value reads "Withheld" with the store's sentence on hover — never "—", which
+     * means the cell is empty (`withheld.tsx`).
+     */
+    withheld?: HiddenFieldNotice | null | undefined;
 }): react.JSX.Element;
+/**
+ * WHAT ONE CARD SAYS — the kanban's, the calendar's, the gallery's and the pipeline's alike, so
+ * no card can read a record differently from another. `field` is the card's title column
+ * (`cardTitleField`); a value the store withheld reads "Withheld" and carries the store's reason
+ * for the card's hover (`withheld.tsx`), never a bare "—".
+ */
+declare function cardWords(record: {
+    document?: RecordDocument | null;
+    hidden?: Record<string, HiddenFieldNotice> | null;
+} & Parameters<typeof rowName>[0], field: Field | undefined, labels?: LabelLookup): {
+    text: string;
+    withheld: string | null;
+};
 
 declare const WORK_DUE_STATES: readonly ["overdue", "due_today", "scheduled", "undated", "finished"];
 declare const DUE_STATE_LABEL: Record<WorkDueState, string>;
 declare const WORK_INBOX_KINDS: readonly ["assignment", "approval", "proposal"];
 declare const WORK_INBOX_KIND_LABEL: Record<WorkInboxKind, string>;
+/** The heading an inbox grouped by kind reads (lane S5-PRIME) — plural, the way Linear groups. */
+declare const WORK_INBOX_KIND_GROUP_LABEL: Record<WorkInboxKind, string>;
+declare const WORK_APPROVAL_STATES: readonly ["pending", "approved", "declined", "withdrawn"];
+declare const WORK_APPROVAL_STATE_LABEL: Record<WorkApprovalState, string>;
 declare const CHECKLIST_REQUIREMENT_KINDS: readonly ["none", "note", "answer", "record_field", "form", "document"];
 declare const CHECKLIST_REQUIREMENT_LABEL: Record<ChecklistRequirementKind, string>;
 declare const FIELD_SENSITIVITY_LABEL: Record<FieldSensitivity, string>;
@@ -1870,6 +2061,14 @@ interface SavedViewSpec {
      * reading is a fact about the records.
      */
     measure?: string | null;
+    /**
+     * Kanban: the Field whose values cut the board into SWIMLANES across the columns — a
+     * dispatcher's board by Status, one lane per Technician (S1-PRIME VIEW-KEYS). Never the
+     * column Field itself; the store refuses that.
+     */
+    swimlaneField?: string | null;
+    /** Kanban: the columns this view keeps shut to a strip, by the column's stored value. */
+    collapsedColumns?: string[];
     /** Calendar: the Field that places a record in the month. */
     dateField?: string | null;
     /** Gallery: the Field shown large on the card. */
@@ -1880,6 +2079,22 @@ interface SavedViewSpec {
      * reference to its Rule record, never a predicate this package evaluates.
      */
     ruleId?: Uuid$1 | null;
+    /**
+     * THE FLAT FILTER a digest or a notify rule wrote the view with — the one shape
+     * `custom.record_filter_sql` compiles, by Field KEY. A view saved in the bar has
+     * none; a view saved by `DigestScheduler` ("where Status is Open") does, and the
+     * grid and the board show exactly the records it names.
+     */
+    filters?: RecordFilter;
+    /**
+     * S2-PRIME — THE VIEW'S OWN QUESTION, as the condition builder writes it: the store's Rule
+     * shape `{op, args}`, ALL / ANY / NOT groups nested to any depth, Fields by id. Kept in the
+     * definition as `where` and asked of the store unchanged — the grid's list door, the board's
+     * headings and the dashboard's numbers compile it into the one WHERE clause
+     * (`custom.record_filter_sql`). Never stored under `filters`: that key is the flat map the
+     * digests and the notifier read, and they would refuse it by name.
+     */
+    where?: RuleExpression | null;
     isDefault?: boolean;
     /**
      * HOW THIS VIEW LOOKS — its colors, its per-column formats and its frozen
@@ -1892,19 +2107,67 @@ interface SavedViewSpec {
      */
     presentation?: GridPresentation;
 }
-/** A saved view as it comes back out of the store, with its record's own id. */
+/**
+ * A saved view as it comes back out of the store, with its row's own id.
+ *
+ * It carries no version: `custom.view_declare` MERGES one key at a time, so two
+ * tabs pressing two different controls on one view both stand, and one control
+ * pressed in both keeps the latest — how Airtable and Notion keep a view change.
+ */
 interface SavedView extends SavedViewSpec {
     id: Uuid$1;
+    /** Where the view came from when it was moved in (the mover, the S0 repair), else null. */
+    movedFrom: Record<string, unknown> | null;
     /**
-     * The record's version AT LOAD, read from `custom.io_revisions` for the one
-     * record being edited. The read door answers documents and not versions, so
-     * this is null until it has been read — and a save with a null version is an
-     * ordinary last-writer-wins write, exactly as the store defines it.
+     * THE WAY THIS TABLE IS MEANT TO BE LOOKED AT, when somebody decided one — a layout id the
+     * host draws (`sheet`), read off the stored kind before `layout` folds it to the four the
+     * package draws. Null when nobody designated one. See `designatedLayoutOf`.
      */
-    version: number | null;
+    designatedLayout?: string | null;
 }
-/** The package-owned Table every saved view is a record of. */
-declare const VIEW_TABLE: SystemTableSpec;
+/**
+ * WHICH LAYOUT A VIEW WAS DESIGNATED, OR NULL (lane DATA-V2-FACE, owner 2026-09-24).
+ *
+ * "For something like my data tables, which are predetermined with a default view of 'Sheet'
+ * I want to see … it just shows them the way it should in the default view. That's how you take
+ * custom systems and fake like they're hard-coded builtin systems."
+ *
+ * A designation is a DELIBERATE write, never a click: a view whose stored kind is a layout the
+ * HOST draws (`sheet` — a layout the store's view-keys registry declares, and one the layout
+ * buttons never write onto a view). That is the ONE way a table is designated (lane
+ * VIEW-KEYS-SHEET): the mover and the repair write `layout: "sheet"` on a copied older table's
+ * default view; `moved_from` says only where a view came from and designates nothing. A package
+ * kind (`grid`, `kanban`, …) is not a designation: picking Kanban writes `layout: "kanban"` onto
+ * the view, and a click must never take the layout chooser away.
+ */
+declare function designatedLayoutOf(definition: Record<string, unknown> | null | undefined): string | null;
+/**
+ * HOW THE TABLE OPENS, decided once from its default view and the layouts the host draws.
+ *
+ *   · `designated` — the default view names a host layout this host registered: the page opens
+ *     IN it and offers no other layout by default (the others sit in the page's one menu);
+ *   · `chooser`    — nothing designated (or the host does not draw what was designated): the
+ *     page opens on the view's own layout and shows the layout chooser.
+ *
+ * Only the DEFAULT view designates: a person who opens another saved view is choosing, and the
+ * chooser is theirs.
+ */
+type TableOpening = {
+    kind: "designated";
+    hostLayout: string;
+} | {
+    kind: "chooser";
+};
+declare function tableOpening(view: Pick<SavedView, "isDefault" | "designatedLayout"> | null | undefined, hostLayoutIds: readonly string[]): TableOpening;
+/**
+ * THE TABLE'S DEFAULT VIEW WHEN MORE THAN ONE SAYS IT IS (lane DATA-V2-FACE-2).
+ *
+ * Two views can both claim the default: the mover's designated one (the older table's own, the
+ * Sheet) and a page seed that a later move of the view bar's older store brings in beside it —
+ * both named "All records", so the store's name order cannot tell them apart. A designation is a
+ * deliberate write and a seed is not, so the designated default wins; then the first default.
+ */
+declare function defaultViewOf<V extends Pick<SavedView, "isDefault" | "designatedLayout">>(views: readonly V[]): V | undefined;
 /**
  * WHICH FIELD EACH LAYOUT CAN BE DRAWN FROM, decided from the FIELD'S OWN
  * DECLARATION and never from the values it happens to hold.
@@ -1968,33 +2231,106 @@ declare function pageViewFromParam(raw: string | null | undefined): PageView | n
 declare function unknownViewLine(raw: string): string;
 /** The one sentence a layout says when the table holds no Field it could use. */
 declare const LAYOUT_NO_FIELD: Record<ViewLayout, string>;
-/** The spec as the one document the store holds. */
+/**
+ * THE SPEC AS THE ONE DEFINITION `platform.saved_view` HOLDS — the keys
+ * `custom.view_declare` documents, by Field KEY. `subject` is not in it: the door
+ * takes the Table as its own argument and writes `table_id` itself.
+ */
 declare function viewDocument(spec: SavedViewSpec): Record<string, unknown>;
-/** One stored record back into the spec a screen and an agent both read. */
-declare function viewFromRecord(row: ReadRow): SavedView;
 /**
- * WRITE A CHANGE ONTO A SAVED VIEW, AND KEEP IT (lane RECORDS-UI-FIX, VERIFIER-15 M4).
+ * One row of `custom.views` back into the spec a screen and an agent both read — THROUGH THE ONE
+ * ACCESSOR (`viewSettings`, viewKeys.ts), so every layout sees every declared key the same way.
+ */
+declare function viewFromRow(row: SavedViewRow): SavedView;
+/**
+ * SAVE ONE NEW VIEW of a Table — the bar's "New view" and an agent's seed spec.
+ * One `view_declare` with no `view_id`; the answer is the new view's id.
+ */
+declare function declareView(client: Pick<RecordsClient, "viewDeclare">, spec: SavedViewSpec): Promise<RecordsResult<Uuid$1>>;
+/**
+ * WRITE A CHANGE ONTO A SAVED VIEW, AND KEEP IT.
  *
- * The version a screen holds for a view is read from the view's history, and the
- * history can be SHORT of the record — measured on the dev clone 2026-09-23: 68 live
- * records whose version is ahead of their newest history row, among them the
- * Birchwood quote board's view (record at 4, history stopping at 3). Every layout
- * press carried 3 and was refused `stale_write`, forever, and nothing said so.
+ * `custom.view_declare` with the view's id MERGES: only the keys in `patch` are
+ * written, a key cleared to null is removed, and everything the patch did not
+ * name — the grid's own choices, a hand-set order, where the view was moved from,
+ * a colour set in another tab — stays exactly as it was (S0, 2026-09-23: the door
+ * used to rebuild the whole definition from what one press sent).
  *
- * So a conflict is answered with the version the refusal itself names as the winner,
- * and the change is sent once more on it. A saved view is a person's own arrangement
- * of a table: their latest press is the one that should stand, the way Airtable and
- * Notion keep the last view change. Anything still refused is handed back, for the
- * page to say through the one notice.
+ * There is no version to be stale against (VERIFIER-15 M4 is closed by the shape,
+ * not by a retry): a saved view is a person's own arrangement of a table, and
+ * their latest press on a control is the one that stands. A refusal — the view
+ * was removed, or belongs to a table this person cannot open — is handed back for
+ * the page to say through the one notice.
  */
-declare function saveViewPatch(client: Pick<RecordsClient, "recordUpdate">, viewId: Uuid$1, document: Record<string, unknown>, expectedVersion: number | null): Promise<RecordsResult<number>>;
+declare function saveViewPatch(client: Pick<RecordsClient, "viewDeclare">, tableId: Uuid$1, viewId: Uuid$1, patch: Partial<SavedViewSpec>): Promise<RecordsResult<Uuid$1>>;
 /**
- * A PARTIAL change to a saved view, as the patch the store takes. Only the keys
- * the caller actually changed are written — a full document would re-write a
- * name or a rule the person edited in another tab.
+ * A PARTIAL change to a saved view, as the definition keys the door merges. Only
+ * the keys the caller actually changed are sent; a Field cleared (a board with no
+ * "Group by") is sent as `null`, which the door removes.
  */
 declare function viewPatchDocument(patch: Partial<SavedViewSpec>): Record<string, unknown>;
 
+/** Every surface a saved view is drawn by. `sheet` is the spreadsheet surface (G-lanes). */
+type ViewKeyLayout = "grid" | "kanban" | "calendar" | "gallery" | "sheet";
+/** Who may write a key: anyone who may save the view, an input the door rewrites, or the server only. */
+type ViewKeyWriter = "caller" | "input" | "server";
+interface ViewKeyDeclaration {
+    /** Where it lives in `platform.saved_view.definition` (dotted under `presentation`). */
+    path: string;
+    /** What the store's guard checks (`custom._view_key_value`). */
+    shape: string;
+    /** The layouts that read it. */
+    layouts: readonly ViewKeyLayout[];
+    writer: ViewKeyWriter;
+}
+/**
+ * THE REGISTRY, as `custom.view_keys()` declares it (uichamp_s1_a_view_keeps_every_setting_it_is_given.sql).
+ * Order and content are compared with the store by the live walk.
+ */
+declare const VIEW_KEYS: readonly ViewKeyDeclaration[];
+/** The keys one layout reads, by path. */
+declare function viewKeysFor(layout: ViewKeyLayout): string[];
+/** One sort clause: a Field key and a direction. */
+interface ViewSortKey {
+    field: string;
+    direction: "asc" | "desc";
+}
+/**
+ * EVERY DECLARED KEY OF A VIEW, TYPED. Absent keys are `null` / empty, never guessed.
+ * `presentation` is the parsed look (colour field, pinned fields, row height, grouping with its
+ * sub-groups and shut sections, hidden fields, gallery size, summaries).
+ */
+interface ViewSettings {
+    layout: "grid" | "kanban" | "calendar" | "gallery";
+    filters: RecordFilter | null;
+    where: RuleExpression | null;
+    groupField: string | null;
+    swimlaneField: string | null;
+    collapsedColumns: string[];
+    measure: string | null;
+    dateField: string | null;
+    imageField: string | null;
+    sorts: ViewSortKey[];
+    ruleId: string | null;
+    isDefault: boolean;
+    presentation: GridPresentation;
+    movedFrom: Record<string, unknown> | null;
+}
+/** THE READER. A stored `definition` (and the row's flat `filters`) in, every declared key out. */
+declare function viewSettings(definition: Record<string, unknown> | null | undefined, rowFilters?: RecordFilter | null): ViewSettings;
+/** The settings as the spec names them — what `viewSettingsPatch` takes. */
+type ViewSettingsPatch = Partial<Omit<ViewSettings, "movedFrom">>;
+/**
+ * THE KEYS ONE LAYOUT READS, and nothing else. A layout that does not use a key never sees it:
+ * a calendar is not told the board's swimlanes, a board is not told the grid's pinned fields.
+ */
+declare function viewSettingsFor(settings: ViewSettings, layout: ViewKeyLayout): Partial<ViewSettings>;
+/**
+ * THE WRITER'S SHAPE. Only the keys a press changed; a cleared Field is `null` (the door removes
+ * it); lists are sent whole. `presentation` is sent whole because the door judges it as one key.
+ */
+declare function viewSettingsPatch(patch: ViewSettingsPatch): Record<string, unknown>;
+
 interface ViewSwitcherProps {
     /**
      * THE DECLARATIVE SPEC — an agent writes the whole thing, a person tweaks it.
@@ -2024,13 +2360,23 @@ interface ViewSwitcherProps {
     /** "Who changed this?" from a grid cell — the host opens that column's timeline. */
     onAskWhoChanged?: ((fieldKey: string, recordId: Uuid) => void) | undefined;
     pageSize?: number | undefined;
+    /**
+     * THE TABLE'S OWN TITLE COLUMN (`title_field`, REC-2), from the table the host already holds.
+     * Every card is named by it (`cardTitleField`); the switcher never reads the table a second
+     * time to find it. Left out, a card is titled by a conventional name column, then the first
+     * text column — never a checkbox or the column the board is grouped by.
+     */
+    titleField?: string | null | undefined;
     /**
      * THE QUESTION THE ADDRESS ASKED, in the store's one filter shape — the same
      * object the chart counted with. It narrows the grid AND the board through
      * the store, so switching layout after a drill-through keeps the same rows
      * instead of quietly widening back to the whole table.
+     *
+     * S2-PRIME: either shape — a flat map, or the view's own nested question (`where`, the
+     * store's Rule shape). The grid, the board's headings and the numbers all ask it.
      */
-    filter?: RecordFilter | undefined;
+    filter?: StoreFilter | undefined;
     /**
      * The HOST layout showing now (`RecordsUiHost.layouts`, by id), or null for the
      * package's own. Controlled by the page, because the address names it.
@@ -2038,10 +2384,18 @@ interface ViewSwitcherProps {
     hostLayout?: string | null | undefined;
     /** The person picked a host layout (its id), or went back to one of the four (null). */
     onHostLayoutChange?: ((id: string | null) => void) | undefined;
+    /**
+     * Whether this component draws its own row — the view's name and the layout buttons. `false`
+     * when the page that mounts it draws the layout choice itself (`TablePage` keeps one control
+     * cluster for the whole table, lane DATA-V2-FACE). Default `true`, for every other host.
+     */
+    chooser?: boolean | undefined;
+    /** Handed to a host layout's `render` — the page's own export. */
+    openExport?: (() => void) | undefined;
     className?: string | undefined;
 }
 /** The records this view holds: its Rule's members when it names one, the table otherwise. */
-declare function useViewRecords(view: SavedViewSpec, pageSize?: number, filter?: RecordFilter): {
+declare function useViewRecords(view: SavedViewSpec, pageSize?: number, filter?: StoreFilter): {
     rows: ReadRow$1[];
     loading: boolean;
     error: RecordsError | null;
@@ -2059,7 +2413,7 @@ declare function useViewRecords(view: SavedViewSpec, pageSize?: number, filter?:
      */
     membership: string;
 };
-declare function ViewSwitcher({ view, onLayoutChange, onViewChange, onOpenRecord, onMoved, onNewRecordForm, onAskWhoChanged, pageSize, filter, hostLayout, onHostLayoutChange, className, }: ViewSwitcherProps): react.JSX.Element;
+declare function ViewSwitcher({ view, onLayoutChange, onViewChange, onOpenRecord, onMoved, onNewRecordForm, onAskWhoChanged, pageSize, titleField, filter, hostLayout, onHostLayoutChange, chooser, openExport, className, }: ViewSwitcherProps): react.JSX.Element;
 
 /** What the screen says above the list, so nobody has to be told twice that nothing was destroyed. */
 declare const ARCHIVE_MEANS = "Archiving never destroys anything. A record you remove from the grid waits here until somebody brings it back.";
@@ -2142,15 +2496,28 @@ interface ViewBarProps {
      * The person tweaks them afterwards like any other view.
      */
     seed?: SavedViewSpec[] | undefined;
+    /**
+     * Draw nothing while the table has at most one saved view (lane DATA-V2-FACE). One view is not
+     * a choice, and a row of one tab is chrome over the table; the page offers "Saved views" in its
+     * menu instead. Two or more views are a real choice and the bar draws.
+     */
+    quietWhenAlone?: boolean | undefined;
+    /** Every time the list is read: the views, or null when they could not be read. */
+    onViews?: ((views: SavedView[] | null) => void) | undefined;
     className?: string | undefined;
 }
 /**
- * What the bar says when this organization's saved-view Table cannot be levelled. It
- * names the ONE thing that is missing (the remembered layouts) and nothing else, because
- * everything else on the page still works and a longer sentence would suggest otherwise.
+ * What the bar says when the saved views cannot be read. It names the ONE thing that is
+ * missing (the remembered layouts) and nothing else, because everything else on the page
+ * still works and a longer sentence would suggest otherwise.
  */
 declare const SAVED_VIEWS_UNAVAILABLE: string;
-declare function ViewBar({ tableId, activeViewId, onActiveView, seed, className }: ViewBarProps): react.JSX.Element;
+/**
+ * WHETHER A SEED IS ALREADY THERE. A view by the seed's name always satisfies it; a DEFAULT seed
+ * is also satisfied by any view the table already marks as its default, whatever it is called.
+ */
+declare function seedIsSatisfied(seed: SavedViewSpec, views: readonly SavedView[]): boolean;
+declare function ViewBar({ tableId, activeViewId, onActiveView, seed, quietWhenAlone, onViews, className }: ViewBarProps): react.JSX.Element | null;
 
 /** One proposed change, in the proposer's words plus the exact act it asks for. */
 interface ProposedChange {
@@ -2207,19 +2574,31 @@ declare function ProposalRow({ change, outcome, onApply, onReject, readOnlyReaso
 /** The three things that land in the queue, exactly as the door names them. */
 declare const ACTION_KINDS: readonly ["approval", "assignment", "proposal"];
 type ActionKind = WorkInboxKind;
+/** How the rows are gathered under headings. `g` cycles kind → table → none. */
+type InboxGrouping = "kind" | "table" | "none";
+declare const INBOX_GROUPINGS: readonly InboxGrouping[];
+interface InboxGroup {
+    key: string;
+    label: string | null;
+    items: WorkInboxItem[];
+}
+/** THE grouping, pure: the headings and, flattened, the order the keys walk. */
+declare function groupInbox(items: readonly WorkInboxItem[], by: InboxGrouping): InboxGroup[];
 interface ActionInboxProps {
     /**
-     * Narrow to one table's work. The door answers the organization; this filters
-     * the assignments to the table a person is looking at, and leaves approvals
-     * and proposals alone because those are about a change, not about a table.
+     * Narrow to one table's work. Every row now carries the table it is about
+     * (lane S5-PRIME), so this narrows approvals, proposals and assignments alike;
+     * when the table has nothing, the inbox says how many wait elsewhere and offers them.
      */
     tableId?: Uuid | null | undefined;
-    /** Show decided rows too. The default is what is still waiting. */
+    /** Show decided rows too, from the start. `h` (or the button) toggles it. */
     includeSettled?: boolean | undefined;
+    /** How the rows start out grouped. Default: by kind. */
+    defaultGroupBy?: InboxGrouping | undefined;
     onOpenRecord?: ((recordId: Uuid, tableId: Uuid) => void) | undefined;
     className?: string | undefined;
 }
-declare function ActionInbox({ tableId, includeSettled, onOpenRecord, className }: ActionInboxProps): react.JSX.Element;
+declare function ActionInbox({ tableId, includeSettled, defaultGroupBy, onOpenRecord, className, }: ActionInboxProps): react.JSX.Element;
 
 interface HistoryPanelProps {
     tableId: Uuid;
@@ -2285,6 +2664,13 @@ interface FormTheme {
     accent?: string | null;
     align?: "left" | "center" | null;
 }
+/** The screen after sending: the form's words, and optionally where to go next. */
+interface FormThankYou {
+    title?: string | null;
+    body?: string | null;
+    /** A secure page on one of the organization's own sites. The store judges it. */
+    redirectUrl?: string | null;
+}
 /** THE COMPLETE DECLARATIVE SPEC. One `record_write` and the form exists. */
 interface FormSpec {
     name: string;
@@ -2294,10 +2680,15 @@ interface FormSpec {
     questions: FormQuestionSpec[];
     flow?: FormFlow | null;
     theme?: FormTheme | null;
-    thankYou?: {
-        title: string;
-        body?: string | null;
-    } | null;
+    /**
+     * WHAT THE PERSON SEES AFTER SENDING. `title` and `body` are the form's own
+     * words for the next step ("You are all set" / "Next, book your first visit").
+     * `redirectUrl` optionally sends them on to a page instead — and only ever to
+     * one of the organization's own sites: `custom.form_declare` refuses anything
+     * else by name, and `custom.form_public` stops handing it out the moment its
+     * site leaves the organization's list (lane S7-PRIME).
+     */
+    thankYou?: FormThankYou | null;
     submitLabel?: string | null;
     /**
      * Is this form meant to be answerable by someone who is not signed in? The
@@ -2453,6 +2844,8 @@ interface PortalCardViewProps {
     onPreview: (person: PortalPrincipal, tableId: Uuid) => Promise<PortalAnswer<PortalPreviewRow[]>>;
     /** The invite control, which needs a client of its own. Absent means none is offered. */
     invite?: ReactNode;
+    /** S6 — the look-and-forms editor, which needs a client of its own. Absent means none is offered. */
+    look?: ReactNode;
     /**
      * Where this app is served from, so a person's own invitation link can be copied whole.
      * Omit it and the view falls back to the browser's origin, which keeps this component
@@ -2461,7 +2854,16 @@ interface PortalCardViewProps {
     origin?: string | undefined;
     className?: string | undefined;
 }
-declare function PortalCardView({ card, tableId, onRevoke, onPreview, invite, origin, className, }: PortalCardViewProps): react.JSX.Element;
+declare function PortalCardView({ card, tableId, onRevoke, onPreview, invite, look, origin, className, }: PortalCardViewProps): react.JSX.Element;
+
+interface PortalLookEditorProps {
+    /** Exactly what `custom.portal_card` answered. */
+    card: PortalCard;
+    /** Called after the store took the new look; the host re-reads the card. */
+    onSaved: () => void;
+    className?: string | undefined;
+}
+declare function PortalLookEditor({ card, onSaved, className }: PortalLookEditorProps): react.JSX.Element;
 
 interface DigestSchedulerProps {
     /** The Table the digest is about. A saved view is a view OF something. */
@@ -2622,6 +3024,10 @@ interface ChartSpec {
     stateKey?: string;
     /** `stuck` only: how long a record may sit on the same value. */
     days?: number;
+    /** S3 — the comparison this block makes, as the store stores it. */
+    compare?: AggregateCompare | null;
+    /** S3 — the number this block aims for. */
+    target?: DashboardTarget | null;
 }
 /** A dashboard as `custom.dashboards` reports it, in the screen's own words. */
 interface SavedDashboard {
@@ -2794,9 +3200,17 @@ interface NotifyRuleEditorProps {
     tableId: Uuid;
     /** COMPLETE declarative subscriptions an agent wrote. Saved once, never overwritten. */
     seed?: NotifyRuleSpec[] | undefined;
+    /**
+     * CHOOSE MODE — the subscription something else points at (a form's notify
+     * Rule). Given with `onChoose`, each subscription offers to be the one, and a
+     * subscription made here becomes the one the moment the store has it.
+     */
+    chosenRuleId?: Uuid | null | undefined;
+    /** CHOOSE MODE — called with the chosen subscription's Rule id, or null to choose none. */
+    onChoose?: ((ruleId: Uuid | null) => void) | undefined;
     className?: string | undefined;
 }
-declare function NotifyRuleEditor({ tableId, seed, className }: NotifyRuleEditorProps): react.JSX.Element;
+declare function NotifyRuleEditor({ tableId, seed, chosenRuleId, onChoose, className }: NotifyRuleEditorProps): react.JSX.Element;
 
 interface ChartBlockProps {
     /** One block out of the canvas's single run — answered, or refused. */
@@ -2832,6 +3246,24 @@ interface FormsPanelProps {
 declare const FORM_NOT_HERE_LINE: string;
 declare function FormsPanel({ tableId, activeFormId, className }: FormsPanelProps): react.JSX.Element;
 
+/**
+ * What the public arm's `whichAsked` answers: for each question, whether the
+ * STORE says it is asked given the answers so far. `said` is the store's own
+ * sentence when it could not work a condition out — that question is asked, and
+ * the sentence is shown, never a silent hide.
+ */
+type FormAsked = {
+    ok: true;
+    asks: ReadonlyArray<{
+        field: string;
+        asked: boolean;
+        said?: string | null;
+    }>;
+} | {
+    ok: false;
+    message: string;
+    error?: RecordsError | undefined;
+};
 /** What the public arm's `onSubmit` answers. A refusal carries the door's words. */
 type FormSubmitOutcome = {
     ok: true;
@@ -2858,11 +3290,31 @@ interface FormRunnerProps {
     fields?: readonly Field[] | undefined;
     /** PUBLIC ARM — where an answer goes. Server action or route handler. */
     onSubmit?: ((values: Record<string, unknown>) => Promise<FormSubmitOutcome>) | undefined;
+    /**
+     * PUBLIC ARM — which questions are asked next, answered by the STORE on the
+     * server (`custom.form_public_asks`). Asked again as answers change. Left out
+     * on a form with conditions, every question is shown and the form says why.
+     */
+    whichAsked?: ((values: Record<string, unknown>) => Promise<FormAsked>) | undefined;
     /**
      * PUBLIC ARM — the name of a decoy input. A person never fills it; a script
      * fills everything. The door decides what a filled one means, not this screen.
      */
     honeypotKey?: string | null | undefined;
+    /**
+     * Answers the form starts with — a prefilled link, or a saved place being
+     * resumed. They are ordinary answers: shown in their questions, changeable,
+     * and handed to `whichAsked` like any typed answer, so branching follows.
+     */
+    initialAnswers?: Readonly<Record<string, unknown>> | undefined;
+    /** Every change to the answers, after the first paint. The host keeps the place. */
+    onAnswersChange?: ((answers: Record<string, unknown>) => void) | undefined;
+    /**
+     * `initialAnswers` is a saved place the person is coming back to, so the form
+     * opens on the first question still waiting for an answer. Without it a
+     * prefilled form opens on question one, showing the prefilled answer in place.
+     */
+    resumed?: boolean | undefined;
     /** Preview mode answers the questions but writes nothing, and says so. */
     preview?: boolean | undefined;
     onSubmitted?: ((recordId: Uuid | null) => void) | undefined;
@@ -3233,11 +3685,48 @@ interface TablesHomeProps {
      * did before, rather than on a screen it does not know how to address.
      */
     onOpenTable?: ((tableId: Uuid$1, dashboardId?: Uuid$1) => void) | undefined;
+    /**
+     * THE ORGANIZATION EVERY ROW HERE LIVES IN, BY NAME (lane SC-1-TAILS; access-is-personal: a
+     * list filtered by one organization says which). Each row carries a quiet "Lives in <name>"
+     * chip that, pressed, asks the store where that table lives and — for its owner — where else
+     * it can go. Absent: the list asks the store once, for its first table. When the store cannot
+     * name it, the chips are absent rather than a row of "unknown".
+     */
+    organizationName?: string | null | undefined;
+    /**
+     * ONLY THE WAYS TO MAKE A TABLE — New table, Start from an example, and the import that
+     * follows — and none of the lists (lane UI-FIX-18, VERIFIER-18 M3). A host page that already
+     * lists the organization's tables, dashboards and booking pages (matrx-frontend's
+     * organization hub) passes this, so one page never draws two full lists of the same tables.
+     * Default false: the package's own home, lists and all.
+     */
+    makingOnly?: boolean | undefined;
     className?: string | undefined;
 }
-declare function TablesHome({ onOpenTable, className }: TablesHomeProps): react.JSX.Element;
+declare function TablesHome({ onOpenTable, organizationName, makingOnly, className }: TablesHomeProps): react.JSX.Element;
 
-type Rail = "none" | "settings" | "inbox" | "import" | "field" | "record" | "new-record" | "forms" | "bookings" | "checklists" | "notifications" | "portals" | "who-changed";
+interface WhereItLivesProps {
+    tableId: Uuid$1;
+    /**
+     * The name the screen already holds (a list whose rows all live in one organization), shown
+     * until the store answers — and, on a row, instead of asking at all until the chip is pressed:
+     * forty rows are not forty reads.
+     */
+    knownOrganizationName?: string | null | undefined;
+    /** After a move lands: the host re-reads (the list, its rows, the page). */
+    onMoved?: ((to: {
+        id: Uuid$1;
+        name: string;
+    }) => void) | undefined;
+    /**
+     * `row` is quieter, for a list; `header` for an object page's own row; `title` rides the page
+     * header beside the object's name (Linear's team beside the issue title) — no frame, muted.
+     */
+    variant?: "header" | "row" | "title" | undefined;
+}
+declare function WhereItLives({ tableId, knownOrganizationName, onMoved, variant }: WhereItLivesProps): react.JSX.Element;
+
+type Rail = "none" | "settings" | "inbox" | "import" | "field" | "record" | "new-record" | "forms" | "bookings" | "checklists" | "notifications" | "portals" | "who-changed" | "export";
 interface TablePageProps {
     tableId: Uuid$1;
     /** Rows per page for every layout. */
@@ -3371,6 +3860,20 @@ interface TablePageProps {
      * said out loud by the rail, never replaced by its first row.
      */
     activeItemId?: Uuid$1 | null | undefined;
+    /**
+     * What the HOST puts at the start of the table's one row — the organization the table lives
+     * in, named quietly (the app's where-it-lives chip). One row: never a second bar above it.
+     */
+    leading?: ReactNode | undefined;
+    /**
+     * What the HOST adds to the table's one menu — a capability the package cannot know about (the
+     * app's "When a row changes, run an agent…"). Drawn after the package's own entries.
+     */
+    menuExtras?: ReadonlyArray<{
+        key: string;
+        label: string;
+        onSelect: () => void;
+    }> | undefined;
     className?: string | undefined;
 }
 /**
@@ -3517,7 +4020,22 @@ declare function openingView(activeView: string | null | undefined, activeDashbo
     layout: ViewLayout | null;
     unknown: string | null;
 };
-declare function TablePage({ tableId, pageSize, seedViews, onLeave, leaveLabel, activeDashboardId, activeRecordId, activeView, onViewChanged, activeGroupField, cameFrom, filter, activeRail, activeItemId, className, }: TablePageProps): react.JSX.Element;
+/**
+ * EVERYTHING A TABLE CAN DO THAT IS NOT LOOKING AT IT — in the table's ONE menu (lane
+ * DATA-V2-FACE). They were fourteen buttons in a row above the records, which is a toolbar
+ * describing the platform rather than the table; the owner met it on his own table and asked
+ * whether somebody was copying Notion and failing. Groups: the records themselves, what is
+ * built on them, and bringing things in and out.
+ */
+interface MenuEntryDef {
+    key: string;
+    label: string;
+    press: SurfacePress;
+    group: 1 | 2 | 3;
+    shown: (rights: ReturnType<typeof useTableRights>) => boolean;
+}
+declare const TABLE_MENU: readonly MenuEntryDef[];
+declare function TablePage({ tableId, pageSize, seedViews, onLeave, leaveLabel, activeDashboardId, activeRecordId, activeView, onViewChanged, activeGroupField, cameFrom, filter, activeRail, activeItemId, leading, menuExtras, className, }: TablePageProps): react.JSX.Element;
 
 /** What the roster can tell us about a user id. `null` when it cannot. */
 type ResolveName = (userId: Uuid$1) => string | null;
@@ -3568,95 +4086,6 @@ declare function WhoChangedSource({ tableId, labelOf, children, }: {
 /** What this cell can say about who last changed it. */
 declare function useWhoChanged(fieldKey: string, recordId: Uuid$1): WhoChanged;
 
-/** One Field a person asked for, in the words a person uses (FLD-1 / FLD-11). */
-interface NewFieldSpec {
-    key: string;
-    label: string;
-    /**
-     * The word for what this column holds. One of the thirteen parity types, one
-     * of the five behaviours, or a plain synonym (`text`, `long_text`, `number`)
-     * — `custom._field_document_for` resolves all three and refuses a word that
-     * means nothing, by name, with the list.
-     */
-    type: FieldTypeWord;
-    sort?: number;
-    required?: boolean;
-    multi?: boolean;
-    config?: Record<string, unknown>;
-    /** A choice list's choices, as words. The store keeps them as a Table (FLD-5). */
-    options?: string[];
-    /** A column that points at another Table of this organization (FLD-11 / REL-8). */
-    relationTarget?: Uuid$1;
-    /** A currency column's symbol; a date column's day-or-day-and-time. */
-    unit?: string;
-    kind?: "date" | "datetime";
-}
-interface NewTableSpec {
-    name: string;
-    /** The token the Table is addressed by. Derived from the name when absent. */
-    slug?: string;
-    labelSingular?: string;
-    labelPlural?: string;
-    /** The Field whose value is the record's title (REC-2). Defaults to the first Field. */
-    titleField?: string;
-    fields?: NewFieldSpec[];
-}
-type DeclareResult = 
-/**
- * The Table's id — and its HOME's, because REC-14 gives the Table exactly one
- * and the caller that made it is the only one that can tidy it up again. A
- * caller reading `data` alone is unaffected.
- */
-{
-    ok: true;
-    data: Uuid$1;
-    homeId: Uuid$1;
-} | {
-    ok: false;
-    error: RecordsError;
-};
-/** `My Sales Pipeline` → `my_sales_pipeline`. A token, never a sentence. */
-declare function tokenFor(name: string): string;
-/** The one Field a Table cannot be declared without: something to call a record. */
-/**
- * WHY THE FIRST FIELD IS NOT REQUIRED.
- *
- * It was, and the cost showed up the moment the grid could add a row: "New
- * record" writes an empty record and puts you in the first cell, and the store
- * correctly refused every one of them — `REC-51: Title is required` — so the
- * one gesture that makes a grid feel like a grid never worked on a table a
- * person had just made. A title is what makes a record a CHIP (REC-2), which is
- * a fact about how it is shown, not a promise it can never be written without;
- * an organization that wants it demanded says so in the field editor, and the
- * store then enforces it for everyone.
- */
-declare const DEFAULT_FIELDS: NewFieldSpec[];
-/**
- * One column, in the shape `custom.field_declare` takes — and EVERYTHING a
- * person said about it. The keys after the type are not decoration: without
- * `options` the door refuses a choice list outright ("A list of choices needs
- * its choices"), without `unit` a money column is dollars whatever the person
- * picked, and without `relation_target` a column that points at another of this
- * organization's own tables cannot be declared at all.
- */
-declare function fieldDeclarationFor(field: NewFieldSpec): NewFieldDeclaration;
-declare function declareTable(client: RecordsClient, spec: NewTableSpec): Promise<DeclareResult>;
-/**
- * Columns for an existing Table, through the door that declares one. Used by
- * the create path and by import.
- *
- * A column the store refused STOPS the sequence and hands back the store's own
- * sentence: a Table that quietly lost a column is the silent failure this
- * package exists to prevent.
- */
-declare function addFields(client: RecordsClient, tableId: Uuid$1, fields: NewFieldSpec[]): Promise<{
-    ok: true;
-    data: Uuid$1;
-} | {
-    ok: false;
-    error: RecordsError;
-}>;
-
 interface ShareControlProps {
     kind: ShareSubject["kind"];
     organizationId: Uuid$1;
@@ -3687,18 +4116,113 @@ declare function useCanShare(): boolean;
 declare function shareUnavailableReason(): string;
 declare function ShareControl({ kind, organizationId, subjectId, name, may, initiallyOpen, size, variant, className, }: ShareControlProps): ReactNode;
 
+/**
+ * 🚨 THE ONE DATE HELPER EVERY LAYOUT READS (lane UI-FIX-18, VERIFIER-18 H2 / M1).
+ *
+ * MEASURED 2026-09-24 on production, browser in America/Los_Angeles: Kitchen's start date,
+ * stored `2026-04-01`, read **Apr 1** in the grid, **Mar 31** on the calendar, **3/31** in
+ * the gallery, and Backyard Deck's May 1 read **4/30** in the record panel. The grid was right
+ * because it formats through the design system's registry (`formatFieldValue`), which reads a
+ * bare `YYYY-MM-DD` as a day on a calendar. Every other surface called `new Date("2026-04-01")`
+ * itself — which JavaScript parses as UTC MIDNIGHT — and then printed it in the viewer's zone,
+ * so everybody west of Greenwich saw the day before.
+ *
+ * THE CLASS, NOT THE INSTANCE. No component in this package parses or prints a date on its
+ * own any more; it asks this file, and this file asks the SAME registry the grid asks. The
+ * calendar's day key is the one thing the registry does not answer, and it is answered here
+ * by the same rule: a bare calendar date IS its own day (read the characters), an instant
+ * (`…Z`, `…+hh:mm`) is placed on the viewer's own calendar.
+ *
+ * The store's own stamps — Created time and Last changed time (`fx.created_time`,
+ * `fx.modified_time`) — are instants, and are printed like every other date-and-time cell
+ * (VERIFIER-18 M1 found `2026-09-25T00:13:34.564Z` in the grid, the gallery and the panel).
+ */
+
+/**
+ * Does this value (or, with no value, this Field) carry a TIME OF DAY as well as a date?
+ *
+ * A DATE IS A DATE (chair ruling, 2026-09-24). The control and the text follow the STORED
+ * VALUE's shape, never `config.kind` alone: a value with no time part — `1988-06-14`, a date
+ * of birth on a `kind: "datetime"` Field — gets a date-only control and a date-only reading
+ * everywhere (grid, form, panel, calendar). With no value yet, only a Field that says so
+ * outright carries a time: the older `format: "datetime"`, or the store's own Created / Last
+ * changed stamps (instants by construction).
+ */
+declare function carriesTimeOfDay(field: Pick<Field, "type" | "config" | "format">, value?: unknown): boolean;
+/** A value that names a moment in the day, not just the day. */
+declare function hasTimePart(value: unknown): boolean;
+/** Is this Field a date column at all — a dated range, or the store's own time stamp? */
+declare function isDateField(field: Pick<Field, "type" | "config">): boolean;
+/**
+ * The format a date-ish Field draws with, or `undefined` for a Field that is not one. With a
+ * value, it is that value's own shape; without, the Field's (`carriesTimeOfDay`).
+ * `presentation.formatForField` answers dates through this, so the grid and every card agree.
+ */
+declare function dateFormatFor(field: Pick<Field, "type" | "config" | "format">, value?: unknown): FieldFormatConfig | undefined;
+/**
+ * THE TEXT OF ONE DATE VALUE, in the viewer's language — through the design system's
+ * registry, exactly as the grid prints it, in the value's own shape. `null` when the value is
+ * not a date at all, so the caller can fall back to its own reading (THE FALLBACK LAW).
+ */
+declare function dateText(field: Pick<Field, "type" | "config" | "format">, value: unknown): string | null;
+/**
+ * THE CALENDAR DAY a value falls on, as `YYYY-MM-DD` — the key a calendar files a card under.
+ *
+ * A bare calendar date is its own day. An instant is placed on the VIEWER's calendar: a visit
+ * logged at 5:13 PM Pacific on 24 September is on the 24th for the person in Pacific time,
+ * even though it is already the 25th in UTC.
+ */
+declare function calendarDayOf(value: unknown): string | null;
+/** The heading of one calendar day — `Apr 1, 2026` — built on local midnight, never UTC. */
+declare function calendarDayLabel(day: string): string;
+
+/** The word a withheld cell shows in place of a value. Never "—", which means empty. */
+declare const WITHHELD_WORD = "Withheld";
+type Hidden = Readonly<Record<string, HiddenFieldNotice | undefined>> | null | undefined;
+/** The store's notice for this column of this row, when the store withheld it. */
+declare function withheldNoticeOf(hidden: Hidden, key: string): HiddenFieldNotice | null;
+/**
+ * THE SENTENCE, in the store's own words: the notice's `says` when the store wrote one (a
+ * worked-out column names what it reads), else the notice's reason, the level it needs and the
+ * other way in.
+ */
+declare function withheldSentence(field: Pick<Field, "key" | "label" | "name">, notice: HiddenFieldNotice): string;
+/** A withheld cell as a person reads it: the word, with the store's reason on hover. */
+declare function WithheldValue({ field, notice }: {
+    field: Field;
+    notice: HiddenFieldNotice;
+}): react.JSX.Element;
+
 interface PipelineBoardProps {
     tableId: Uuid;
     /** The rows the view holds — the SAME rows every other layout of this view draws. */
     rows: ReadRow$1[];
+    /**
+     * The table's own title column (`title_field`), from the table the host already holds — each
+     * card is named by it through `cardTitleField`. The board never reads the table again for it.
+     */
+    titleKey?: string | null | undefined;
     /** A number column to total under each heading. The person picks it; nothing is guessed. */
     measure?: string | null;
+    /**
+     * S2-PRIME — the question the cards under this board were read with, either shape. The
+     * headings are counted by the store with THE SAME question (`pipelineBoard({filter})`), so a
+     * column never says 16 over the 4 cards a view put in it.
+     */
+    filter?: StoreFilter | null | undefined;
     onMeasureChange?: ((key: string | null) => void) | undefined;
     onOpenRecord?: ((recordId: Uuid) => void) | undefined;
     /** Called after a move lands, so the host re-reads the rows it owns. */
     onMoved?: (() => void) | undefined;
+    /**
+     * THE COLORS THE REST OF THE VIEW PAINTS WITH (lane UI-QUICK-1) — `resolveTableStyle`'s answer,
+     * the table's G1 decorations under the view's own look. `ViewSwitcher`'s board passes the one it
+     * already resolved; left out, the board resolves the table's own decorations itself, so a host
+     * that mounts the board alone still tints its cards exactly as the grid tints the rows.
+     */
+    style?: TableStyle | undefined;
     className?: string | undefined;
 }
-declare function PipelineBoard({ tableId, rows, measure, onMeasureChange, onOpenRecord, onMoved, className, }: PipelineBoardProps): react.JSX.Element;
+declare function PipelineBoard({ tableId, rows, titleKey, measure, filter, onMeasureChange, onOpenRecord, onMoved, style, className, }: PipelineBoardProps): react.JSX.Element;
 
-export { ABSENCE_WORD_LABEL, ABSENCE_WORD_VALUES, ACTION_KINDS, ARCHIVED_NEVER_DESTROYED, ARCHIVE_MEANS, type AbsenceWord, ActionInbox, type ActionInboxProps, type ActionKind, type AgentBuildAsk, ArchivedDisclosure, type ArchivedDisclosureProps, ArchivedPortals, type ArchivedPortalsProps, ArchivedView, type ArchivedViewProps, BOOKING_NOT_HERE_LINE, BOOKING_PAGE_STATE_LABEL, BOOKING_PAGE_STATE_VALUES, BookingBuilder, type BookingBuilderProps, type BookingPageState, BookingSlots, type BookingSlotsProps, BuildOrAsk, type BuildOrAskProps, type BuildableKind, CAPTURE_MODES, CHART_KINDS, CHART_KIND_LABEL, CHART_NEEDS, CHECKLIST_REQUIREMENT_KINDS, CHECKLIST_REQUIREMENT_LABEL, CONDITION_OPS, CONTEXT_POLICY_LABEL, type Capability, type CaptureMode, type CaptureQueuePort, CaptureRun, type CaptureRunProps, CaptureSheet, type CaptureSheetProps, type CellAddress, type CellRefusal, type CellState, ChartBlock, type ChartBlockProps, type ChartConfig, ChartFrame, type ChartKind, ChartLegendContent, type ChartSpec, ChartTooltipContent, ChecklistRunner, type ChecklistRunnerProps, ChecklistTemplateEditor, ChecklistsPanel, type ChecklistsPanelProps, CommentThread, type CommentThreadProps, type ConditionField, ConditionGroup, type ConditionGroupProps, ConditionRow, type ConditionRowProps, CustomFieldsSection, type CustomFieldsSectionProps, DEFAULT_FIELDS, DEFAULT_VIEW_NAME, DUE_STATE_LABEL, DashboardCanvas, type DashboardCanvasProps, type DeclareResult, DigestScheduler, type DigestSchedulerProps, DocRender, type DocRenderProps, DocTemplate, type DocTemplateProps, type DocTemplateSpec, EMPTY_PRESENTATION, ENGINEER_TEXT, type EditorKind, EmbedFrame, type EmbedFrameProps, type EnrichAsk, EnrichBadge, type EnrichBadgeProps, type EnrichOutcome, EnrichPanel, type EnrichPanelProps, ExportMenu, type ExportMenuProps, FIELD_RULE_KIND_LABEL, FIELD_RULE_KIND_VALUES, FIELD_SENSITIVITY_LABEL, FIELD_TYPE_CHOICES, FIELD_TYPE_GROUPS, FORMULA_OP_JOINS, FORMULA_OP_LABEL, FORMULA_OP_VALUES, FORM_FLOWS, FORM_NOT_HERE_LINE, FROZEN_COLUMN_WIDTH, FieldControl, FieldEditor, type FieldEditorControlProps, type FieldEditorProps, FieldHistoryPanel, type FieldHistoryPanelProps, FieldLabel, type FieldProposalRow, type FieldRuleKindValue, type FieldTypeChoice, FilePicker, type FilePickerProps, FormBuilder, type FormBuilderProps, type FormFlow, type FormQuestionSpec, FormRunner, type FormRunnerProps, type FormSpec, type FormSubmitOutcome, type FormTheme, FormsPanel, type FormsPanelProps, type FormulaOp, Grid, GridCell, type GridEditing, type GridGrouping, type GridPresentation, type GridProps, HistoryPanel, type HistoryPanelProps, type HostLayout, IN_MEMORY_QUEUE_REASON, ImportWizard, type ImportWizardProps, KERNEL_REASON, LANE_EMPTY, LANE_TITLE, LAYOUT_FIELD_KIND, LAYOUT_LABEL, LAYOUT_NEEDS, LAYOUT_NO_FIELD, LEVEL_WORD, type LabelLookup, type LinkRail, MACHINE_IDENTITY, MAX_ROW_HEIGHT, MIN_ROW_HEIGHT, type MainView, MyChecklistSteps, NEEDS_A_SENTENCE, NOT_ANSWERED_YET, NOT_DRAWN_HERE, NO_AGENT_PORT, NO_CHAT_REASON, NO_COLUMNS_WHY, NO_COLUMNS_YET, NO_ENRICH_REASON, NO_MEMBERS_REASON, NO_OPEN_RECORDS_REASON, NO_REASK_REASON, NO_RIGHTS, NO_RULES_YET, NO_SAVED_VIEWS_REASON, NO_SHARE_REASON, NO_UPLOAD_REASON, type NewFieldSpec, type NewTableSpec, NotifyRuleEditor, type NotifyRuleEditorProps, type NotifyRuleSpec, type OpenRecordsAsk, type OrganizationMember, PAGE_VIEWS, PAGE_VIEW_LABEL, PARITY_LABEL, PARITY_MADE_OF, PORTAL_NOT_HERE_LINE, PROPOSED_CHANGE_ACT_LABEL, PROPOSED_CHANGE_ACT_VALUES, type PageView, Peek, type PeekProps, type PendingCapture, PersonPicker, type PersonPickerProps, type PickableFieldType, PipelineBoard, type PipelineBoardProps, type PlainFieldType, type PlainRefusal, type PortalAnswer, PortalBuilder, type PortalBuilderProps, PortalCardView, type PortalCardViewProps, PortalShell, type PortalShellProps, PortalsPanel, type PortalsPanelProps, type ProposalOutcome, ProposalRow, type ProposalRowProps, type ProposedChange, type ProposedChangeAct, ProvenanceBadge, PublicViewPage, type PublicViewPageProps, ROLLUP_AGG_LABEL, ROLLUP_AGG_VALUES, RULE_NOT_HERE_LINE, type ReaskContext, RecordChat, type RecordChatContext, type RecordChatEntry, type RecordChatProps, type RecordChatWithheld, RecordChip, RecordForm, type RecordFormProps, RecordLabelProvider, RecordValue, RecordsMount, type RecordsMountProps, type RecordsUiHost, RecordsUiProvider, ReferenceBuilder, type ReferenceBuilderProps, type ReferenceChoice, RefusalLine, RefusalNotice, type RelationFieldType, RelationPicker, type RelationPickerProps, type ResolveName, type RollupAgg, SAVED_VIEWS_UNAVAILABLE, SAY_WHAT_YOU_ARE_WAITING_FOR_AFTER_MS, SECTIONS_UNKNOWN, SERIES_COLORS, SHARE_NOT_YOURS_LINE, SOMEBODY, STAGE_RULE_ON_FAIL_LABEL, STORE_ANSWERS_THESE, STORE_DECIDES_REASON, SUBSCRIPTION_CADENCES, SUBSCRIPTION_CADENCE_LABEL, SUBSCRIPTION_CHANNEL_LABEL, SUBSCRIPTION_CHANNEL_VALUES, type SavedDashboard, type SavedForm, type SavedView, type SavedViewSpec, ShareControl, type ShareControlProps, type ShareSubject, SignBlock, type SignBlockProps, StageRulesSection, type StageRulesSectionProps, StepRow, type SubscriptionChannel, SubscriptionsPanel, type SubscriptionsPanelProps, type Surface, type SurfacePress, type SystemFieldSpec, type SystemTableSpec, TABLE_LANES, TABLE_NOT_REACHABLE, THE_SYSTEM, type TableLane, TablePage, type TablePageProps, type TableRights, TableSettings, type TableSettingsProps, TablesHome, type TablesHomeProps, type TrackedVersion, type UseSystemTableState, VIEW_LAYOUTS, VIEW_NOT_SAVED_YET, VIEW_TABLE, VISIBILITY_LANES, VISIBILITY_LANE_TITLE, ViewBar, type ViewBarProps, type ViewLayout, type ViewSort, ViewSwitcher, type ViewSwitcherProps, type VisibilityLane, WITHHELD_RECORD_LABEL, WORK_DUE_STATES, WORK_INBOX_KINDS, WORK_INBOX_KIND_LABEL, type WhatYouMayDo, type WhoChanged, WhoChangedSource, actorBadge, actorWords, addFields, archivedRowLine, asRefusal, askableFields, blockFromSpec, bodyForReading, bodyFromKeys, cameFromLine, cellState, chooseSurface, colorFromTheValue, columnForField, conditionInWords, conditionIsDrawable, conditionIsSimple, conditionValue, controlFor, currencyCodeFor, dashboardDeclareArgs, dashboardFromSummary, declareTable, editorKindFor, ensureSystemTable, envelopeFor, fieldDeclarationFor, fieldIsEditable, fieldName, fieldToken, fieldTypeChoice, fieldTypeLabel, formDeclareArgs, formFromSummary, formPresentation, formatForField, groupLabel, hintForAPerson, hintIsMachineIdentity, humanize, idsOf, isEngineerText, isId, isMachineIdentity, isParityFieldType, isPlainFieldType, isRelationFieldType, isSignatureField, keptByTheApp, keyFor, kindsWithNoChoice, laneFor, lastChangeSentence, looksLikeId, machineIdentityIn, mayNotRestoreLine, memberName, nextInWords, nextSummaryAt, openingRail, openingView, pageViewFromParam, parityTypesWithNoExplanation, parseGridPresentation, personActor, personRecordForMember, pointsAtRecords, presentationDocument, presentationIsEmpty, previewLine, previewWords, publiclyAnswerable, railFromParam, recordName, recordNameIn, recordsDataSource, refusal, refusalForAPerson, refusalFromThrown, refusalLineForAPerson, refusalOr, renderValue, revokeConsequence, rowName, rowNameIn, saveViewPatch, scalarText, shareUnavailableReason, specFromBlock, storeDecidesRights, submissionStamp, surfaceChosen, tableName, tableRightsAt, tokenFor, unknownRailLine, unknownViewLine, useCanShare, useEmbedHandshake, useEnrichCells, useGridEditing, useLabelWait, useMeasuredWidth, useMyChecklistSteps, useRecordLabels, useRecordRights, useRecordsUi, useRowRights, useSystemTable, useTableRights, useViewRecords, useWhoChanged, viewDocument, viewFromRecord, viewPatchDocument, visibilityLaneFor, whatIsMissing, whatYouMayDo, whatYouMayDoWithTable, whenWords, whyNotAskable };
+export { ABSENCE_WORD_LABEL, ABSENCE_WORD_VALUES, ACTION_KINDS, ARCHIVED_NEVER_DESTROYED, ARCHIVE_MEANS, type AbsenceWord, ActionInbox, type ActionInboxProps, type ActionKind, type AgentBuildAsk, ArchivedDisclosure, type ArchivedDisclosureProps, ArchivedPortals, type ArchivedPortalsProps, ArchivedView, type ArchivedViewProps, BOOKING_NOT_HERE_LINE, BOOKING_PAGE_STATE_LABEL, BOOKING_PAGE_STATE_VALUES, BookingBuilder, type BookingBuilderProps, type BookingPageState, BookingSlots, type BookingSlotsProps, BuildOrAsk, type BuildOrAskProps, type BuildableKind, CAPTURE_MODES, CHART_KINDS, CHART_KIND_LABEL, CHART_NEEDS, CHECKLIST_REQUIREMENT_KINDS, CHECKLIST_REQUIREMENT_LABEL, CONDITION_OPS, CONTEXT_POLICY_LABEL, type Capability, type CaptureMode, type CaptureQueuePort, CaptureRun, type CaptureRunProps, CaptureSheet, type CaptureSheetProps, type CellAddress, type CellRefusal, type CellState, ChartBlock, type ChartBlockProps, type ChartConfig, ChartFrame, type ChartKind, ChartLegendContent, type ChartSpec, ChartTooltipContent, ChecklistRunner, type ChecklistRunnerProps, ChecklistTemplateEditor, ChecklistsPanel, type ChecklistsPanelProps, CommentThread, type CommentThreadProps, type ConditionField, ConditionGroup, type ConditionGroupProps, ConditionRow, type ConditionRowProps, CustomFieldsSection, type CustomFieldsSectionProps, DEFAULT_VIEW_NAME, DUE_STATE_LABEL, DashboardCanvas, type DashboardCanvasProps, DigestScheduler, type DigestSchedulerProps, DocRender, type DocRenderProps, DocTemplate, type DocTemplateProps, type DocTemplateSpec, EMPTY_PRESENTATION, ENGINEER_TEXT, ENTITY_REFERENCE_KINDS_MISSING, type EditorKind, EmbedFrame, type EmbedFrameProps, type EnrichAsk, EnrichBadge, type EnrichBadgeProps, type EnrichOutcome, EnrichPanel, type EnrichPanelProps, EntityReferenceKindPicker, type EntityReferenceKindPickerProps, ExportMenu, type ExportMenuProps, FIELD_RULE_KIND_LABEL, FIELD_RULE_KIND_VALUES, FIELD_SENSITIVITY_LABEL, FIELD_TYPE_CHOICES, FIELD_TYPE_GROUPS, FORMULA_OP_JOINS, FORMULA_OP_LABEL, FORMULA_OP_VALUES, FORM_FLOWS, FORM_NOT_HERE_LINE, FROZEN_COLUMN_WIDTH, FieldControl, FieldEditor, type FieldEditorControlProps, type FieldEditorProps, FieldHistoryPanel, type FieldHistoryPanelProps, FieldLabel, type FieldProposalRow, type FieldRuleKindValue, type FieldTypeChoice, FilePicker, type FilePickerProps, type FormAsked, FormBuilder, type FormBuilderProps, type FormFlow, type FormQuestionSpec, FormRunner, type FormRunnerProps, type FormSpec, type FormSubmitOutcome, type FormTheme, FormsPanel, type FormsPanelProps, type FormulaOp, Grid, GridCell, type GridEditing, type GridGrouping, type GridPresentation, type GridProps, HistoryPanel, type HistoryPanelProps, type HostLayout, INBOX_GROUPINGS, IN_MEMORY_QUEUE_REASON, ImportWizard, type ImportWizardProps, type InboxGroup, type InboxGrouping, KERNEL_REASON, LANE_EMPTY, LANE_TITLE, LAYOUT_FIELD_KIND, LAYOUT_LABEL, LAYOUT_NEEDS, LAYOUT_NO_FIELD, LEVEL_WORD, type LabelLookup, type LinkRail, MACHINE_IDENTITY, MAX_ROW_HEIGHT, MIN_ROW_HEIGHT, type MainView, MyChecklistSteps, NEEDS_A_SENTENCE, NOT_ANSWERED_YET, NOT_DRAWN_HERE, NO_AGENT_PORT, NO_CHAT_REASON, NO_COLUMNS_WHY, NO_COLUMNS_YET, NO_ENRICH_REASON, NO_MEMBERS_REASON, NO_OPEN_RECORDS_REASON, NO_REASK_REASON, NO_RIGHTS, NO_RULES_YET, NO_SAVED_VIEWS_REASON, NO_SHARE_REASON, NO_UPLOAD_REASON, NotifyRuleEditor, type NotifyRuleEditorProps, type NotifyRuleSpec, type OpenRecordsAsk, type OrganizationMember, PAGE_VIEWS, PAGE_VIEW_LABEL, PARITY_LABEL, PARITY_MADE_OF, PORTAL_NOT_HERE_LINE, PROPOSED_CHANGE_ACT_LABEL, PROPOSED_CHANGE_ACT_VALUES, type PageView, Peek, type PeekProps, type PendingCapture, PersonPicker, type PersonPickerProps, type PickableFieldType, PipelineBoard, type PipelineBoardProps, type PlainFieldType, type PlainRefusal, type PortalAnswer, PortalBuilder, type PortalBuilderProps, PortalCardView, type PortalCardViewProps, PortalLookEditor, type PortalLookEditorProps, PortalShell, type PortalShellProps, PortalsPanel, type PortalsPanelProps, type ProposalOutcome, ProposalRow, type ProposalRowProps, type ProposedChange, type ProposedChangeAct, ProvenanceBadge, PublicViewPage, type PublicViewPageProps, ROLLUP_AGG_LABEL, ROLLUP_AGG_VALUES, RULE_NOT_HERE_LINE, type ReaskContext, RecordChat, type RecordChatContext, type RecordChatEntry, type RecordChatProps, type RecordChatWithheld, RecordChip, RecordForm, type RecordFormProps, RecordLabelProvider, RecordValue, RecordsMount, type RecordsMountProps, type RecordsUiHost, RecordsUiProvider, ReferenceBuilder, type ReferenceBuilderProps, type ReferenceChoice, RefusalLine, RefusalNotice, type RelationFieldType, RelationPicker, type RelationPickerProps, type ResolveName, type RollupAgg, SAVED_VIEWS_UNAVAILABLE, SAY_WHAT_YOU_ARE_WAITING_FOR_AFTER_MS, SECTIONS_UNKNOWN, SERIES_COLORS, SHARE_NOT_YOURS_LINE, SOMEBODY, STAGE_RULE_ON_FAIL_LABEL, STORE_ANSWERS_THESE, STORE_DECIDES_REASON, SUBSCRIPTION_CADENCES, SUBSCRIPTION_CADENCE_LABEL, SUBSCRIPTION_CHANNEL_LABEL, SUBSCRIPTION_CHANNEL_VALUES, type SavedDashboard, type SavedForm, type SavedView, type SavedViewSpec, ShareControl, type ShareControlProps, type ShareSubject, SignBlock, type SignBlockProps, StageRulesSection, type StageRulesSectionProps, StepRow, type SubscriptionChannel, SubscriptionsPanel, type SubscriptionsPanelProps, type Surface, type SurfacePress, type SystemFieldSpec, type SystemTableSpec, TABLE_LANES, TABLE_MENU, TABLE_NOT_REACHABLE, THE_SYSTEM, type TableLane, type TableOpening, TablePage, type TablePageProps, type TableRights, TableSettings, type TableSettingsProps, TablesHome, type TablesHomeProps, type TrackedVersion, type UseSystemTableState, VIEW_KEYS, VIEW_LAYOUTS, VIEW_NOT_SAVED_YET, VISIBILITY_LANES, VISIBILITY_LANE_TITLE, ViewBar, type ViewBarProps, type ViewKeyDeclaration, type ViewKeyLayout, type ViewKeyWriter, type ViewLayout, type ViewSettings, type ViewSettingsPatch, type ViewSort, type ViewSortKey, ViewSwitcher, type ViewSwitcherProps, type VisibilityLane, WITHHELD_RECORD_LABEL, WITHHELD_WORD, WORK_APPROVAL_STATES, WORK_APPROVAL_STATE_LABEL, WORK_DUE_STATES, WORK_INBOX_KINDS, WORK_INBOX_KIND_GROUP_LABEL, WORK_INBOX_KIND_LABEL, type WhatYouMayDo, WhereItLives, type WhereItLivesProps, type WhoChanged, WhoChangedSource, WithheldValue, actorBadge, actorWords, archivedRowLine, asRefusal, askableFields, blockFromSpec, bodyForReading, bodyFromKeys, calendarDayLabel, calendarDayOf, cameFromLine, cardTitleField, cardWords, carriesTimeOfDay, cellState, chooseSurface, colorFromTheValue, columnForField, conditionInWords, conditionIsDrawable, conditionIsSimple, conditionValue, controlFor, currencyCodeFor, dashboardDeclareArgs, dashboardFromSummary, dateFormatFor, dateText, declareView, defaultViewOf, designatedLayoutOf, editorKindFor, ensureSystemTable, entityReferenceSpec, envelopeFor, fieldIsEditable, fieldName, fieldToken, fieldTypeChoice, fieldTypeLabel, formDeclareArgs, formFromSummary, formPresentation, formatForField, groupInbox, groupLabel, hasTimePart, hintForAPerson, hintIsMachineIdentity, humanize, idsOf, isDateField, isEngineerText, isId, isMachineIdentity, isParityFieldType, isPlainFieldType, isRelationFieldType, isSignatureField, keptByTheApp, keyFor, kindsWithNoChoice, laneFor, lastChangeSentence, looksLikeId, machineIdentityIn, mayNotRestoreLine, memberName, nextInWords, nextSummaryAt, openingRail, openingView, pageViewFromParam, parityTypesWithNoExplanation, parseGridPresentation, personActor, personRecordForMember, pointsAtRecords, presentationDocument, presentationIsEmpty, previewLine, previewWords, publiclyAnswerable, railFromParam, recordName, recordNameIn, recordsDataSource, refusal, refusalForAPerson, refusalFromThrown, refusalLineForAPerson, refusalOr, renderValue, resolveTableStyle, revokeConsequence, rowName, rowNameIn, saveViewPatch, scalarText, seedIsSatisfied, shareUnavailableReason, specFromBlock, storeDecidesRights, styleFromDecorations, submissionStamp, surfaceChosen, tableName, tableOpening, tableRightsAt, unknownRailLine, unknownViewLine, useCanShare, useEmbedHandshake, useEnrichCells, useGridEditing, useLabelWait, useMeasuredWidth, useMyChecklistSteps, useRecordLabels, useRecordRights, useRecordsUi, useRowRights, useSystemTable, useTableRights, useViewRecords, useWhoChanged, viewDocument, viewFromRow, viewKeysFor, viewPatchDocument, viewSettings, viewSettingsFor, viewSettingsPatch, visibilityLaneFor, whatIsMissing, whatIsMissingForEntityReference, whatYouMayDo, whatYouMayDoWithTable, whenWords, whyNotAskable, withheldNoticeOf, withheldSentence };