@object-ui/plugin-form 17.6.0 → 18.0.0

package/dist/WizardForm.d.ts

@@ -1,40 +1,114 @@
 import { default as React } from 'react';
-import { DataSource } from '@object-ui/types';
-import { SubmitBehavior } from './successBehavior';
-import { FormSectionConfig } from './TabbedForm';
+import { FormField, DataSource, ObjectFormSchema, ObjectFormSection } from '@object-ui/types';
+import { SubmitBehavior } from './successBehavior.js';
 /**
- * What the submitter is told when a DECLARED `navigateOnSuccess` produced no
- * destination — objectui#5034 point 2.
+ * A wizard STEP — the wizard's OWN authored group shape (objectui#6237).
  *
- * The write succeeded, so this rides on the success toast as a note rather than
- * becoming an error or a blocking panel: turning a successful write into an
- * error state would be a worse lie than the silence it replaces. What was
- * missing is one fact, and only one: the navigation the author declared did not
- * happen. Before this, the toast was byte-identical to the toast a form with no
- * `navigateOnSuccess` at all produces, so an author who mistyped the destination
- * — or whose record carried no usable id — saw a form that looked entirely
- * healthy and had silently stopped honouring a key they wrote.
+ * ## Why this is declared here rather than derived from the tabbed layout
  *
- * Maintainer ruling, 2026-08-17: "A refused declared navigation is surfaced: the
- * success toast carries a note that the declared navigation was not performed —
- * never indistinguishable from the no-key case."
+ * It used to be `Omit<FormSectionConfig, 'visibleWhen'>`, which subtracted the
+ * predicate slot from `TabbedForm`'s section type. That closed the hole for the
+ * ONE key it named and left the mechanism wide open: `FormSectionConfig` is the
+ * predicate-CARRYING type, so every key added to it lands here by default and
+ * the author has to remember to widen the `Omit`. The defect the 2026-08-30
+ * ruling closes is the SILENCE — "在共享 `FormSectionConfig` 上声明 `visibleWhen`
+ * 会**静默**给 WizardForm 的 step 也发一个谓词槽而那侧无实现" — and a subtractive
+ * derivation reproduces that silence for the next key in the same family
+ * (`readonlyWhen` / `requiredWhen`, both already this repo's field-level
+ * predicate vocabulary). Declaring the step shape independently flips the
+ * derivation from subtractive to additive: a key reaches a wizard step only
+ * because someone wrote it here, on the type whose renderer has to honour it.
  *
- * The note names no REASON on purpose. `resolveSuccessNavigate` answers null for
- * two different causes (no usable id on the written record; a destination the
- * same-origin guard refused) and returns no discriminant, so a reason in this
- * copy could only be re-derived by reimplementing that helper's internals at the
- * call site — where it would drift from the helper, and would additionally bake
- * today's acceptance rule into user-visible prose while objectui#5548 is still
- * open on exactly that rule. The diagnosable detail — the template the author
- * actually wrote — goes to `console.warn` at each call site instead.
+ * This is also simply the house pattern. `SplitFormSectionConfig`,
+ * `ModalFormSectionConfig` and `DrawerFormSectionConfig` each declare their own
+ * group shape, each documents `className` / `gridClassName` in ITS layout's
+ * terms, and each declares `visibleWhen` only because its layout honours it
+ * (`SplitFormSectionConfig` even carries a key — `pane` — that exists nowhere
+ * else). The wizard borrowing the tabbed layout's interface was the exception,
+ * and it cost real accuracy: a wizard author reading the shared type was told
+ * `name` is "used as tab value", `label` is "used as tab trigger text", and
+ * `className` is "Unused in the tabbed layout" — while this renderer uses all
+ * three, `className` at the step container (`FormSectionContainer` below).
  *
- * Lives here rather than in `successBehavior.ts` (the natural home, but read-only
- * for this card) and is imported BY `ObjectForm`, which is the dependency
- * direction that already exists — ObjectForm imports WizardForm, never the
- * reverse. Single-sourced so a wizard and a flat form cannot tell a submitter
- * two different things about one refusal; a test pins that they do not.
+ * ## ⛔ Why there is no predicate slot, and why that is not an oversight
+ *
+ * A step predicate is not a port of the tab predicate, it is a different
+ * contract. Steps are wizard component state keyed by section INDEX, only the
+ * current step is mounted (unmounted-ness is every other step's NORMAL state,
+ * which is why the final gate re-checks the whole declared field set), and the
+ * predicate would read `formData` — which merges only at step boundaries. So a
+ * step predicate is structurally STEP-BOUNDARY reactive where a tab's is ruled
+ * LIVE-RECORD reactive: one keyword, two different "when". It also needs
+ * machinery none of which is inherited — navigation policy for skipping hidden
+ * steps, the indicator, `isLastStep`, the "Step X of Y" denominator, index
+ * stability while hiding is live, re-selection when the CURRENT step hides, and
+ * a final-gate exclusion for a hidden step's required fields.
+ *
+ * Declaring the key on a type this renderer ignores would make it WRITABLE on a
+ * step — precisely the declared-but-unenforced shape this card family exists to
+ * close. Its absence means TypeScript rejects the key on a wizard step literal,
+ * which is where an author (or an agent authoring metadata) finds out.
+ * `ObjectForm` additionally reports the gap at runtime for a section predicate
+ * arriving on the wizard route, since untyped JSON reaches it too. Both halves
+ * are pinned in `__tests__/tabbedFormSectionPredicate-6237.test.tsx`, including
+ * a FAMILY-level pin that fails the build if any `*When` key ever appears here,
+ * not just the one this card was about.
+ *
+ * Since the objectstack#13622 ruling (2026-08-31), the boundary is also an
+ * AUTHOR-door refusal: `@objectstack/spec` refuses `visibleWhen` (and
+ * `collapsible`/`collapsed: true`) on a wizard step at parse, so authored
+ * form-view metadata carrying them never reaches this renderer at all. This
+ * type and the runtime report remain the guard for what the spec door cannot
+ * see — programmatic SDUI callers and metadata published before the
+ * tightening. The step-predicate FUTURE contract stays tracked in
+ * objectui#6237; the spec-side refusal is its single opening point.
+ *
+ * ⚠️ This changes nothing that used to work. The published surface is exactly
+ * the key set `WizardStepConfig` already had — the derivation changed, not the
+ * type — and `visibleWhen` was already a type error on a wizard step literal.
  */
-export declare const NAVIGATE_ON_SUCCESS_REFUSED_NOTE: string;
+export interface WizardStepConfig {
+    /**
+     * Step identifier. Used as the step's test handle
+     * (`data-testid="wizard-step:<name>"`) and, with `label`, as what the
+     * indicator names; falls back to the step INDEX when absent.
+     */
+    name?: string;
+    /**
+     * Step label — the text the step indicator shows.
+     * Falls back to `Step <n>`, in the session locale (`wizard.stepFallback`).
+     */
+    label?: string;
+    /**
+     * Step description, rendered under the step heading.
+     */
+    description?: string;
+    /**
+     * How densely this step fills the grid (1–4). Outranked by the form view's
+     * own `columns` (spec `FormView.columns`), which sets the grid WIDTH.
+     * @default 1
+     */
+    columns?: 1 | 2 | 3 | 4;
+    /**
+     * The same three entry shapes as `ObjectFormSection.fields`, by reference:
+     * a field name, the form view's `{ field, … }` entry, or an inline
+     * `FormField` (objectui#11615).
+     */
+    fields: NonNullable<ObjectFormSection['fields']>;
+    /**
+     * Custom CSS class for this step's container.
+     *
+     * Honoured, unlike its tabbed counterpart: a wizard mounts ONE step at a
+     * time inside its own `FormSectionContainer`, so the step has a container to
+     * carry it.
+     */
+    className?: string;
+    /**
+     * Custom CSS class for this step's field grid (overrides the column classes).
+     */
+    gridClassName?: string;
+}
+export { NAVIGATE_ON_SUCCESS_REFUSED_NOTE } from './formChrome.js';
 export interface WizardFormSchema {
     type: 'object-form';
     formType: 'wizard';
@@ -47,13 +121,23 @@ export interface WizardFormSchema {
      */
     mode: 'create' | 'edit' | 'view';
     /**
-     * Record ID (for edit/view modes)
+     * Record ID (for edit/view modes). A string, per the one record-id rule on
+     * `DataSource` (objectui#9511) — `ObjectForm` builds this schema from the
+     * authorable `ObjectFormSchema.recordId`, which is a string, and `findOne`
+     * takes a string.
      */
-    recordId?: string | number;
+    recordId?: string;
     /**
      * Wizard step sections
      */
-    sections: FormSectionConfig[];
+    sections: WizardStepConfig[];
+    /**
+     * Inline field definitions (`object-form.customFields`). A member naming a
+     * field a section lists is that field's definition, as on every other
+     * `formType` (objectui#10254); `ObjectForm` hands the key over in its
+     * `{...schema}` spread.
+     */
+    customFields?: FormField[];
     /**
      * Allow navigation to any step (not just sequential).
      *
@@ -77,22 +161,26 @@ export interface WizardFormSchema {
      */
     showStepIndicator?: boolean;
     /**
-     * Text for Next button
+     * Text for Next button. Rendered as authored when set; otherwise the
+     * session locale's `common.next`.
      * @default 'Next'
      */
     nextText?: string;
     /**
-     * Text for Previous button
+     * Text for Previous button. Rendered as authored when set; otherwise the
+     * session locale's `wizard.back`.
      * @default 'Back'
      */
     prevText?: string;
     /**
-     * Submit button text (shown on last step)
+     * Submit button text (shown on last step). Rendered as authored when set;
+     * otherwise the session locale's `form.create` / `form.update`.
      */
     submitText?: string;
     /**
      * Declarative success toast text shown when no `onSuccess` handler is given
-     * (metadata pages cannot pass a function). Falls back to 'Created'/'Saved'.
+     * (metadata pages cannot pass a function). Falls back to the session
+     * locale's `form.created` / `form.saved` ('Created' / 'Saved' in English).
      * Ignored when `submitBehavior` is set.
      */
     successMessage?: string;
@@ -117,7 +205,8 @@ export interface WizardFormSchema {
      */
     showCancel?: boolean;
     /**
-     * Cancel button text
+     * Cancel button text. Rendered as authored when set; otherwise the session
+     * locale's `common.cancel`.
      */
     cancelText?: string;
     /**
@@ -132,6 +221,24 @@ export interface WizardFormSchema {
      * Read-only mode
      */
     readOnly?: boolean;
+    /**
+     * Override persistence — the seam a host uses to own the write. Declared as
+     * `ObjectFormSchema['submitHandler']` rather than restated, so this variant
+     * and the canonical key `ObjectForm` forwards can never drift apart.
+     * When supplied, the form validates and hands the collected values
+     * to this handler INSTEAD of calling `dataSource.create` /
+     * `dataSource.update`; the returned record is passed on to `onSuccess`.
+     * In `edit` mode, for a record this form read itself, it hands over what it
+     * would have written: the fields that differ from that read, or the full
+     * sanitized payload when nothing changed (objectui#10156, objectui#10563;
+     * the whole rule is on `ObjectFormSchema['submitHandler']`).
+     *
+     * `MasterDetailForm` supplies it to route the parent AND its child
+     * collections through one atomic `batchTransaction` (#2679 / ADR-0034
+     * item 4). A renderer that does not read it writes the parent on its own and
+     * escapes that transaction — objectui#6176.
+     */
+    submitHandler?: ObjectFormSchema['submitHandler'];
     /**
      * Callbacks
      */

package/dist/WizardForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WizardForm.d.ts","sourceRoot":"","sources":["../src/WizardForm.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH,OAAO,KAAyC,MAAM,OAAO,CAAC;AAC9D,OAAO,KAAK,EAAa,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAW9D,OAAO,EAA0B,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAQhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,gCAAgC,QAEN,CAAC;AAiBxC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE3B;;OAEG;IACH,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAE9B;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;+CAG2C;IAC3C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;iBAEa;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;OAIG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEpC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAEtB;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAwsBhD,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"WizardForm.d.ts","sourceRoot":"","sources":["../src/WizardForm.tsx"],"names":[],"mappings":"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"}

package/dist/autoLayout.d.ts

@@ -8,7 +8,7 @@ export declare function isWideFieldType(type: string): boolean;
  */
 export declare function isAutoGeneratedFieldType(type: string): boolean;
 /**
- * Infer the MAX column count from the field count (#2578). This is an UPPER
+ * Infer the MAX column count from the field count (objectstack-ai/objectstack#2578). This is an UPPER
  * BOUND — the actual column count at render time is decided by the CSS
  * container queries in {@link CONTAINER_GRID_COLS} against the form's REAL
  * width, so a narrow drawer stays 1–2 columns while the SAME form on a wide
@@ -25,12 +25,21 @@ export declare function isAutoGeneratedFieldType(type: string): boolean;
 export declare function inferColumns(fieldCount: number): number;
 /**
  * Resolve the effective colSpan (grid cells) a field occupies, given the form's
- * grid width and the section's desired column count (#2578).
+ * grid width and the section's desired column count (objectstack-ai/objectstack#2578).
  *
  * The column count is derived per surface (mobile 1 / modal 2 / page 3-4), so
  * the robust field-width primitive is the relative `span`, NOT an absolute
  * colSpan. Precedence:
  *   1. `span: 'full'`     → whole row (grid cells).
+ *
+ * ⚠️ «Whole row» is a claim about what RENDERS, and this function only returns
+ * a number. It is kept by the form renderer's `spanLadderFor`, which turns
+ * that number into one col-span class per container-query tier. Until
+ * `bd0995738` the renderer emitted a single class for the widest tier only,
+ * so this sentence was true of the return value and false on screen at every
+ * intermediate width. ⛔ A pin under this function cannot observe that — see
+ * `__tests__/spanFullTierLadder-9244.test.tsx` for the leg that can.
+ *
  *   2. legacy `colSpan`   → honoured but CLAMPED to the grid (never overflows).
  *   3. wide widget type   → whole row (textarea/markdown/… — the `span:'auto'` default).
  *   4. section density    → grid / sectionColumns, so `sectionColumns` fields fill a row.
@@ -41,7 +50,7 @@ export declare function inferColumns(fieldCount: number): number;
 export declare function resolveColSpan(field: FormField, gridColumns: number, sectionColumns?: number): number;
 /**
  * Apply the resolved colSpan to each field so the form's CSS grid lays them out
- * at the intended density. Span-aware and clamping (#2578); wide fields still
+ * at the intended density. Span-aware and clamping (objectstack-ai/objectstack#2578); wide fields still
  * span the full row (the `span: 'auto'` default). `section-divider` rows are
  * left untouched (they carry their own full-row span).
  *
@@ -94,6 +103,96 @@ export declare function filterAutoGeneratedFields(fields: FormField[], objectSch
 export declare const CONTAINER_GRID_COLS: Record<number, string | undefined>;
 /** Clamp an arbitrary column count into the 1–4 keys of {@link CONTAINER_GRID_COLS}. */
 export declare function containerGridColsFor(columns: number | undefined): string | undefined;
+/**
+ * The field grid of a sectioned form whose sections do not all fit one grid
+ * (objectui#12548): one column below `@md`, twelve tracks from `@md` up.
+ *
+ * Twelve is the least count every authored section density divides
+ * (`@objectstack/spec` `FormSectionSchema.columns` is `1 | 2 | 3 | 4`), so in
+ * this grid a field's colSpan is in TWELFTHS of the row: 12 / 6 / 4 / 3 for a
+ * 1 / 2 / 3 / 4-column section. The form renderer draws a twelfths colSpan as
+ * one class per tier, keeping each density's step ladder from
+ * {@link CONTAINER_GRID_COLS} (at most two per row at `@md`, three at `@2xl`,
+ * four at `@4xl`); its table is `TWELVE_TRACK_SPAN_CLASS` in
+ * `@object-ui/components`' form renderer.
+ *
+ * ⛔ A literal, never assembled: Tailwind's scanner reads source text.
+ */
+export declare const TWELVE_TRACK_GRID_COLS = "grid gap-4 grid-cols-1 @md:grid-cols-12";
+/**
+ * How many fields per row a section draws where neither it nor its form
+ * declares `columns` (objectui#12592): two from the container's `@md` tier up,
+ * one below it, so a phone keeps its single column.
+ *
+ * An undeclared density is the renderer's choice by available width, and a
+ * declared one — `1` included — is drawn as written (the section-`columns`
+ * fork on objectui#12521, ruled 6204264665; `@objectstack/spec` dropped
+ * `FormSectionSchema.columns`' `default(1)` in objectstack-ai/objectstack#23740,
+ * so an undeclared section reaches every host). The container query makes
+ * "available width" literal: the same section draws one per row in a narrow
+ * drawer or on a phone, and two in a dialog or a page.
+ */
+export declare const UNDECLARED_SECTION_COLUMNS = 2;
+/**
+ * One section's fields per row: its declared `columns` as written, else the
+ * form's declared `columns` (what an undeclared section always filled), else
+ * {@link UNDECLARED_SECTION_COLUMNS}.
+ */
+export declare function sectionColumnsFor(sectionColumns: unknown, formColumns: unknown): number;
+/**
+ * The ONE grid width of a sectioned form: the form's declared `columns`, else
+ * the widest section's {@link sectionColumnsFor}.
+ *
+ * @param formColumns    The form's DECLARED `columns` (`undefined` when none).
+ * @param sectionColumns The DECLARED `columns` of every section the form draws.
+ */
+export declare function sectionedFormColumns(formColumns: unknown, sectionColumns: ReadonlyArray<unknown>): 1 | 2 | 3 | 4;
+/** The field grid a sectioned host draws, and how it lays out one section's fields on it. */
+export interface SectionedGridLayout {
+    /** The form's grid width in the 1–4 vocabulary (`FormSchema.columns`). */
+    columns: 1 | 2 | 3 | 4;
+    /** The field container's grid classes; `undefined` for a one-column form. */
+    fieldContainerClass: string | undefined;
+    /** Lay one section's fields out at that section's DECLARED `columns` (`undefined` when none). */
+    layOut: (fields: FormField[], sectionColumns?: unknown) => FormField[];
+}
+/**
+ * The ONE layout rule of a sectioned form — `ModalForm`, `ObjectForm`,
+ * `SplitForm`, `TabbedForm` and `WizardForm` all call it (objectui#12548).
+ *
+ * Every section shares the form's single field grid (one form, one
+ * react-hook-form instance — #2153/#2959), and every authored section must
+ * still draw its OWN `columns` count per row: `FormSectionSchema.columns` is a
+ * per-section count, whatever the other sections declare.
+ *
+ * - When every section's count is 1 or the grid's own width, the grid is
+ *   {@link CONTAINER_GRID_COLS}' and the spans are {@link applyAutoColSpan}'s,
+ *   byte for byte what a single-density form always drew: on that grid a
+ *   one-column section's fields take the row and a full-width section's take
+ *   one cell each, which is exactly their count.
+ * - Otherwise a section's count does not fit that grid at some tier — a
+ *   `columns: 2` section on a 3-wide grid spanned 2 of 3 cells, ONE field per
+ *   row, and a `columns: 3` section on a 4-wide grid spanned 1 cell, FOUR per
+ *   row (`Math.round(grid / sectionColumns)`). The grid becomes
+ *   {@link TWELVE_TRACK_GRID_COLS} and each field spans twelfths of the row:
+ *     1. `span: 'full'`, or a wide widget type → 12, the whole row;
+ *     2. an authored `colSpan` → that many of its SECTION's columns, clamped
+ *        to them (it keeps winning over the density);
+ *     3. otherwise → 12 / the section's columns.
+ *
+ * A section's count is clamped to the grid width, as it always was: the form
+ * view's own `columns` outranks how a section fills it.
+ *
+ * Every host hands it what the AUTHOR wrote, never a count it resolved itself
+ * (objectui#12592): an undeclared section and an undeclared form resolve here,
+ * through {@link sectionColumnsFor} and {@link sectionedFormColumns}, so a
+ * section that declares nothing draws {@link UNDECLARED_SECTION_COLUMNS} per
+ * row in the dialog and on every page host alike.
+ *
+ * @param formColumns    The form's DECLARED `columns` (`undefined` when none).
+ * @param sectionColumns The DECLARED `columns` of every section the form draws.
+ */
+export declare function sectionedGridLayout(formColumns: unknown, sectionColumns: ReadonlyArray<unknown>): SectionedGridLayout;
 /**
  * Build the layout-related props for a *section's* inner form (`SchemaRenderer`).
  *
@@ -114,13 +213,19 @@ export declare function sectionFormLayout(fields: FormField[], columns: number |
     fieldContainerClass?: string;
 };
 /**
- * Infer an appropriate modal size based on the number of layout columns.
- * Used to auto-upgrade the modal width when auto-layout detects multi-column forms.
+ * Infer the modal size for a dialog whose author declared none, from the
+ * number of layout columns it will show.
  *
  * Mapping:
- * - 1 column   → 'default' (max-w-lg)
- * - 2 columns  → 'xl'      (max-w-5xl)
- * - 3+ columns → 'full'    (max-w-[95vw])
+ * - 0–1 column → 'lg' (max-w-2xl)
+ * - 2+ columns → 'xl' (max-w-5xl)
+ *
+ * ⛔ Never 'full' (objectui#12521): a derived dialog is bounded, and its width
+ * follows its content (the objectui#12080 ruling). 'full' (95vw) stays
+ * available to an author who declares `modalSize: 'full'`. The bound changes
+ * no grid class an authored layout carries: the field grid's tiers are
+ * container queries, so an authored section draws as many of its columns as
+ * the bounded dialog's width admits.
  */
 export declare function inferModalSize(columns: number): 'sm' | 'default' | 'lg' | 'xl' | 'full';
 /**

package/dist/autoLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoLayout.d.ts","sourceRoot":"","sources":["../src/autoLayout.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAqElD;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAKvD;AAOD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAmBR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EAAE,EACnB,WAAW,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,GACtB,SAAS,EAAE,CAab;AAmCD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EAAE,EACnB,YAAY,CAAC,EAAE,GAAG,GACjB,SAAS,EAAE,CAgBb;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,EAAE,EACnB,YAAY,CAAC,EAAE,GAAG,GACjB,SAAS,EAAE,CAmBb;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,EAAE,EACnB,YAAY,CAAC,EAAE,GAAG,GACjB,SAAS,EAAE,CAOb;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAKlE,CAAC;AAEF,wFAAwF;AACxF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAGpF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EAAE,EACnB,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B;IAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,CASxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,MAAM,CAIvF;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,SAAS,EAAE,EACvB,YAAY,EAAE,GAAG,EACjB,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB;IAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CA6BtD"}
+{"version":3,"file":"autoLayout.d.ts","sourceRoot":"","sources":["../src/autoLayout.ts"],"names":[],"mappings":"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"}

package/dist/closedAffordanceNotice.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { ClosedFormAffordance } from './fieldWriteGate.js';
+export interface ClosedAffordanceNoticeProps {
+    /** `closedFormAffordance`'s answer for the form; nothing renders when `undefined`. */
+    affordance: ClosedFormAffordance | undefined;
+    /** The form's object. Its label is resolved the way the console resolves it. */
+    objectName: string;
+    /** The object schema the form resolved; its `label` is the fallback label. */
+    objectSchema: {
+        label?: unknown;
+    } | null | undefined;
+}
+export declare function ClosedAffordanceNotice({ affordance, objectName, objectSchema, }: ClosedAffordanceNoticeProps): React.ReactElement | null;
+//# sourceMappingURL=closedAffordanceNotice.d.ts.map

package/dist/closedAffordanceNotice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closedAffordanceNotice.d.ts","sourceRoot":"","sources":["../src/closedAffordanceNotice.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAwC7D,MAAM,WAAW,2BAA2B;IAC1C,sFAAsF;IACtF,UAAU,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC7C,gFAAgF;IAChF,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,YAAY,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC;CACtD;AAED,wBAAgB,sBAAsB,CAAC,EACrC,UAAU,EACV,UAAU,EACV,YAAY,GACb,EAAE,2BAA2B,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CA4BzD"}

package/dist/customFieldsMerge.d.ts

@@ -0,0 +1,29 @@
+import { FormField } from '@object-ui/types';
+/**
+ * The member that supplies the definition of the field called `name`, or
+ * `undefined` when no member names it — the override direction's precedence,
+ * spelled once. The first member naming the field wins, and an EMPTY
+ * `customFields` supplies nothing.
+ *
+ * Shared by the two producers of a runtime field from a name: the flat list
+ * (`mergeCustomFields` below, the default arm's pool and the drawer / modal
+ * no-sections path) and a section body (`normalizeSectionField` in
+ * `sectionFields.ts`, where the member is a section entry's BASE definition).
+ * objectui#10254: the drawer and modal section bodies used to regenerate every
+ * named field from the object schema, so a member the default arm drew was
+ * dropped on those two arms.
+ */
+export declare function findCustomFieldMember(customFields: readonly FormField[] | null | undefined, name: string): FormField | undefined;
+/**
+ * Resolve the runtime field list for `names`, with `customFields` merged over
+ * the fields `generate` produces.
+ *
+ * @param names        The field names the form draws, in render order.
+ * @param customFields The authored members (`schema.customFields`).
+ * @param generate     Builds the generated field for `names[index]`, or
+ *                     returns `undefined` when the object declares no such
+ *                     field (the name is then skipped unless a member names it).
+ * @param normalize    Applied to every member before it is drawn.
+ */
+export declare function mergeCustomFields(names: readonly string[], customFields: readonly FormField[] | null | undefined, generate: (name: string, index: number) => FormField | undefined, normalize?: (member: FormField) => FormField): FormField[];
+//# sourceMappingURL=customFieldsMerge.d.ts.map

package/dist/customFieldsMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customFieldsMerge.d.ts","sourceRoot":"","sources":["../src/customFieldsMerge.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,GAAG,SAAS,EACrD,IAAI,EAAE,MAAM,GACX,SAAS,GAAG,SAAS,CAGvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,YAAY,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,GAAG,SAAS,EACrD,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,EAChE,SAAS,GAAE,CAAC,MAAM,EAAE,SAAS,KAAK,SAA8B,GAC/D,SAAS,EAAE,CAyBb"}

package/dist/deriveMasterDetail.d.ts

@@ -1,6 +1,25 @@
-import { GridColumn } from '@object-ui/fields';
-/** Minimal shape of an object schema as returned by `DataSource.getObjectSchema`. */
-export interface ObjectSchemaLike {
+import { BooleanValueLabel, GridColumn } from '@object-ui/fields';
+/**
+ * Minimal shape of a MASTER-DETAIL CHILD object's schema, as returned by
+ * `DataSource.getObjectSchema` — the `childSchema` parameter of every derive
+ * function below (objectui#7324).
+ *
+ * Named for the child because that is the only thing it is ever used for, and
+ * because `schemaDefaults.ts` holds a DIFFERENT shape under what used to be
+ * the same name (`FieldDefaultsSchemaLike` now). The two are not
+ * interchangeable: this one's field values are `any` — these functions read a
+ * field's `type`, `label`, `options`, `hidden`, `reference` and more — while
+ * the defaults one pins the four members that rule reads. Publishing both
+ * under one name would have put a name on the package surface that already
+ * meant something else two files over.
+ *
+ * NOT `@object-ui/types`' `ObjectSchemaMetadata`: that type requires `name`
+ * and requires a `type` on every field, so the partial schemas these
+ * functions are handed (and every fixture that exercises them) would stop
+ * compiling. This is a deliberately structural parameter type — pass the
+ * object document your data source serves.
+ */
+export interface ChildObjectSchemaLike {
     name?: string;
     fields?: Record<string, any>;
 }
@@ -11,25 +30,31 @@ export declare function fieldTypeToColumnType(type: string | undefined): GridCol
  * master_detail/lookup field whose `reference` is the parent object. Prefer
  * `master_detail` over `lookup` when both exist.
  */
-export declare function findRelationshipField(childSchema: ObjectSchemaLike | undefined, parentObjectName: string): string | undefined;
+export declare function findRelationshipField(childSchema: ChildObjectSchemaLike | undefined, parentObjectName: string): string | undefined;
 /**
- * Default-visible column budget for an auto-derived inline grid. An inline
- * line-item grid lives in a constrained width (modal / detail card), so we show
- * a focused set by default and mark the rest `defaultHidden` — they are NOT
- * dropped: the grid's column chooser reveals them on demand (the mainstream
- * "personalize columns" pattern; cf. Odoo `optional` / Salesforce column
- * personalization). Required columns are always visible. Authors can override
- * with explicit `columns` / `inlineColumns` (no curation), or `maxColumns: 0`.
+ * Derive editable grid columns from a child object's fields — the grid an
+ * inline master-detail collection draws when its author listed no columns.
+ *
+ * WHICH columns, in what order, and which are `defaultHidden`, is
+ * `@objectstack/spec`'s rule, `deriveInlineGridColumns` (objectui#11345): it
+ * skips system / audit fields, sort-position fields, fields flagged `system`,
+ * `readonly` or `hidden`, non-editable types, the back-reference FK to the
+ * parent and any `exclude`d name, and keeps every other field. Past the
+ * visible budget ({@link DEFAULT_MAX_INLINE_GRID_COLUMNS}, the spec's) the
+ * overflow is flagged `defaultHidden` — collapsed into the grid's column
+ * chooser, never dropped; required columns always stay visible. Pass
+ * `maxColumns: 0` to flag none. The rule lives in the spec so that an
+ * author-time tool (objectstack's `field-no-consumers` lint) credits exactly
+ * the columns this grid draws, and the two cannot disagree.
+ *
+ * What each column carries — label, cell type, options, lookup target,
+ * conditional rules, computed expression — is built here, from the child
+ * field, by {@link deriveColumn}. `booleanLabel` is required: it draws the
+ * option labels of a `boolean` / `toggle` child field in the session language
+ * (see `optionsFor`, objectui#12924).
  */
-export declare const DEFAULT_MAX_INLINE_COLUMNS = 6;
-/**
- * Derive editable grid columns from a child object's fields, skipping system /
- * audit fields, non-editable types, and the back-reference FK to the parent.
- * Every editable column is returned; those beyond {@link DEFAULT_MAX_INLINE_COLUMNS}
- * are flagged `defaultHidden` (collapsed into the grid's column chooser, not
- * dropped). Pass `maxColumns: 0` to flag none.
- */
-export declare function deriveColumns(childSchema: ObjectSchemaLike | undefined, opts?: {
+export declare function deriveColumns(childSchema: ChildObjectSchemaLike | undefined, opts: {
+    booleanLabel: BooleanValueLabel;
     relationshipField?: string;
     exclude?: string[];
     maxColumns?: number;
@@ -44,15 +69,40 @@ export declare function deriveColumns(childSchema: ObjectSchemaLike | undefined,
  * schema, exactly as {@link deriveColumns} would, while preserving the author's
  * column set, order and labels. A column that already declares a `type` is left
  * untouched — the author's explicit choice always wins.
+ *
+ * A column that renders as `currency` and carries an authored `scale`, whether
+ * its type is declared or hydrated, is reported by
+ * {@link reportCurrencyColumnScale} (objectui#10783): the grid does not read
+ * that key.
+ *
+ * `booleanLabel` is required for the same reason as on {@link deriveColumns}:
+ * an untyped column over a `boolean` / `toggle` child field hydrates into a
+ * select whose two option labels it draws (objectui#12924).
  */
-export declare function hydrateColumns(columns: GridColumn[] | undefined, childSchema: ObjectSchemaLike | undefined): GridColumn[];
+export declare function hydrateColumns(columns: GridColumn[] | undefined, childSchema: ChildObjectSchemaLike | undefined, opts: {
+    booleanLabel: BooleanValueLabel;
+}): GridColumn[];
 /**
- * Field names for a child's full "row form" (the per-row expand editor) — every
- * editable business field, skipping system/audit fields, the back-reference FK,
- * and computed types. Broader than {@link deriveColumns} (which only returns
- * grid-friendly types): the form has room for textarea/richtext/file/etc.
+ * Field names for a child's full "row form" (the per-row expand editor) — the
+ * form an inline master-detail collection opens when its author listed no
+ * `formFields`.
+ *
+ * WHICH fields, in what order, is `@objectstack/spec`'s rule,
+ * `deriveInlineRowFormFields` (objectui#11428), the row-form twin of the
+ * `deriveInlineGridColumns` rule {@link deriveColumns} reads: it skips system /
+ * audit fields, sort-position fields, fields flagged `system` or `hidden`, the
+ * computed types, the back-reference FK to the parent and any `exclude`d name,
+ * and keeps every other field in the child's field order. So it is broader than
+ * the grid: `readonly` fields and the rich types a grid cell omits (textarea,
+ * richtext, json, file, …) stay, since the form has room for them. The rule
+ * lives in the spec so that an author-time tool (objectstack's
+ * `field-no-consumers` lint) credits exactly the fields this form draws.
+ *
+ * WHETHER a row offers the form at all is the spec's `isInlineRowFormOffered`,
+ * which `MasterDetailForm` asks. How each named field renders is the form's own
+ * per-field builder, over these names.
  */
-export declare function deriveFormFields(childSchema: ObjectSchemaLike | undefined, opts?: {
+export declare function deriveFormFields(childSchema: ChildObjectSchemaLike | undefined, opts?: {
     relationshipField?: string;
     exclude?: string[];
 }): string[];
@@ -72,7 +122,7 @@ export declare const RICH_FIELD_FORM_THRESHOLD = 2;
  *     ({@link RICH_FIELD_FORM_THRESHOLD}), or more than
  *     {@link SMART_FORM_FIELD_THRESHOLD} editable business fields; else a `grid`.
  */
-export declare function resolveInlineMode(childSchema: ObjectSchemaLike | undefined, inlineEdit: boolean | InlineMode | undefined, opts?: {
+export declare function resolveInlineMode(childSchema: ChildObjectSchemaLike | undefined, inlineEdit: boolean | InlineMode | undefined, opts?: {
     relationshipField?: string;
 }): InlineMode;
 export interface DerivedDetail {
@@ -93,9 +143,12 @@ export interface DerivedDetail {
  * Resolve a child collection's full config (FK + columns) from its object
  * schema. Throws when no relationship to the parent can be found. The caller
  * supplies any explicit overrides (relationshipField / columns / amountField),
- * which win over the derived values.
+ * which win over the derived values, and the required `booleanLabel`, which
+ * is not an override: it draws a `boolean` / `toggle` column's two option
+ * labels in the session language (objectui#12924, see {@link deriveColumns}).
  */
-export declare function deriveDetail(childObject: string, childSchema: ObjectSchemaLike | undefined, parentObjectName: string, override?: {
+export declare function deriveDetail(childObject: string, childSchema: ChildObjectSchemaLike | undefined, parentObjectName: string, override: {
+    booleanLabel: BooleanValueLabel;
     relationshipField?: string;
     columns?: GridColumn[];
     amountField?: string;