@object-ui/plugin-form 6.2.2 → 7.0.0

package/CHANGELOG.md

@@ -1,5 +1,328 @@
 # @object-ui/plugin-form
 
+## 7.0.0
+
+### Minor Changes
+
+- 5332639: feat(app-shell): render full object forms (incl. master-detail) in screen-flow wizard steps
+
+  `FlowRunner` now renders an `object-form` screen step: when the paused screen
+  carries `kind: 'object-form'`, it mounts the real `<ObjectForm>` for the named
+  object (auto-routing to `MasterDetailForm` for inline child collections),
+  prefilled from the step's `defaults`. The form persists itself (atomic
+  master-detail batch), then resumes the run with the saved record id bound to the
+  step's `idVariable`. `dataSource`/`objects` are threaded through all three
+  `FlowRunner` mount points.
+
+  Also fixes three pre-existing bugs this surfaced (each affects normal forms too):
+
+  - **plugin-form**: `ObjectForm` now forwards `initialValues`/`initialData` when
+    routing to `MasterDetailForm`, so prefilled header values are no longer
+    dropped on master-detail create forms.
+  - **fields**: `PercentField` treated values as `0–1` fractions (`value × 100`),
+    so a `0–100` field (e.g. `probability` default `50`) rendered as `5000%` —
+    exceeding `max=100`, which makes HTML5 constraint validation mark the field
+    `:invalid` and silently block the whole form's submit. It now treats a field
+    declaring `max > 1` as the `0–100` whole-number convention, matching the
+    read-side formatter.
+  - **data-objectstack**: `ObjectStackAdapter.batchTransaction` now sends
+    `credentials: 'include'`, so master-detail batch saves authenticate under the
+    console's cookie session (previously every batch save 401'd).
+
+- 80c133c: Spreadsheet-style line-item grid editor.
+
+  `GridField`'s editable grid mode is reworked into an enterprise line-item editor (the QuickBooks / Stripe / NetSuite pattern), generalised across every inline grid:
+
+  - **Computed read-only columns** — a child field with an arithmetic `expression` (e.g. `amount = quantity * unit_price`) renders read-only, recomputes live as its inputs change, and writes the result back into the row so it persists and the running total reflects it. A small safe arithmetic evaluator (`+ - * / %`, parens, `record.<field>` refs; no `eval`) powers it.
+  - **Trailing "ghost" row** — start-with-one + auto-append: typing in the ghost materialises a real row (index-stable, so focus/caret survive), so you keep entering lines without clicking "Add".
+  - **Borderless click-to-focus cells** + role-based column widths (description flexes; qty/price/amount stay narrow).
+  - **Keyboard navigation** — Enter / ArrowUp / ArrowDown move between rows in the same column.
+  - Per-row "expand to full form" is gated to grids that omit fields (no redundant expand on thin lines).
+  - `deriveColumns` surfaces a field `expression` as a computed column; the running-total column prefers the computed/last-currency column. Blank/ghost rows are filtered from the persisted batch (`isBlankRow`).
+
+- d16566f: Atomic master-detail create via the cross-object transactional batch endpoint (ObjectStack #1604).
+
+  When the server exposes the transactional batch endpoint, a NEW parent record and its child line items are now persisted in ONE server transaction — commit all or roll back all — instead of the previous client-orchestrated "create parent → create children → best-effort cleanup on failure" sequence.
+
+  **`@object-ui/data-objectstack` — `ObjectStackAdapter.batchTransaction(operations)`**
+
+  - New method posting `{ operations }` to `POST /api/v1/batch`. Operations run in one server transaction. A field value of `{ $ref: <earlier op index> }` resolves to that op's generated id, so a child can reference its parent created earlier in the same batch (master-detail FK). Throws `ObjectStackError('BATCH_ERROR')` on a non-2xx response.
+
+  **`@object-ui/plugin-form`**
+
+  - `MasterDetailForm` now detects `dataSource.batchTransaction` and, on a NEW parent, builds one atomic batch (parent at index 0, each child FK set to `{ $ref: 0 }`) via the new pure helper `buildMasterDetailBatch`. Client-side total rollups are merged into the parent payload before the batch. Edit mode and adapters without `batchTransaction` keep the existing client-orchestrated path.
+  - `ObjectForm` gained a `submitHandler` hook: when supplied, the form validates and hands the collected values to the host instead of calling `dataSource.create` / `dataSource.update`. `MasterDetailForm` uses it to own the atomic parent+children write while the parent fields are still rendered by `ObjectForm`.
+
+  **`@object-ui/types`**
+
+  - `ObjectFormSchema.submitHandler?: (values) => any | Promise<any>` — typed override for host-owned persistence.
+
+  Pairs with the framework-side ambient-transaction fix (ObjectQL `AsyncLocalStorage` transaction propagation) and the `/api/v1/batch` endpoint added in `@objectstack/rest`.
+
+- 69510df: feat(master-detail): derive child columns + relationship FK from metadata
+
+  A master-detail child collection can now be configured with **just the child
+  object name** — the relationship FK and the editable grid columns are derived
+  from the child object's schema (via `DataSource.getObjectSchema`), instead of a
+  hand-authored columns block.
+
+  ```ts
+  // before: ~40 lines of columns + relationshipField
+  details: [{ childObject: 'task', relationshipField: 'project', columns: [ ...12 lines... ] }]
+  // after:
+  details: [{ childObject: 'task' }]
+  ```
+
+  - `relationshipField` is auto-detected from the child's `master_detail`/`lookup`
+    field that references the parent (master_detail preferred).
+  - `columns` are derived from the child's fields, skipping system/audit fields,
+    the back-reference FK, and non-editable types (formula/summary/autonumber/
+    file/json/…); select options and lookup references carry through.
+  - `amountField` (running-total source) defaults to the first numeric/currency
+    column.
+  - Any of these can still be set explicitly to override the derived defaults.
+  - Save is gated until derivation resolves; new pure helpers
+    (`deriveDetail`/`deriveColumns`/`findRelationshipField`) are unit-tested.
+
+- b148daf: feat(master-detail): atomic EDIT via the cross-object batch endpoint
+
+  Edit mode now persists the parent update together with its child line-item
+  create/update/delete diffs in ONE server transaction (commit all or roll back
+  all), matching what create already did. Previously only create used the atomic
+  `/api/v1/batch` path; edit fell back to client-orchestrated writes with
+  best-effort cleanup.
+
+  - New pure helper `buildMasterDetailEditBatch(parentObject, parentId,
+parentData, details)` — emits a parent `update` op (index 0) then diffs each
+    child collection against its loaded snapshot into `create` / `update` /
+    `delete` ops (children reference the known parent id directly, no `$ref`).
+  - `MasterDetailForm` now treats `canBatch` as available whenever the data
+    source exposes `batchTransaction` (create AND edit). `submitViaBatch` builds
+    create-ops or edit-ops by mode; `onSuccess` → `handleSaved` ("saved" toast,
+    no form reset in edit).
+
+  The server `/api/v1/batch` handler already supports `update`/`delete` actions,
+  and the adapter already forwards `action`/`id`, so this is a front-end change.
+  Unit-tested (parent update + child create/update/delete diff); the create path
+  remains verified by the live e2e.
+
+- 90acb7f: Master-detail subform + lightweight list primitives (SDUI).
+
+  - `MasterDetailForm` (`object-master-detail-form`): enter a parent record and its child line items together; client-orchestrated transactional create (parent → FK → bulk children → rollup → cleanup). Enterprise-convention layout (header on top, line grid, single Save bar at the bottom).
+  - `LineItemsField` editable child grid (line numbers, right-aligned numerics, running total) and `LineItemsPanel` (`record:line_items`) for detail-page inline edit.
+  - `element:definition-list` and `element:repeater` — lightweight, low-chrome list primitives for simple data.
+
+- 00f8d2d: Master-detail form: live Subtotal / Tax / Total stack.
+
+  `MasterDetailForm` now renders a right-aligned document totals stack under the line items when the parent form has a tax-rate field (`taxRateField`, default `tax_rate`): **Subtotal** (Σ line amounts) → **Tax** (header rate %) → **Total**, recomputed live as lines and the rate change. The header rate is read via scoped event delegation on the form host (no coupling into `ObjectForm` internals). When the stack is shown, the per-grid footer total is subsumed.
+
+- 300d755: feat(form): inline master-detail in a plain ObjectForm via `subforms`
+
+  `ObjectFormSchema` gains a `subforms` array. When set, a regular `object-form`
+  renders as a master-detail form — the object's own fields on top, an editable
+  grid per child collection below, persisted together in one atomic transaction —
+  without a bespoke `object-master-detail-form` page.
+
+  ```ts
+  { type: 'object-form', objectName: 'expense_claim',
+    subforms: [{ childObject: 'expense_line' }] }   // FK + columns auto-derived
+  ```
+
+  Each subform needs only `childObject` (relationship FK and columns are derived
+  from the child object's metadata; override with `relationshipField`/`columns`).
+  This is the config-driven, page-less way to express master-detail entry — a form
+  view can declare its child collections directly.
+
+- 18728c1: Master-detail entry: lighter layout, compact lookup cells, persisted line order.
+
+  - **De-framed line-item section** — the subform no longer double-frames the grid in a `Card` (border + `p-6`); it renders as a light label + the grid's own bordered table, reclaiming the width the line table needs.
+  - **Compact lookup cells** — `LookupField` gains a `compact` mode (used by grid cells): the selected value shows inline in a borderless single-line trigger instead of a chip stacked above a separate "Select…" button.
+  - **Persisted drag-reorder** — `deriveMasterDetail` detects a sort field (`position`/`sort_order`/…), excludes it from the editable columns/row-form, and threads it as the grid's `sort_field` so reordering stamps `row[position] = index` and survives a reload.
+
+- 8426db7: feat(form): standard New/Edit modal renders form-view subforms (Tier 0)
+
+  The console's standard create/edit record modal now renders inline child
+  collections when the object's form view declares `subforms` — master-detail
+  entry with **no bespoke page**, persisted as one atomic transaction.
+
+  - `ModalForm` (and the create/edit modal in app-shell `AppContent`) detects
+    `subforms` and renders `MasterDetailForm` inside the dialog (it owns its Save
+    bar; the modal footer is suppressed); on success the modal closes + refreshes.
+  - `AppContent` sources `subforms` from the object's default form view
+    (`form.subforms` / `formViews.default.subforms`).
+  - `ModalFormSchema` gains `subforms`.
+
+  With this, declaring `formViews.default.subforms: [{ childObject }]` is enough
+  to make an object's standard New/Edit screen a master-detail form — completing
+  the config-driven master-detail story (Tier 0 → derive everything from the
+  relationship + child metadata).
+
+### Patch Changes
+
+- ddbe4a2: B2 step 3: client-side field-level conditional rules (`visibleWhen` / `readonlyWhen` / `requiredWhen`). The form renderer now evaluates these CEL predicates reactively against the live record and gates each field's visibility, read-only state, and required-ness accordingly. Evaluation delegates to the canonical `@objectstack/formula` `ExpressionEngine` — the _same_ dialect the server enforces (`requiredWhen` in the rule-validator, `readonlyWhen` in `stripReadonlyWhenFields`) — so the UX and the persisted verdict always agree. New core helpers `evalFieldPredicate` / `resolveFieldRuleState` (zero-React, fail-open). `FormField` gains `visibleWhen` / `readonlyWhen` / `requiredWhen` (+ deprecated `conditionalRequired` alias), and `ObjectForm` carries them through from object metadata.
+- 2d47e94: B2 follow-ups (A): field conditional rules in inline grids + submit-time enforcement.
+
+  - **Grids**: a line-item column's `readonlyWhen` / `requiredWhen` CEL rule is now honored per row — `deriveMasterDetail` carries the props onto the `GridColumn` and `GridField` evaluates them against each row via `resolveFieldRuleState` (a `readonlyWhen`-TRUE cell locks; a `requiredWhen`-TRUE empty cell flags inline-invalid). Rules are row-scoped (`record.*`); the core helpers gained an optional `scope` (and `GridField` a `contextRecord` prop) so a future header-driven lock can bind `parent.*` — that wiring is deferred (it needs the master-detail header's re-renders isolated).
+  - **Submit enforcement**: `requiredWhen` already drove react-hook-form's `required` rule, so submit is blocked with a field error when the predicate is TRUE and the value is empty. Added a reactive cleanup so a stale _required_ error clears when the predicate flips FALSE (and all errors clear when a field is hidden by `visibleWhen`).
+
+- f6044fa: feat(form): subforms in DrawerForm + full-page record form (Tier 0 everywhere)
+
+  Completes config-driven master-detail across all standard create/edit entry
+  points (after the modal in the previous change):
+
+  - `DrawerForm` now hosts `MasterDetailForm` inside the drawer when the schema
+    declares `subforms` (its own Save bar; closes + refreshes on success).
+  - `RecordFormPage` (full-page New/Edit) sources `subforms` from the object's
+    form view, so the full-page form renders inline child collections too.
+  - `ObjectForm`'s subforms shortcut now defers to the drawer/modal variants for
+    those formTypes (so they keep their envelope), and only renders the
+    master-detail form directly for inline/simple forms.
+
+  Declaring `formViews.default.subforms: [{ childObject }]` now yields a
+  master-detail experience in the modal, drawer, AND full-page form — no bespoke
+  page anywhere.
+
+- ad8ade6: feat(components): metadata-derived field locators on generated forms (ADR-0054 Phase 4)
+
+  The form renderer now emits a stable `data-testid="field:{objectName}.{field}"`
+  (plus `data-field`) on every field wrapper, derived from the form's `objectName`
+  and each field's name — closing the locator gap at the source so every generated
+  form (`ObjectForm`/`ModalForm`/`DrawerForm`/`SplitForm`/`WizardForm`) inherits
+  testable fields with zero per-app work (ADR-0054 C4). `FormSchema` gains an
+  optional `objectName`; the object prefix is omitted (`field:{field}`) when a form
+  has none. `FormItem` now accepts `data-*` attributes.
+
+- 3870c20: feat(forms): declarative `navigateOnSuccess` + `resetOnSuccess` on object-form
+
+  Rounds out declarative success behavior for metadata-only forms (which can't
+  pass an `onSuccess` function), complementing `successMessage`:
+
+  - **`navigateOnSuccess`** — after a successful create/update, navigate here.
+    Supports `{id}`/`{recordId}` interpolation from the saved record and is
+    same-origin-guarded; takes precedence over the toast (landing on the record
+    is the confirmation).
+  - **`resetOnSuccess`** — after a successful create, reset the form for another
+    entry (the wizard returns to a cleared step 1). Ignored when navigating.
+
+  Wired in both ObjectForm and WizardForm via a small shared `successBehavior`
+  helper (kept dependency-free to avoid an EmbeddableForm import cycle).
+
+- b88c560: feat(forms): declarative `successMessage` on object-form
+
+  Metadata-only forms (a wizard/object-form authored as JSON) cannot pass an
+  `onSuccess` function, so the post-create/update feedback was a fixed
+  "Created"/"Saved" toast. `ObjectFormSchema` now accepts `successMessage`, which
+  ObjectForm and WizardForm use for the default success toast when no `onSuccess`
+  handler is supplied. Falls back to "Created"/"Saved".
+
+- 7913390: fix(master-detail): never silent on save — feedback, reset, and a duplicate-submit guard
+
+  `MasterDetailForm`'s "Create" submitted successfully but gave **no feedback**: no toast, no form reset, no navigation. A successful create looked broken, and re-clicking created duplicate records.
+
+  - On success: a `toast.success`, and on create the form clears (line items reset + parent `<ObjectForm>` remounts) ready for the next entry. A page-supplied `onSuccess` still runs afterwards (e.g. to navigate).
+  - On failure (validation / network / atomic rollback): a `toast.error` surfaces the message instead of failing silently.
+  - In-flight guard: the Create button shows "Saving…" and is disabled while a submit is running, preventing duplicate submissions, with a safety release if client-side validation blocks the submit.
+  - `@object-ui/components` now re-exports `toast` (alongside `Toaster`) from its sonner wrapper.
+
+  Tests: two new `MasterDetailForm` tests assert success → toast + form clear, and failure → error toast.
+
+- 514f426: fix(master-detail): reliable submit + stable e2e hooks
+
+  Fixes the "click Create, nothing happens" report, surfaced by a new live browser
+  e2e harness that drives the form with real input.
+
+  - **MasterDetailForm `handleSave`** now triggers the button-less parent form's
+    submit from a deferred macrotask and re-queries the live `<form>` inside it.
+    Calling `requestSubmit()` synchronously inside the click handler (right after
+    the `setSaving` state update) intermittently dropped the nested submit event,
+    so react-hook-form's `onSubmit` never ran and the click appeared to do nothing
+    — only the occasional click got through. Deferring makes it fire every time.
+  - **Stable `data-testid`s** so automation/e2e can drive the widgets
+    deterministically (Radix Select + react-hook-form cannot be driven by
+    synthetic DOM events): `select-trigger-{field}` / `select-option-{value}`
+    (SelectField), `lookup-trigger-{field}` (LookupField), `line-items-add`
+    (GridField), `md-form-submit` / `md-form-cancel` (MasterDetailForm).
+
+- 586a027: B2 follow-up (#1581): parent-scoped conditional rules in inline grids — "paid invoice → lock lines". `MasterDetailForm` now binds the live header record to every line-item grid as `parent`, so a column's `readonlyWhen` / `requiredWhen` CEL rule can react to the header (e.g. `parent.status == 'paid'` locks quantity / unit price / product when the invoice is paid). The line grids + document totals moved into a dedicated `<MasterDetailLines>` child that owns the scraped header record, so a header edit re-renders only the lines and never resets the header `ObjectForm`'s react-hook-form state mid-edit; the scrape is deduped by value to avoid needless churn. (`@object-ui/fields`' `GridField.contextRecord` and column-rule derivation already existed — this wires the last link.)
+- 9aac2b8: feat(form): modal forms can host a tabbed layout (modal + tabbed composes)
+
+  `ModalForm` rendered sections as a flat vertical stack — a modal create/edit
+  form could never be tabbed, because `formType` (one field) couldn't be both
+  `modal` (container) and `tabbed` (layout). Per ADR-0050 (additive first), the
+  modal container now accepts a `contentLayout` ('simple' | 'tabbed'): when
+  `tabbed`, sections render as tabs inside the dialog. The console record
+  New/Edit modal (`AppContent`) forwards the default form view's layout, so a
+  `type:'tabbed'` form view now renders tabbed in the modal too — not just on the
+  full-page route (#1762). Non-breaking; `FormView.type` enum unchanged.
+
+  Refs objectstack-ai/framework#1890, ADR-0050
+
+- 650bd1f: fix(forms/dashboard/related-list): four business-facing rendering fixes found while QA-ing a showcase workspace
+
+  - **plugin-form / WizardForm**: a multi-step `object-form` with `formType: 'wizard'` posted an empty/partial body on submit, so the server rejected every required field. Two causes: (1) the footer Next/Create buttons bypassed the inner form and submitted the wizard's own (never-collected) `formData`; (2) the create-mode data-seeding effect re-ran on `dataSource`/`objectSchema` identity churn and reset `formData` to `{}` mid-wizard. Now the buttons submit the inner form natively (`<form id>` + `type="submit"`, which validates each step and collects values via `getValues()`), and the create seed is made idempotent.
+  - **plugin-dashboard / DashboardRenderer**: chart widgets rendered as empty cards (recharts logged `width(-1) height(-1)`) because the positioned grid used `auto-rows-min`, collapsing any widget with no intrinsic height. The explicit-columns grid now uses `gridAutoRows: minmax(5rem, auto)` so spanned chart rows get a real height while tables can still grow.
+  - **plugin-detail / RelatedList**: auto-derived related-list columns led with system audit fields (`created_at`, `updated_at`, …) for child objects without a name/title field, pushing business columns past the column cap. System audit fields are now sorted last.
+  - **plugin-form / ObjectForm + WizardForm**: a successful create/update gave no feedback for metadata-only pages (which can't pass an `onSuccess` function). They now show a default `toast.success('Created'/'Saved')` when no `onSuccess` handler is supplied (guarded so a `submitHandler` host like MasterDetailForm never double-toasts).
+
+- Updated dependencies [5976ba3]
+- Updated dependencies [a00e16d]
+- Updated dependencies [eaccefd]
+- Updated dependencies [f7f325d]
+- Updated dependencies [c12986e]
+- Updated dependencies [71d7ce0]
+- Updated dependencies [053c948]
+- Updated dependencies [ddbe4a2]
+- Updated dependencies [2d47e94]
+- Updated dependencies [9049bbe]
+- Updated dependencies [6c0c92c]
+- Updated dependencies [cb2fdb1]
+- Updated dependencies [c3749eb]
+- Updated dependencies [6cfa330]
+- Updated dependencies [ad8ade6]
+- Updated dependencies [d54346c]
+- Updated dependencies [5332639]
+- Updated dependencies [3870c20]
+- Updated dependencies [2eb3096]
+- Updated dependencies [b88c560]
+- Updated dependencies [bd398df]
+- Updated dependencies [66ed3ad]
+- Updated dependencies [c6445b6]
+- Updated dependencies [80c133c]
+- Updated dependencies [5e1b838]
+- Updated dependencies [d16566f]
+- Updated dependencies [90acb7f]
+- Updated dependencies [7913390]
+- Updated dependencies [514f426]
+- Updated dependencies [1394e34]
+- Updated dependencies [e95cc25]
+- Updated dependencies [abe8ebc]
+- Updated dependencies [300d755]
+- Updated dependencies [bd8b054]
+- Updated dependencies [4eb9cb6]
+- Updated dependencies [7c239fd]
+- Updated dependencies [858ad94]
+- Updated dependencies [2270239]
+- Updated dependencies [db8cd00]
+- Updated dependencies [18728c1]
+- Updated dependencies [8d1195d]
+  - @object-ui/core@7.0.0
+  - @object-ui/components@7.0.0
+  - @object-ui/react@7.0.0
+  - @object-ui/types@7.0.0
+  - @object-ui/fields@7.0.0
+  - @object-ui/permissions@7.0.0
+
+## 6.2.3
+
+### Patch Changes
+
+- @object-ui/types@6.2.3
+- @object-ui/core@6.2.3
+- @object-ui/react@6.2.3
+- @object-ui/components@6.2.3
+- @object-ui/fields@6.2.3
+- @object-ui/permissions@6.2.3
+
 ## 6.2.2
 
 ### Patch Changes

package/dist/{packages/plugin-form/src/DrawerForm.d.ts → DrawerForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FormField, DataSource } from '../../types/src';
+import { FormField, DataSource } from '@object-ui/types';
 export interface DrawerFormSectionConfig {
     name?: string;
     label?: string;
@@ -53,6 +53,19 @@ export interface DrawerFormSchema {
     onError?: (error: Error) => void;
     onCancel?: () => void;
     className?: string;
+    /** Inline child collections — renders the drawer as an atomic master-detail
+     *  form. Each entry needs only `childObject` (FK + columns derived). */
+    subforms?: Array<{
+        childObject: string;
+        relationshipField?: string;
+        columns?: any[];
+        amountField?: string;
+        totalField?: string;
+        title?: string;
+        addLabel?: string;
+        minRows?: number;
+        maxRows?: number;
+    }>;
 }
 export interface DrawerFormProps {
     schema: DrawerFormSchema;

package/dist/{packages/plugin-form/src/EmbeddableForm.d.ts → EmbeddableForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DataSource, FormField } from '../../types/src';
+import { DataSource, FormField } from '@object-ui/types';
 export interface EmbeddableFormTexts {
     submit?: string;
     submitting?: string;

package/dist/LineItemsPanel.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { GridColumn } from '@object-ui/fields';
+export interface LineItemsPanelSchema {
+    type?: 'record:line_items';
+    childObject: string;
+    relationshipField: string;
+    columns: GridColumn[];
+    parentObject?: string;
+    parentId?: string;
+    recordId?: string;
+    amountField?: string;
+    totalField?: string;
+    title?: string;
+    readonly?: boolean;
+    minRows?: number;
+    maxRows?: number;
+}
+export declare const LineItemsPanel: React.FC<{
+    schema: LineItemsPanelSchema;
+}>;

package/dist/MasterDetailForm.d.ts

@@ -0,0 +1,67 @@
+import { default as React } from 'react';
+import { DataSource } from '@object-ui/types';
+import { GridColumn } from '@object-ui/fields';
+import { InlineMode } from './deriveMasterDetail';
+export interface MasterDetailDetailConfig {
+    /** Child object name, e.g. 'expense_line'. */
+    childObject: string;
+    /** FK field on the child pointing back to the parent, e.g. 'expense_claim'.
+     *  Optional — auto-detected from the child's master_detail/lookup field that
+     *  references the parent object when omitted. */
+    relationshipField?: string;
+    /** Editable columns for the child grid. Optional — derived from the child
+     *  object's fields (via DataSource.getObjectSchema) when omitted. */
+    columns?: GridColumn[];
+    /** Field names for the per-row expand form. Optional — derived from the child
+     *  object's fields (broader than `columns`: includes rich types) when omitted. */
+    formFields?: string[];
+    /** Inline-edit form factor: 'grid' = editable cells; 'form' = read-only list +
+     *  per-row full form. Optional — resolved from the relationship's `inlineEdit`
+     *  (incl. the smart default) when omitted. */
+    inlineMode?: InlineMode;
+    /** Numeric child column to sum, e.g. 'amount'. */
+    amountField?: string;
+    /** Child field holding the line sort position — stamped on drag-reorder so
+     *  order persists. Auto-derived from a `position`/`sort_order`/… field. */
+    sortField?: string;
+    /** Parent field to receive the rolled-up sum, e.g. 'total_amount'. */
+    totalField?: string;
+    /** Section title. */
+    title?: string;
+    minRows?: number;
+    maxRows?: number;
+    addLabel?: string;
+}
+export interface MasterDetailFormSchema {
+    type?: 'object-master-detail-form';
+    /** Parent object name, e.g. 'expense_claim'. */
+    objectName: string;
+    mode?: 'create' | 'edit';
+    recordId?: string;
+    /** Prefilled parent header values (create mode) — seeds the parent form's
+     *  initial values, e.g. a conversion wizard carrying the lead/account over. */
+    initialValues?: Record<string, any>;
+    initialData?: Record<string, any>;
+    /** Parent form sections/fields — passed straight through to ObjectForm. */
+    sections?: any[];
+    fields?: any[];
+    formType?: 'simple' | 'tabbed';
+    title?: string;
+    submitText?: string;
+    /** One or more child collections. */
+    details: MasterDetailDetailConfig[];
+    /** Parent header field holding a tax rate (percent). When the parent form has
+     *  this field, a live Subtotal / Tax / Total stack renders under the lines.
+     *  Defaults to `tax_rate`; the stack only appears if the field is present. */
+    taxRateField?: string;
+    onSuccess?: (parent: any) => void | Promise<void>;
+    onError?: (err: Error) => void;
+    onCancel?: () => void;
+    className?: string;
+}
+export interface MasterDetailFormProps {
+    schema: MasterDetailFormSchema;
+    dataSource?: DataSource;
+    className?: string;
+}
+export declare const MasterDetailForm: React.FC<MasterDetailFormProps>;

package/dist/{packages/plugin-form/src/ModalForm.d.ts → ModalForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FormField, DataSource } from '../../types/src';
+import { FormField, DataSource } from '@object-ui/types';
 export interface ModalFormSectionConfig {
     name?: string;
     label?: string;
@@ -16,6 +16,9 @@ export interface ModalFormSchema {
     title?: string;
     description?: string;
     sections?: ModalFormSectionConfig[];
+    /** Internal content layout (ADR-0050, #1890): 'tabbed' renders sections as
+     *  tabs inside the modal, so "modal + tabbed" composes. Default stacks them. */
+    contentLayout?: 'simple' | 'tabbed';
     fields?: string[];
     customFields?: FormField[];
     /**
@@ -50,6 +53,19 @@ export interface ModalFormSchema {
     onError?: (error: Error) => void;
     onCancel?: () => void;
     className?: string;
+    /** Inline child collections — renders the modal as an atomic master-detail
+     *  form. Each entry needs only `childObject` (FK + columns derived). */
+    subforms?: Array<{
+        childObject: string;
+        relationshipField?: string;
+        columns?: any[];
+        amountField?: string;
+        totalField?: string;
+        title?: string;
+        addLabel?: string;
+        minRows?: number;
+        maxRows?: number;
+    }>;
 }
 export interface ModalFormProps {
     schema: ModalFormSchema;

package/dist/{packages/plugin-form/src/ObjectForm.d.ts → ObjectForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { ObjectFormSchema, DataSource } from '../../types/src';
+import { ObjectFormSchema, DataSource } from '@object-ui/types';
 export interface ObjectFormProps {
     /**
      * The schema configuration for the form

package/dist/{packages/plugin-form/src/SplitForm.d.ts → SplitForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FormField, DataSource } from '../../types/src';
+import { FormField, DataSource } from '@object-ui/types';
 export interface SplitFormSectionConfig {
     name?: string;
     label?: string;

package/dist/{packages/plugin-form/src/TabbedForm.d.ts → TabbedForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FormField, DataSource } from '../../types/src';
+import { FormField, DataSource } from '@object-ui/types';
 export interface FormSectionConfig {
     /**
      * Section identifier (used as tab value)

package/dist/{packages/plugin-form/src/WizardForm.d.ts → WizardForm.d.ts}

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DataSource } from '../../types/src';
+import { DataSource } from '@object-ui/types';
 import { FormSectionConfig } from './TabbedForm';
 export interface WizardFormSchema {
     type: 'object-form';
@@ -44,6 +44,18 @@ export interface WizardFormSchema {
      * Submit button text (shown on last step)
      */
     submitText?: string;
+    /**
+     * Declarative success toast text shown when no `onSuccess` handler is given
+     * (metadata pages cannot pass a function). Falls back to 'Created'/'Saved'.
+     */
+    successMessage?: string;
+    /** Navigate here after a successful create/update (declarative; metadata
+     * pages can't pass onSuccess). Supports `{id}`/`{recordId}` interpolation
+     * from the saved record. Same-origin-guarded. Takes precedence over the toast. */
+    navigateOnSuccess?: string;
+    /** Reset the wizard (back to step 1, cleared) after a successful create so the
+     * user can enter another. Ignored when `navigateOnSuccess` is set. */
+    resetOnSuccess?: boolean;
     /**
      * Show cancel button
      * @default true

package/dist/{packages/plugin-form/src/autoLayout.d.ts → autoLayout.d.ts}

@@ -1,4 +1,4 @@
-import { FormField } from '../../types/src';
+import { FormField } from '@object-ui/types';
 /**
  * Check if a field type is "wide" (should span full row in multi-column layout).
  */

package/dist/deriveMasterDetail.d.ts

@@ -0,0 +1,86 @@
+import { GridColumn } from '@object-ui/fields';
+/** Minimal shape of an object schema as returned by `DataSource.getObjectSchema`. */
+export interface ObjectSchemaLike {
+    name?: string;
+    fields?: Record<string, any>;
+}
+/** Map an ObjectQL field type to a LineItems grid column type. */
+export declare function fieldTypeToColumnType(type: string | undefined): GridColumn['type'];
+/**
+ * Find the field on the child object that points back to the parent — the
+ * 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;
+/**
+ * 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`.
+ */
+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?: {
+    relationshipField?: string;
+    exclude?: string[];
+    maxColumns?: number;
+}): 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.
+ */
+export declare function deriveFormFields(childSchema: ObjectSchemaLike | undefined, opts?: {
+    relationshipField?: string;
+    exclude?: string[];
+}): string[];
+/** Inline-edit form factor. */
+export type InlineMode = 'grid' | 'form';
+/** Above this many editable business fields, the grid gets cramped → `form`. */
+export declare const SMART_FORM_FIELD_THRESHOLD = 8;
+/**
+ * Resolve the inline-edit form factor for a child collection.
+ *   - explicit `'grid'` / `'form'` win;
+ *   - otherwise (`true` / undefined) pick by the child's shape: a `form` when it
+ *     has rich/form-only fields 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?: {
+    relationshipField?: string;
+}): InlineMode;
+export interface DerivedDetail {
+    childObject: string;
+    relationshipField: string;
+    columns: GridColumn[];
+    /** Field names for the per-row expand form (broader than `columns`). */
+    formFields: string[];
+    /** Inline-edit form factor (grid = editable cells; form = list + per-row form). */
+    mode: InlineMode;
+    /** First numeric column, used as the running-total source when none is set. */
+    amountField?: string;
+    /** Child field holding the line sort position, if any — the grid stamps it on
+     *  drag-reorder so order persists (excluded from the editable columns). */
+    sortField?: string;
+}
+/**
+ * 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.
+ */
+export declare function deriveDetail(childObject: string, childSchema: ObjectSchemaLike | undefined, parentObjectName: string, override?: {
+    relationshipField?: string;
+    columns?: GridColumn[];
+    amountField?: string;
+    inlineEdit?: boolean | InlineMode;
+}): DerivedDetail;