@ai-matrx/records-ui 0.9.0 → 0.16.0

package/dist/index.d.ts

@@ -1,10 +1,48 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { Uuid as Uuid$1, Table, Field, RecordDocument, ReadRow, RecordsError, WriteConflict, ValueEnvelope, ParityFieldType, RuleExpression, AggregateBucket, AggregateMeasure, DocTemplateRow, DocRenderRow, AnonTokenBinding, RecordsConfig, RecordsActor, RecordsDataSource } from '@ai-matrx/records';
+import { PermissionLevel, Table, Uuid as Uuid$1, RecordsError, Field, RecordDocument, ReadRow, WriteConflict, ParityFieldType, NewFieldDeclaration, ValueEnvelope, WorkInboxKind, RuleExpression, AggregateBucket, AggregateMeasure, DocTemplateRow, DocRenderRow, AnonTokenBinding, RecordsConfig, RecordsActor, RecordsDataSource } from '@ai-matrx/records';
 import { Uuid, Field as Field$1, ReadRow as ReadRow$1 } from '@ai-matrx/records/react';
 import { RecordsClient } from '@ai-matrx/records/core';
 import { MatrxColumnDef } from '@ai-matrx/design-system/data-table/types';
 
+/** The six things a person does to a record or a table, as the screens offer them. */
+type Capability = "read" | "comment" | "write" | "remove" | "share" | "structure";
+interface WhatYouMayDo {
+    /** The word the store answered, or null when it answered nothing. */
+    level: PermissionLevel | null;
+    /**
+     * Whether the store has ANSWERED yet. `false` is a third state and not a
+     * refusal: a screen that drew "you may not" while the answer was in flight
+     * would blink every control off on every reload, which is its own lie.
+     */
+    known: boolean;
+    read: boolean;
+    comment: boolean;
+    write: boolean;
+    remove: boolean;
+    share: boolean;
+    structure: boolean;
+    /** Why this person may not do that, in one sentence naming the way in. */
+    why: (what: Capability) => string;
+}
+/** What each rung of the ladder is called where a person reads it. */
+declare const LEVEL_WORD: Record<PermissionLevel, string>;
+/**
+ * WHAT ONE LEVEL LETS A PERSON DO. `level` null and `known` true means the
+ * store said "nothing" — a real answer. `known` false means it has not said.
+ */
+declare function whatYouMayDo(level: PermissionLevel | null, known?: boolean): WhatYouMayDo;
+/** Nothing offered, because nothing is known yet. */
+declare const NOT_ANSWERED_YET: WhatYouMayDo;
+/**
+ * REC-27. The nine Tables the platform ships are not administered from a
+ * person's screen whatever level they hold on them — so the structure controls
+ * are absent for a kernel Table and say why, and everything else follows the
+ * level as usual.
+ */
+declare const KERNEL_REASON: string;
+declare function whatYouMayDoWithTable(table: Table | null | undefined, level: PermissionLevel | null, known: boolean): WhatYouMayDo;
+
 /** One named piece of grounding, shaped the way the platform's context slice takes them. */
 interface RecordChatEntry {
     key: string;
@@ -70,21 +108,37 @@ interface EnrichPanelProps {
 }
 declare function EnrichPanel({ tableId, recordId, className }: EnrichPanelProps): react.JSX.Element;
 
-/** What a person may do to one table. The words are the store's, not ours. */
-interface TableRights {
+/**
+ * What a person may do to one table. The four words and the ladder are the
+ * store's (`rights.ts`), not ours.
+ *
+ * `admin`, `comment` and `write` are kept with the names they have always had,
+ * because every screen in this package and in the host apps reads them; they
+ * are now the store's ANSWER rather than a host's guess.
+ */
+interface TableRights extends WhatYouMayDo {
     /** SCR-2: holders of `admin` on the table see the "+" and the settings panel. */
     admin: boolean;
-    /** SCR-18: `commenter` and no higher right. */
-    comment: boolean;
-    /** May write records at all. */
-    write: boolean;
     /**
-     * Why this answer, in a sentence a person can read. Never empty: a right that
-     * is false without a reason is the silent failure this package refuses.
+     * Why this answer, in one sentence. Kept for callers that show a single
+     * reason; `why(what)` is the per-control sentence and is what the screens use.
      */
     reason: string;
 }
+/**
+ * Kept so a host that imported it still compiles. It is no longer any screen's
+ * default: the store answers this question now, and a package that said "I
+ * assume nothing" while holding the answer would be hiding controls from the
+ * people who hold them.
+ */
 declare const NO_RIGHTS: TableRights;
+/**
+ * THE ONE WAY TO BUILD A `TableRights` BY HAND — for a host with its own
+ * authority, and for a suite that wants to mount one seat's screen. It takes
+ * the LEVEL, never six booleans, so nobody can hand a screen a combination the
+ * ladder cannot produce (write without read, share without edit).
+ */
+declare function tableRightsAt(level: PermissionLevel | null): TableRights;
 interface RecordsUiHost {
     /** Answer the rights question for one table. Synchronous: a screen renders now. */
     rights?: (table: Table) => TableRights;
@@ -122,6 +176,14 @@ interface RecordsUiHost {
         ok: false;
         reason: string;
     }>;
+    /**
+     * Where this app serves its PUBLIC pages from, when that is not the origin
+     * the screen is running on. A form's link is built here, so an owner copying
+     * it from an admin host, a preview deployment or a desktop shell gets the
+     * address a stranger can actually open — never `http://localhost:3000/f/…`
+     * pasted into an email. Unbound, the browser's own origin is used.
+     */
+    publicOrigin?: string;
     /**
      * OPTIONAL. The organization's saved views as `platform.saved_view` holds
      * them — which is what a subscription points at (DOOR-18). The record store
@@ -267,8 +329,81 @@ declare function RecordsUiProvider({ value, children }: {
     children: ReactNode;
 }): react.JSX.Element;
 declare function useRecordsUi(): RecordsUiHost;
-/** The rights for one table — `NO_RIGHTS`, with its reason, when nothing is bound. */
+/**
+ * WHAT THIS PERSON MAY DO TO THIS TABLE — asked, once per table.
+ *
+ * A host that binds `rights` still wins: a portal, an embed or an app with its
+ * own authority is entitled to a narrower answer than the store's. An unbound
+ * host no longer gets a guess in either direction — while the door is
+ * answering, `known` is false and NOTHING is offered and nothing is claimed.
+ */
 declare function useTableRights(table: Table | null | undefined): TableRights;
+/**
+ * WHAT THIS PERSON MAY DO TO ONE RECORD — which is a different question from
+ * the table's, and the sixth-pass verdict is the proof: a record shared with a
+ * colleague at Editor inside a table she holds at Viewer. The grid used to
+ * label that row "viewer" while the store let her write to it.
+ */
+declare function useRecordRights(recordId: Uuid$1 | null): WhatYouMayDo;
+/**
+ * The same question for a whole page of records, in ONE call — the door takes a
+ * list precisely so a grid never makes one call per row.
+ *
+ * `enabled` is how a grid avoids asking at all in the ordinary case: when the
+ * table level already admits editing, every row it returned is editable and
+ * there is nothing a per-record answer could add.
+ */
+declare function useRowRights(rowIds: Uuid$1[], enabled: boolean): (rowId: Uuid$1) => WhatYouMayDo | null;
+
+/**
+ * MACHINE IDENTITY, BY SHAPE — never by a list of the sentences we happen to
+ * have seen, because the next refusal is one nobody has read yet.
+ *
+ *   `FLD-11:` / `REC-29:` / `AGT-7:`     a contract row id
+ *   `custom.field_declare`               a schema-qualified database object
+ *   `config.via` / `data.fields`         a path inside a stored document
+ *   `retention_days`                     a document key, snake_case
+ *   `8f2c1b0a-…`                         a uuid
+ *   `23514` / `PT409`                    a SQLSTATE
+ */
+declare const MACHINE_IDENTITY: RegExp[];
+/** Whether any shape above appears in this text. */
+declare function isMachineIdentity(text: string): boolean;
+/**
+ * Every fragment of `text` that a person should never have been shown. Used by
+ * the suite to say WHAT it found rather than only that it found something.
+ */
+declare function machineIdentityIn(text: string): string[];
+/** The one shape every screen in this package renders a refusal from. */
+interface PlainRefusal {
+    /** The heading. Never the store's code. */
+    title: string;
+    /**
+     * What happened, in the store's own words where they are a person's words
+     * and in ours where they are not. Never empty.
+     */
+    sentence: string;
+    /** What to do now. Never empty. */
+    remedy: string;
+    /**
+     * Everything a person should not read, kept for whoever has to debug it: the
+     * SQLSTATE, the hint written for a caller, and any clause dropped above.
+     * Rendered out of sight (the notice's `title` attribute and a screen-reader-
+     * only line), never deleted.
+     */
+    forEngineers: string;
+}
+/**
+ * THE FORMATTER. Every refusal a screen in this package shows goes through
+ * here, and nothing in this package renders `error.message` directly.
+ */
+declare function refusalForAPerson(error: RecordsError): PlainRefusal;
+/**
+ * The same answer as one line, for a cell or a field where a block would break
+ * the layout. Still one sentence and one remedy — never the sentence alone,
+ * because half of this formatter's job is the thing to do next.
+ */
+declare function refusalLineForAPerson(error: RecordsError): string;
 
 /**
  * A token (`records_ui_view`, `long_text`, `v78_widget2`) as a person would
@@ -347,12 +482,21 @@ interface GridEditing {
     /** The value to DRAW for one cell — the optimistic one when there is one. */
     valueFor: (row: ReadRow, field: Field) => unknown;
     editing: CellAddress | null;
+    /** What has been typed into the open cell. Owned here, never by the cell. */
+    draft: unknown;
+    /** The open cell's editor reports every keystroke to the session. */
+    type: (value: unknown) => void;
     stateOf: (rowId: Uuid$1, key: string) => CellState;
     refusalOf: (rowId: Uuid$1, key: string) => CellRefusal | null;
     begin: (address: CellAddress) => void;
     cancel: () => void;
-    /** Commit the open cell. `move` opens the next/previous editable cell after it. */
-    commit: (value: unknown, move?: "next" | "previous" | null) => void;
+    /**
+     * Commit the open cell — whatever is in `draft`. `move` opens the
+     * next/previous editable cell after it. It takes NO value: a caller that
+     * passed one would be a second copy of the typed value, which is the defect
+     * this file's header describes.
+     */
+    commit: (move?: "next" | "previous" | null) => void;
     /** Write the attempted value again, after re-reading the version. */
     retry: (rowId: Uuid$1, key: string) => void;
     /** Drop the edit and show what the other person wrote. */
@@ -374,8 +518,19 @@ interface Options {
     reload: () => void;
     /** May this person write records at all? A read-only grid opens no editor. */
     canWrite: boolean;
+    /**
+     * MAY THIS PERSON WRITE *THIS* ROW — asked before an editor is opened, never
+     * after it has been typed into.
+     *
+     * A level on the TABLE is not the answer for a row: the sixth-pass verdict
+     * found a record shared with a colleague at Editor inside a table she held at
+     * Viewer, and the grid labelled the row "viewer" while the store let her
+     * write to it. Unbound, every row follows the table, which is what the
+     * ordinary case is.
+     */
+    mayWriteRow?: ((rowId: Uuid$1) => boolean) | undefined;
 }
-declare function useGridEditing({ tableId, fields, rows, reload, canWrite }: Options): GridEditing;
+declare function useGridEditing({ tableId, fields, rows, reload, canWrite, mayWriteRow }: Options): GridEditing;
 /**
  * ONE CELL. Read, until somebody asks to change it; then the Field's own
  * editor, in place, with the keys a person expects from a grid.
@@ -383,13 +538,27 @@ declare function useGridEditing({ tableId, fields, rows, reload, canWrite }: Opt
  * `data-matrx-cell-control` is the data table's own opt-out from whole-row
  * click, so opening a cell never also opens the record panel behind it.
  */
-declare function GridCell({ field, row, editing, canWrite, }: {
+declare function GridCell({ field, row, editing, canWrite, whyNot, }: {
     field: Field;
     row: ReadRow;
     editing: GridEditing;
+    /** Whether this person may write THIS row. Asked before the cell is drawn. */
     canWrite: boolean;
+    /**
+     * Why not, when not — one sentence naming the level it would take and who can
+     * give it. A cell that is simply not a control, with nothing to say about it,
+     * is the silent half of the same defect this file closes.
+     */
+    whyNot?: string | undefined;
 }): react.JSX.Element;
 
+/**
+ * Kept for callers outside this package that already ask the question. The
+ * answer is `plainWords.ts`'s, so there is one shape list and not two.
+ */
+declare function hintIsMachineIdentity(hint: string): boolean;
+/** The hint a PERSON should read, or null when it is written for an engineer. */
+declare function hintForAPerson(hint: string | null | undefined): string | null;
 declare function RefusalNotice({ error, className, actions, }: {
     error: RecordsError;
     className?: string | undefined;
@@ -427,7 +596,7 @@ declare function Grid({ tableId, pageSize, onOpenRecord, onAddField, onNewRecord
  * key (`names.ts`) — and the cell is the value, rendered by its parity type and
  * editable in place when an editing session is passed.
  */
-declare function columnForField(field: Field$1, editing?: GridEditing | null): MatrxColumnDef<ReadRow$1>;
+declare function columnForField(field: Field$1, editing?: GridEditing | null, mayWriteRow?: (rowId: Uuid) => boolean, whyNotRow?: (rowId: Uuid) => string): MatrxColumnDef<ReadRow$1>;
 
 interface ExportMenuProps {
     tableId: Uuid;
@@ -449,24 +618,42 @@ interface ImportWizardProps {
 declare function ImportWizard({ tableId, onProposeField, onDone, className }: ImportWizardProps): react.JSX.Element;
 
 interface CustomFieldsSectionProps {
-    /**
-     * The Table the Fields extend. For a standard entity this is the Table record
-     * that stands for that entity — the host passes it, because which entity a
-     * page is showing is the page's own fact.
-     *
-     * A page that knows the entity's TOKEN rather than its id passes `entityToken`
-     * instead, and this section resolves it: an entity page must not have to run
-     * a lookup of its own to add one line.
-     */
-    tableId?: Uuid | undefined;
-    /** The entity's registered token (REC-33), e.g. `party`. Resolved to its Table. */
-    entityToken?: string | undefined;
+    /** The standard table's registered token (REC-33), e.g. `party`, `crm_deal`. */
+    entityToken: string;
+    /** The id of the row this page is showing. */
     recordId: Uuid;
     /** The heading. One row, no subtitle restating it. */
     title?: string | undefined;
     className?: string | undefined;
 }
-declare function CustomFieldsSection({ tableId, entityToken, recordId, title, className, }: CustomFieldsSectionProps): react.JSX.Element | null;
+declare function CustomFieldsSection({ entityToken, recordId, title, className, }: CustomFieldsSectionProps): react.JSX.Element | null;
+
+/** The three behaviours that carry no parity type of their own. */
+type PlainFieldType = "text" | "long_text" | "number";
+/** What a person picks in the panel: one of the thirteen, or one of the three. */
+type PickableFieldType = ParityFieldType | PlainFieldType;
+interface FieldTypeChoice {
+    id: PickableFieldType;
+    /** The word on the menu. */
+    label: string;
+    /** One line, under the word, saying what it is FOR. Never what it is made of. */
+    explanation: string;
+    /** The heading it sits under, so sixteen choices read as four short lists. */
+    group: "Words" | "Numbers and dates" | "Choices and people" | "Worked out";
+}
+declare const FIELD_TYPE_CHOICES: FieldTypeChoice[];
+declare const FIELD_TYPE_GROUPS: FieldTypeChoice["group"][];
+declare function fieldTypeChoice(id: string): FieldTypeChoice | undefined;
+/** The three that are a plain behaviour rather than one of the thirteen. */
+declare function isPlainFieldType(id: string): id is PlainFieldType;
+/**
+ * THE GUARD THIS FILE NEEDS, because the list it explains is generated.
+ *
+ * Returns the parity types the store ships that nothing here explains. The
+ * suite asserts it is empty; a fourteenth type would otherwise reach the menu
+ * with a blank line under it and nobody would notice until a person did.
+ */
+declare function parityTypesWithNoExplanation(): string[];
 
 /** `Day rate` → `day_rate`. Shown, so nothing about it is a surprise. */
 declare function keyFor(label: string): string;
@@ -481,6 +668,29 @@ interface FieldEditorProps {
     className?: string | undefined;
 }
 declare function FieldEditor({ tableId, field, onSaved, onCancel, onRemoved, className }: FieldEditorProps): react.JSX.Element;
+/**
+ * WHAT THE PANEL STILL NEEDS BEFORE THE STORE WOULD TAKE THIS, in plain words.
+ *
+ * It answers exactly the questions this panel asked, so every sentence names a
+ * control the person is looking at. It is NOT a second copy of the store's
+ * rules and it is not allowed to become one: the store decides, and every one
+ * of these is something the panel can see is unanswered without asking it.
+ *
+ * Exported so the suite can assert the sentences without driving the whole
+ * panel, and so the red twin can assert that removing it puts the contract row
+ * id back in front of a person.
+ */
+declare function whatIsMissing(state: {
+    type: PickableFieldType;
+    label: string;
+    options: string[];
+    via: string;
+    pick: string;
+    agg: NonNullable<NewFieldDeclaration["agg"]>;
+    of: string;
+    relations: Field[];
+    formulaFields: string[];
+}): string | null;
 
 interface FieldProposalRow {
     id: string;
@@ -635,33 +845,6 @@ declare function editorKindFor(field: Field): EditorKind;
  */
 declare function fieldTypeLabel(field: Field): string;
 
-/** The three behaviours that carry no parity type of their own. */
-type PlainFieldType = "text" | "long_text" | "number";
-/** What a person picks in the panel: one of the thirteen, or one of the three. */
-type PickableFieldType = ParityFieldType | PlainFieldType;
-interface FieldTypeChoice {
-    id: PickableFieldType;
-    /** The word on the menu. */
-    label: string;
-    /** One line, under the word, saying what it is FOR. Never what it is made of. */
-    explanation: string;
-    /** The heading it sits under, so sixteen choices read as four short lists. */
-    group: "Words" | "Numbers and dates" | "Choices and people" | "Worked out";
-}
-declare const FIELD_TYPE_CHOICES: FieldTypeChoice[];
-declare const FIELD_TYPE_GROUPS: FieldTypeChoice["group"][];
-declare function fieldTypeChoice(id: string): FieldTypeChoice | undefined;
-/** The three that are a plain behaviour rather than one of the thirteen. */
-declare function isPlainFieldType(id: string): id is PlainFieldType;
-/**
- * THE GUARD THIS FILE NEEDS, because the list it explains is generated.
- *
- * Returns the parity types the store ships that nothing here explains. The
- * suite asserts it is empty; a fourteenth type would otherwise reach the menu
- * with a blank line under it and nobody would notice until a person did.
- */
-declare function parityTypesWithNoExplanation(): string[];
-
 /** One Field of a package-owned Table, in the store's own words. */
 interface SystemFieldSpec {
     key: string;
@@ -902,54 +1085,22 @@ interface ProposalRowProps {
 }
 declare function ProposalRow({ change, outcome, onApply, onReject, readOnlyReason, onSettled, className, }: ProposalRowProps): react.JSX.Element;
 
-/** The three things that land in the queue. One word each, closed. */
+/** The three things that land in the queue, exactly as the door names them. */
 declare const ACTION_KINDS: readonly ["approval", "assignment", "proposal"];
-type ActionKind = (typeof ACTION_KINDS)[number];
-/** The package-owned Table every queued action is a record of. */
-declare const ACTION_TABLE: SystemTableSpec;
-/**
- * THE DECLARATIVE SPEC an agent writes. One `record_write` of this document puts
- * a decision in front of a person — there is no per-feature approval plumbing
- * anywhere in the platform.
- */
-interface QueuedActionSpec {
-    kind: ActionKind;
-    title: string;
-    why?: string | undefined;
-    assignee?: Uuid | null | undefined;
-    subjectTable?: Uuid | null | undefined;
-    subject?: Uuid | null | undefined;
-    /** For a proposal: the exact acts being asked for. */
-    changes?: ProposedChange[] | undefined;
-}
-interface QueuedAction extends QueuedActionSpec {
-    id: Uuid;
+type ActionKind = WorkInboxKind;
+interface ActionInboxProps {
     /**
-     * The version this row was read at. The read door answers documents and not
-     * versions, so a queue row carries null and settling it is the store's
-     * ordinary last-writer-wins write — the row's own `status` is what a second
-     * settler then sees.
+     * 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.
      */
-    version: number | null;
-    status: "open" | "accepted" | "rejected" | "refused";
-    answer: string | null;
-    at: string;
-}
-declare function actionDocument(spec: QueuedActionSpec): Record<string, unknown>;
-interface ActionInboxProps {
-    /** Narrow the queue to one table's actions. Left out, it is everything waiting. */
     tableId?: Uuid | null | undefined;
-    /** Show settled actions too. The default is what is still waiting. */
+    /** Show decided rows too. The default is what is still waiting. */
     includeSettled?: boolean | undefined;
-    /**
-     * COMPLETE DECLARATIVE SPECS an agent wrote. Any of these the queue does not
-     * already hold (by title) is filed as a record on first load.
-     */
-    seed?: QueuedActionSpec[] | undefined;
     onOpenRecord?: ((recordId: Uuid, tableId: Uuid) => void) | undefined;
     className?: string | undefined;
 }
-declare function ActionInbox({ tableId, includeSettled, seed, onOpenRecord, className }: ActionInboxProps): react.JSX.Element;
+declare function ActionInbox({ tableId, includeSettled, onOpenRecord, className }: ActionInboxProps): react.JSX.Element;
 
 interface HistoryPanelProps {
     tableId: Uuid;
@@ -1214,15 +1365,48 @@ interface DashboardCanvasProps {
 }
 declare function DashboardCanvas({ tableId, seed, activeDashboardId, className }: DashboardCanvasProps): react.JSX.Element;
 
+interface FormsPanelProps {
+    tableId: Uuid;
+    className?: string | undefined;
+}
+declare function FormsPanel({ tableId, className }: FormsPanelProps): react.JSX.Element;
+
+/** What the public arm's `onSubmit` answers. A refusal carries the door's words. */
+type FormSubmitOutcome = {
+    ok: true;
+    message?: string | null;
+    recordId?: Uuid | null;
+} | {
+    ok: false;
+    message: string;
+};
 interface FormRunnerProps {
     /** The complete spec. An agent wrote it; `FormBuilder` saved it; this runs it. */
     form: FormSpec | SavedForm;
+    /**
+     * PUBLIC ARM — the subject Table's Fields, already resolved by the server
+     * through `custom.form_public`. Given together with `onSubmit`, this component
+     * mounts no store client at all and the browser never touches the store.
+     */
+    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 — 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;
     /** Preview mode answers the questions but writes nothing, and says so. */
     preview?: boolean | undefined;
-    onSubmitted?: ((recordId: Uuid) => void) | undefined;
+    onSubmitted?: ((recordId: Uuid | null) => void) | undefined;
     className?: string | undefined;
 }
-declare function FormRunner({ form, preview, onSubmitted, className }: FormRunnerProps): react.JSX.Element;
+/**
+ * THE ONE ENTRY POINT. It picks the arm and nothing else: a caller that brought
+ * the Fields and a place to send the answers gets the stage on its own, and
+ * everybody else gets the connected half, which reads both from the store.
+ */
+declare function FormRunner(props: FormRunnerProps): react.JSX.Element;
 
 /** THE COMPLETE DECLARATIVE SPEC — one object, one `record_write`, a whole checklist. */
 interface ChecklistSpec {
@@ -1272,7 +1456,8 @@ interface BookingSlotsProps {
     };
     /** How long a hold lasts before the store lets the slot go. Default 15 minutes. */
     holdFor?: string;
-    onBooked?: ((recordId: Uuid) => void) | undefined;
+    /** `null` when the answer was HELD rather than written — see the runner's own note. */
+    onBooked?: ((recordId: Uuid | null) => void) | undefined;
     className?: string | undefined;
 }
 declare function BookingSlots({ tableId, form, availability, holdFor, onBooked, className, }: BookingSlotsProps): react.JSX.Element;
@@ -1347,12 +1532,18 @@ declare function useEmbedHandshake(args: {
 };
 
 declare const STORE_DECIDES_REASON: string;
-declare const KERNEL_REASON: string;
+
 /**
- * The rights answer for a host whose authority IS the record store's doors.
- * Offers the control; the store refuses with its own sentence if it must.
+ * DEPRECATED, and kept only so a host that imported it still compiles.
+ *
+ * It used to answer yes to everything for every non-kernel table. It cannot
+ * answer honestly at all, because the honest answer needs a door call and this
+ * signature is synchronous — which is exactly why the guess was here. Binding
+ * it now would be binding a port that OVERRIDES the store's real answer, so it
+ * returns the not-yet-answered set and every caller should simply stop passing
+ * a `rights` port: unbound is the honest path (`useTableRights`).
  */
-declare function storeDecidesRights(table: Table): TableRights;
+declare function storeDecidesRights(_table: Table): TableRights;
 interface RecordsMountProps {
     /** The store config: the host's session-carrying client, the actor, the organization. */
     config: RecordsConfig;
@@ -1541,6 +1732,14 @@ interface ShareControlProps {
     subjectId: Uuid$1;
     /** What to call it in the dialog's title. */
     name?: string | undefined;
+    /**
+     * Whether this person may pass this on — `custom.share_grant` asks for Admin
+     * ON THE THING. A caller that already holds the answer (a table screen has
+     * the table's rights in its hand) passes it; left out, this asks the store
+     * itself for the subject named above. Either way it is an ANSWER and never an
+     * assumption, which is the whole of this lane.
+     */
+    may?: boolean | undefined;
     size?: "sm" | "default" | undefined;
     variant?: "ghost" | "outline" | "default" | undefined;
     className?: string | undefined;
@@ -1549,6 +1748,6 @@ interface ShareControlProps {
 declare function useCanShare(): boolean;
 /** Why there is no Share button here, for anything that asks. */
 declare function shareUnavailableReason(): string;
-declare function ShareControl({ kind, organizationId, subjectId, name, size, variant, className, }: ShareControlProps): ReactNode;
+declare function ShareControl({ kind, organizationId, subjectId, name, may, size, variant, className, }: ShareControlProps): ReactNode;
 
-export { ACTION_KINDS, ACTION_TABLE, ActionInbox, type ActionInboxProps, type ActionKind, BookingSlots, type BookingSlotsProps, CAPTURE_MODES, CHART_KINDS, CHART_KIND_LABEL, CHART_NEEDS, CHECKLIST_TABLE, COMMENT_TABLE, type CaptureMode, type CaptureQueuePort, CaptureSheet, type CaptureSheetProps, type CellAddress, type CellRefusal, type CellState, ChartBlock, type ChartBlockProps, type ChartKind, type ChartSpec, ChecklistRunner, type ChecklistRunnerProps, type ChecklistSpec, type ChecklistStepSpec, CommentThread, type CommentThreadProps, CustomFieldsSection, type CustomFieldsSectionProps, DASHBOARD_TABLE, DEFAULT_FIELDS, DEFAULT_VIEW_NAME, DashboardCanvas, type DashboardCanvasProps, type DashboardSpec, type DeclareResult, DocRender, type DocRenderProps, DocTemplate, type DocTemplateProps, type DocTemplateSpec, type EditorKind, EmbedFrame, type EmbedFrameProps, type EnrichAsk, type EnrichOutcome, EnrichPanel, type EnrichPanelProps, ExportMenu, type ExportMenuProps, FIELD_TYPE_CHOICES, FIELD_TYPE_GROUPS, FORM_FLOWS, FORM_TABLE, FieldControl, FieldEditor, type FieldEditorControlProps, type FieldEditorProps, FieldLabel, type FieldProposalRow, type FieldTypeChoice, FormBuilder, type FormBuilderProps, type FormFlow, type FormQuestionSpec, FormRunner, type FormRunnerProps, type FormSpec, type FormTheme, Grid, GridCell, type GridEditing, type GridProps, HistoryPanel, type HistoryPanelProps, IN_MEMORY_QUEUE_REASON, ImportWizard, type ImportWizardProps, KERNEL_REASON, LANE_EMPTY, LANE_TITLE, LAYOUT_FIELD_KIND, LAYOUT_LABEL, LAYOUT_NEEDS, LAYOUT_NO_FIELD, type LabelLookup, NO_CHAT_REASON, NO_ENRICH_REASON, NO_MEMBERS_REASON, NO_RIGHTS, NO_SAVED_VIEWS_REASON, NO_SHARE_REASON, NO_UPLOAD_REASON, type NewFieldSpec, type NewTableSpec, NotifyRuleEditor, type NotifyRuleEditorProps, type NotifyRuleSpec, type OrganizationMember, PARITY_LABEL, PARITY_MADE_OF, Peek, type PeekProps, type PendingCapture, PersonPicker, type PersonPickerProps, type PickableFieldType, type PlainFieldType, PortalShell, type PortalShellProps, type ProposalOutcome, ProposalRow, type ProposalRowProps, type ProposedChange, ProvenanceBadge, PublicViewPage, type PublicViewPageProps, type QueuedAction, type QueuedActionSpec, RecordChat, type RecordChatContext, type RecordChatEntry, type RecordChatProps, type RecordChatWithheld, RecordChip, RecordForm, type RecordFormProps, RecordLabelProvider, RecordValue, RecordsMount, type RecordsMountProps, type RecordsUiHost, RecordsUiProvider, RefusalLine, RefusalNotice, RelationPicker, type RelationPickerProps, SERIES_COLORS, STORE_DECIDES_REASON, type SavedDashboard, type SavedForm, type SavedView, type SavedViewSpec, ShareControl, type ShareControlProps, type ShareSubject, SignBlock, type SignBlockProps, type SystemFieldSpec, type SystemTableSpec, TABLE_LANES, TABLE_NOT_REACHABLE, type TableLane, TablePage, type TablePageProps, type TableRights, TableSettings, type TableSettingsProps, TablesHome, type TablesHomeProps, type TrackedVersion, type UseSystemTableState, VIEW_LAYOUTS, VIEW_TABLE, ViewBar, type ViewBarProps, type ViewLayout, type ViewSort, ViewSwitcher, type ViewSwitcherProps, actionDocument, addFields, bodyForReading, bodyFromKeys, columnForField, dashboardDocument, dashboardFromRecord, declareTable, editorKindFor, ensureSystemTable, envelopeFor, fieldIsEditable, fieldName, fieldToken, fieldTypeChoice, fieldTypeLabel, formDocument, formFromRecord, groupLabel, humanize, idsOf, isId, isPlainFieldType, isSignatureField, keyFor, laneFor, memberName, parityTypesWithNoExplanation, personActor, personRecordForMember, pointsAtRecords, recordName, recordsDataSource, renderValue, rowName, scalarText, shareUnavailableReason, storeDecidesRights, submissionStamp, tableName, tokenFor, useCanShare, useEmbedHandshake, useGridEditing, useRecordLabels, useRecordsUi, useSystemTable, useTableRights, useViewRecords, viewDocument, viewFromRecord, viewPatchDocument };
+export { ACTION_KINDS, ActionInbox, type ActionInboxProps, type ActionKind, BookingSlots, type BookingSlotsProps, CAPTURE_MODES, CHART_KINDS, CHART_KIND_LABEL, CHART_NEEDS, CHECKLIST_TABLE, COMMENT_TABLE, type Capability, type CaptureMode, type CaptureQueuePort, CaptureSheet, type CaptureSheetProps, type CellAddress, type CellRefusal, type CellState, ChartBlock, type ChartBlockProps, type ChartKind, type ChartSpec, ChecklistRunner, type ChecklistRunnerProps, type ChecklistSpec, type ChecklistStepSpec, CommentThread, type CommentThreadProps, CustomFieldsSection, type CustomFieldsSectionProps, DASHBOARD_TABLE, DEFAULT_FIELDS, DEFAULT_VIEW_NAME, DashboardCanvas, type DashboardCanvasProps, type DashboardSpec, type DeclareResult, DocRender, type DocRenderProps, DocTemplate, type DocTemplateProps, type DocTemplateSpec, type EditorKind, EmbedFrame, type EmbedFrameProps, type EnrichAsk, type EnrichOutcome, EnrichPanel, type EnrichPanelProps, ExportMenu, type ExportMenuProps, FIELD_TYPE_CHOICES, FIELD_TYPE_GROUPS, FORM_FLOWS, FORM_TABLE, FieldControl, FieldEditor, type FieldEditorControlProps, type FieldEditorProps, FieldLabel, type FieldProposalRow, type FieldTypeChoice, FormBuilder, type FormBuilderProps, type FormFlow, type FormQuestionSpec, FormRunner, type FormRunnerProps, type FormSpec, type FormTheme, FormsPanel, type FormsPanelProps, Grid, GridCell, type GridEditing, type GridProps, HistoryPanel, type HistoryPanelProps, 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, MACHINE_IDENTITY, NOT_ANSWERED_YET, NO_CHAT_REASON, NO_ENRICH_REASON, NO_MEMBERS_REASON, NO_RIGHTS, NO_SAVED_VIEWS_REASON, NO_SHARE_REASON, NO_UPLOAD_REASON, type NewFieldSpec, type NewTableSpec, NotifyRuleEditor, type NotifyRuleEditorProps, type NotifyRuleSpec, type OrganizationMember, PARITY_LABEL, PARITY_MADE_OF, Peek, type PeekProps, type PendingCapture, PersonPicker, type PersonPickerProps, type PickableFieldType, type PlainFieldType, type PlainRefusal, PortalShell, type PortalShellProps, type ProposalOutcome, ProposalRow, type ProposalRowProps, type ProposedChange, ProvenanceBadge, PublicViewPage, type PublicViewPageProps, RecordChat, type RecordChatContext, type RecordChatEntry, type RecordChatProps, type RecordChatWithheld, RecordChip, RecordForm, type RecordFormProps, RecordLabelProvider, RecordValue, RecordsMount, type RecordsMountProps, type RecordsUiHost, RecordsUiProvider, RefusalLine, RefusalNotice, RelationPicker, type RelationPickerProps, SERIES_COLORS, STORE_DECIDES_REASON, type SavedDashboard, type SavedForm, type SavedView, type SavedViewSpec, ShareControl, type ShareControlProps, type ShareSubject, SignBlock, type SignBlockProps, type SystemFieldSpec, type SystemTableSpec, TABLE_LANES, TABLE_NOT_REACHABLE, type TableLane, TablePage, type TablePageProps, type TableRights, TableSettings, type TableSettingsProps, TablesHome, type TablesHomeProps, type TrackedVersion, type UseSystemTableState, VIEW_LAYOUTS, VIEW_TABLE, ViewBar, type ViewBarProps, type ViewLayout, type ViewSort, ViewSwitcher, type ViewSwitcherProps, type WhatYouMayDo, addFields, bodyForReading, bodyFromKeys, columnForField, dashboardDocument, dashboardFromRecord, declareTable, editorKindFor, ensureSystemTable, envelopeFor, fieldIsEditable, fieldName, fieldToken, fieldTypeChoice, fieldTypeLabel, formDocument, formFromRecord, groupLabel, hintForAPerson, hintIsMachineIdentity, humanize, idsOf, isId, isMachineIdentity, isPlainFieldType, isSignatureField, keyFor, laneFor, machineIdentityIn, memberName, parityTypesWithNoExplanation, personActor, personRecordForMember, pointsAtRecords, recordName, recordsDataSource, refusalForAPerson, refusalLineForAPerson, renderValue, rowName, scalarText, shareUnavailableReason, storeDecidesRights, submissionStamp, tableName, tableRightsAt, tokenFor, useCanShare, useEmbedHandshake, useGridEditing, useRecordLabels, useRecordRights, useRecordsUi, useRowRights, useSystemTable, useTableRights, useViewRecords, viewDocument, viewFromRecord, viewPatchDocument, whatIsMissing, whatYouMayDo, whatYouMayDoWithTable };