@object-ui/plugin-form 17.6.0 → 18.0.0

package/dist/deriveMasterDetail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deriveMasterDetail.d.ts","sourceRoot":"","sources":["../src/deriveMasterDetail.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAuBD,kEAAkE;AAClE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC,CAqClF;AAgCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,gBAAgB,EAAE,MAAM,GACvB,MAAM,GAAG,SAAS,CAWpB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAuD5C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,IAAI,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACjF,UAAU,EAAE,CA0Cd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,EAAE,GAAG,SAAS,EACjC,WAAW,EAAE,gBAAgB,GAAG,SAAS,GACxC,UAAU,EAAE,CAgCd;AAOD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,IAAI,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GAC5D,MAAM,EAAE,CAaV;AAED,+BAA+B;AAC/B,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAiBzC,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;iFAEiF;AACjF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,UAAU,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,EAC5C,IAAI,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,UAAU,CAaZ;AAwBD,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,wEAAwE;IACxE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mFAAmF;IACnF,IAAI,EAAE,UAAU,CAAC;IACjB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;+EAC2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,gBAAgB,GAAG,SAAS,EACzC,gBAAgB,EAAE,MAAM,EACxB,QAAQ,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CAAO,GAC7H,aAAa,CAmBf"}
+{"version":3,"file":"deriveMasterDetail.d.ts","sourceRoot":"","sources":["../src/deriveMasterDetail.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgBH,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAQD,kEAAkE;AAClE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC,CAqClF;AA+CD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,qBAAqB,GAAG,SAAS,EAC9C,gBAAgB,EAAE,MAAM,GACvB,MAAM,GAAG,SAAS,CAWpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,qBAAqB,GAAG,SAAS,EAC9C,IAAI,EAAE;IAAE,YAAY,EAAE,iBAAiB,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7G,UAAU,EAAE,CAYd;AA2GD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,EAAE,GAAG,SAAS,EACjC,WAAW,EAAE,qBAAqB,GAAG,SAAS,EAC9C,IAAI,EAAE;IAAE,YAAY,EAAE,iBAAiB,CAAA;CAAE,GACxC,UAAU,EAAE,CAqCd;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,qBAAqB,GAAG,SAAS,EAC9C,IAAI,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GAC5D,MAAM,EAAE,CAKV;AAED,+BAA+B;AAC/B,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAiBzC,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;iFAEiF;AACjF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,qBAAqB,GAAG,SAAS,EAC9C,UAAU,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,EAC5C,IAAI,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,UAAU,CAaZ;AAwBD,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,wEAAwE;IACxE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mFAAmF;IACnF,IAAI,EAAE,UAAU,CAAC;IACjB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;+EAC2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,qBAAqB,GAAG,SAAS,EAC9C,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE;IACR,YAAY,EAAE,iBAAiB,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;CACnC,GACA,aAAa,CAoBf"}

package/dist/fieldGroups.d.ts

@@ -19,4 +19,193 @@ import { FormField, ObjectFormSection } from '@object-ui/types';
  * into ObjectForm's existing section-render path.
  */
 export declare function deriveFieldGroupSections(fields: FormField[], fieldGroups: unknown): ObjectFormSection[] | null;
+/**
+ * THE ONE ROW RULE (objectui#9849 step two — director ruling letter E,
+ * item 2): 「The divider row exists iff `title || description`; with
+ * `description` only it is the blurb-only row (objectui#9835's shape), on
+ * every arm — one rule」.
+ *
+ * Every arm asks this one function, both to decide whether a row is drawn and
+ * — because 「the collapse control lives on the row」 (item 3) — whether a
+ * collapse control has anywhere to live. It replaced a four-way gate union
+ * (one answer per arm) that the ruling deleted.
+ *
+ * ⚠️ The row is PRESENTATION only. Whether the group is gated by its ADR-0089
+ * `visibleWhen` predicate and objectui#6236 membership claim does NOT depend
+ * on it (item 1) — see `projectSectionDivider`.
+ */
+export declare function sectionDrawsDividerRow(title?: string, description?: string): boolean;
+/**
+ * The section configuration a divider row is projected FROM, already resolved
+ * by the arm that owns each resolution.
+ *
+ * ⚠️ `collapse` arrives RESOLVED — by `resolveSectionCollapse` below, the one
+ * `collapsed` / `collapsible` resolution every arm calls. It is resolved before
+ * this projection rather than inside it because the arm needs the same answer
+ * a second time: whether to take the section's fields out of the DOM.
+ */
+export interface SectionDividerSource {
+    /** Section identity; spells the row's `name`. */
+    key: string | number;
+    /** The heading, already resolved through `sectionLabel` where the arm does that. */
+    title?: string;
+    /** The authored blurb (spec `FormSection.description`). */
+    description?: string;
+    /** ADR-0089 `FormSection.visibleWhen` (#6111), unevaluated. */
+    visibleWhen?: unknown;
+    /**
+     * The fault direction of {@link visibleWhen}, copied onto the row unchanged
+     * (`ObjectFormSection.visibleWhenFault`, objectui#13055).
+     */
+    visibleWhenFault?: ObjectFormSection['visibleWhenFault'];
+    /** The objectui#6236 membership claim: RESOLVED (post-FLS) member names. */
+    members: string[];
+    /** Read by one arm only — see `projectSectionDivider`. */
+    className?: string;
+    /** Resolved by `resolveSectionCollapse`, ⛔ never here. */
+    collapse?: {
+        collapsible?: boolean;
+        collapsed?: boolean;
+        onToggle?: () => void;
+    };
+}
+/**
+ * The loud diagnostic director ruling letter E, item 3 orders for a group that
+ * declares `collapsible` (or `collapsed`) but yields neither a heading nor a
+ * blurb: 「The collapse control lives on the row. A group that … yields neither
+ * title nor description has nowhere to host the control ⇒ a loud diagnostic at
+ * validation or render …, ⛔ never fields removed from the DOM with no control」.
+ *
+ * Emitted at RENDER, through the channel this package already uses for
+ * renderer-side author mistakes — a once-per-occurrence `console.warn`, the
+ * voice of `warnSectionMemberExcludedByFields` in `sectionFields.ts`. ⛔ It
+ * only warns: the resolution below keeps such a group OPEN, so its fields stay
+ * reachable whatever the warning's reader does.
+ *
+ * The first sentence is the ruling's own wording, verbatim; the pin that holds
+ * it reads it from this function, so the two cannot drift.
+ */
+export declare function headinglessCollapseWarning(where: string): string;
+/**
+ * Forget which sections were already reported — for pins only, so each row
+ * observes its own first report. The dedupe is per module instance, and this
+ * module is internal (the package barrel does not re-export it).
+ */
+export declare function resetHeadinglessCollapseWarnings(): void;
+/**
+ * Resolve a section's authored `collapsed` / `collapsible` pair into what the
+ * page draws: whether its row is a disclosure control, whether its fields are
+ * out of the DOM right now, and what toggles them.
+ *
+ * ⭐ THE ONE RESOLUTION (objectui#9849 — director ruling letter E, item 4:
+ * 「the three `collapsed` / `collapsible` resolutions converge to the
+ * declaration-based one objectui#9780 established」). Every arm calls it: the
+ * default arm, both `DrawerForm` pushes and — since step two, per item 1's
+ * 「on every arm」 — both stacked `ModalForm` pushes.
+ *
+ * The rules, each objectui#9780's (maintainer ruling 2026-09-18, letter A):
+ *
+ *  - `collapsed` IMPLIES `collapsible`. "Collapsed by default" is an everyday
+ *    intent and `collapsed: true` its most natural spelling, so that spelling
+ *    installs the control.
+ *  - `collapsible: false` WITH `collapsed: true` is the same contradiction and
+ *    resolves the same way — collapsed wins, the control is present.
+ *  - The control is read off the DECLARATION, ⛔ never off the live state:
+ *    deriving it from the live state would delete the control the moment the
+ *    user opened the section.
+ *  - A section declaring neither member is untouched.
+ *  - ⭐ A section is only ever collapsed when it is collapsible, and it is only
+ *    collapsible when it has a divider row to carry the control — which, by
+ *    the one row rule (`sectionDrawsDividerRow`), is exactly when it yields a
+ *    heading or a blurb. So fields leave the DOM only while a control that
+ *    brings them back is on the page.
+ *  - ⭐ A section that declares the pair and yields NEITHER is rendered open
+ *    and reported (`headinglessCollapseWarning`) — letter E item 3.
+ */
+export declare function resolveSectionCollapse(declared: {
+    collapsible?: boolean;
+    collapsed?: boolean;
+}, host: {
+    /** The live state the user has toggled this section to, if any. */
+    live: boolean | undefined;
+    /** The row the section yields — the one row rule decides from these two. */
+    title: string | undefined;
+    description: string | undefined;
+    /**
+     * Who is asking and about which section, for the diagnostic only — e.g.
+     * `ObjectForm section 2 of object 'invoice'`. Also its dedupe key.
+     */
+    where: string;
+    /** Record the next live state for this section. */
+    setCollapsed: (next: boolean) => void;
+}): {
+    collapsible: boolean;
+    collapsed: boolean;
+    onToggle?: () => void;
+};
+/**
+ * Project one section configuration onto the `section-divider` row it draws.
+ *
+ * ⭐ THIS IS THE ONE PATH (objectui#9849, triage ruling 2026-09-18:
+ * 「让 section 配置到 divider 的投影只有一条路径」). Before it, six sites across
+ * `ObjectForm.tsx`, `ModalForm.tsx` and `DrawerForm.tsx` each rebuilt the row
+ * key by key, and a key one of them forgot was invisible to the author. A key
+ * added here is added for every arm at once, and a key dropped here is dropped
+ * for every arm at once, which is what makes the loss visible instead of
+ * silent.
+ *
+ * ⭐ AND ONE RULE FOR WHICH ROW (director ruling letter E, maintainer 「同意」).
+ * There is no per-arm gate any more — the enumerated four-way union this
+ * function used to take as a parameter was deleted by that ruling:
+ *
+ *  1. 「Group-level semantics are independent of the heading」 — the ADR-0089
+ *     `visibleWhen` predicate and the objectui#6236 membership claim ride
+ *     EVERY row this function returns, so a headingless group is never
+ *     un-gated, and the claim names only the group's own resolved members, so
+ *     its predicate never hides more than the group it names.
+ *  2. The VISIBLE row exists iff `title || description`
+ *     (`sectionDrawsDividerRow`); with `description` only, it is the blurb-only
+ *     row — no heading span, just the blurb (objectui#9835's shape).
+ *  3. A group with neither, that authored a predicate, still needs a carrier
+ *     for item 1: it gets a CHROME-LESS gate row — no `label`, no
+ *     `description`, so `SectionDivider` renders nothing — which exists only
+ *     to carry the predicate and the claim. It is the same shape `TabbedForm`
+ *     already emits for a degraded single-section form, spelled
+ *     `__section_gate_` like that one. A group with neither and no predicate
+ *     returns no row at all: nothing to draw, nothing to gate.
+ *
+ * The key set, and who owns each member:
+ *
+ *  - `label` — the heading. The arm resolves i18n before handing it over.
+ *  - `description` — the authored blurb (objectui#9779 / #9834 / #9849).
+ *  - `visibleWhen` — ADR-0089's section predicate (#6111). The renderer
+ *    evaluates it on this pseudo-field with the host predicate scope bound
+ *    (#6010), so copying it here is what makes the authored predicate reach an
+ *    evaluator at all.
+ *  - `visibleWhenFault` — the fault direction of that predicate, emitted only
+ *    when the section carries one (a field group's: `'hidden'`,
+ *    objectui#13055). The renderer reads it for the divider's fault fallback.
+ *  - `fields` — the objectui#6236 membership claim: RESOLVED member names, so
+ *    the predicate gates the whole group and not just the heading. The form
+ *    renderer also ends the group's field grid where the claim ends
+ *    (`splitAtUntitledRuns`, `@object-ui/components`, objectui#11777), which is
+ *    how an untitled section after it — the trailing ungrouped bucket, which
+ *    gets no row here — is drawn as its own block instead of under this
+ *    heading. A row that dropped the claim would put those fields back under it.
+ *  - `colSpan` — see `DIVIDER_COL_SPAN`.
+ *  - `collapsible` / `collapsed` / `onToggle` — on the visible row only (the
+ *    control lives on the row), and only when the arm hands over a resolved
+ *    `collapse`; see `SectionDividerSource`.
+ *  - `className` — emitted only when the arm hands one over. objectstack#13626
+ *    ("retire the reads", maintainer ruling 2026-09-01) took this read off
+ *    every arm but `ModalForm`'s explicit-sections push, whose residue is
+ *    preserved here rather than retired in passing: retiring it is a second
+ *    ruling's job, and `sectionStyleKeysRetired-13626` pins the arms that
+ *    already dropped it.
+ *
+ * ⛔ Not read, on any arm: `gridClassName` — a per-section grid needs a
+ * per-section form, which the single-form structure these arms share does not
+ * have.
+ */
+export declare function projectSectionDivider(source: SectionDividerSource): FormField[];
 //# sourceMappingURL=fieldGroups.d.ts.map

package/dist/fieldGroups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fieldGroups.d.ts","sourceRoot":"","sources":["../src/fieldGroups.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,EAAE,EACnB,WAAW,EAAE,OAAO,GACnB,iBAAiB,EAAE,GAAG,IAAI,CAiC5B"}
+{"version":3,"file":"fieldGroups.d.ts","sourceRoot":"","sources":["../src/fieldGroups.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,EAAE,EACnB,WAAW,EAAE,OAAO,GACnB,iBAAiB,EAAE,GAAG,IAAI,CAsD5B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAEpF;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC,iDAAiD;IACjD,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;IACzD,4EAA4E;IAC5E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;CAClF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQhE;AAGD;;;;GAIG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,EACxD,IAAI,EAAE;IACJ,mEAAmE;IACnE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,4EAA4E;IAC5E,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACvC,GACA;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CAAE,CAWrE;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,EAAE,CAkC/E"}

package/dist/fieldWriteGate.d.ts

@@ -0,0 +1,136 @@
+import { SchemaLike } from '@object-ui/core';
+/**
+ * The permission surface this module consumes — structurally the subset of
+ * `usePermissions()` that answers the write question. Declared structurally so
+ * `@object-ui/plugin-form` binds to the two members it actually reads rather
+ * than to the whole context type.
+ */
+export interface FieldWritePrincipal {
+    isLoaded: boolean;
+    checkField(object: string, field: string, action: 'read' | 'write' | 'create'): boolean;
+}
+/** A field-name predicate: `true` when the caller may write that field. */
+export type FieldWriteGate = (fieldName: string) => boolean;
+/**
+ * Build the outbound write gate for one object, or `undefined` when there is
+ * no resolved principal to ask.
+ *
+ * `undefined` rather than an always-true function on purpose: the callers hand
+ * this straight to `sanitizeFormData`, whose option is absent-or-predicate, so
+ * an unresolved principal produces the byte-identical payload it produced
+ * before this gate existed.
+ *
+ * `mode` is required, not optional: it picks the question (objectui#12082),
+ * and a container that forgot it would silently strip a create-only caller's
+ * whole body again. A mode that writes nothing (`view`) gets the edit
+ * question, the stricter of the two.
+ */
+export declare function fieldWriteGate(perms: FieldWritePrincipal | null | undefined, objectName: string, mode: string | undefined): FieldWriteGate | undefined;
+export interface ApplyFieldPermissionsOptions {
+    perms: FieldWritePrincipal | null | undefined;
+    objectName: string;
+    /**
+     * The form's mode, which picks the field question (objectui#12082): `create`
+     * asks the insert rule, any other mode but `view` the update rule. A
+     * `view`-mode form renders everything read-only already.
+     */
+    mode?: string;
+    /**
+     * Optional hint placed on a field the caller may read but not edit, used
+     * only when the field declares no description of its own. `ObjectForm`'s
+     * simple variant is the one container that shows it.
+     */
+    deniedDescription?: string;
+}
+/**
+ * The render half for a FORM: drop what the caller may not READ, and mark what
+ * they may read but not WRITE as non-editable.
+ */
+export declare function applyFieldPermissions<T extends Record<string, any>>(fields: T[] | undefined, { perms, objectName, mode, deniedDescription }: ApplyFieldPermissionsOptions): T[] | undefined;
+/**
+ * The principal surface {@link gateFormFields} reads: the field-level resolver,
+ * the server's effective API operation set for an object (`/me/permissions`
+ * `apiOperations`, objectstack#3391; `undefined` means "no effective set",
+ * which leaves the object's own affordance standing), and the caller's object
+ * grant (`usePermissions().can`, objectui#12082).
+ */
+export interface FormFieldPrincipal extends FieldWritePrincipal {
+    can(object: string, action: 'create' | 'update' | 'delete'): boolean;
+    getObjectApiOperations?: (object: string) => readonly string[] | undefined;
+}
+export interface GateFormFieldsOptions extends ApplyFieldPermissionsOptions {
+    perms: FormFieldPrincipal | null | undefined;
+    /**
+     * The object schema the form resolved (its `managedBy` bucket and
+     * `userActions` opt-ins). `null` while it has not loaded, or when the form
+     * has no metadata source, reads as the default bucket.
+     */
+    objectSchema: SchemaLike | null | undefined;
+}
+/** The form-level affordance {@link closedFormAffordance} can report closed. */
+export type ClosedFormAffordance = 'create' | 'edit';
+/**
+ * Which affordance the form-wide lock found CLOSED for this form, or
+ * `undefined` when the lock does not engage (objectui#11000) — closed by the
+ * managed-object policy, the effective API operation set or, since
+ * objectui#12082, the caller's object grant.
+ *
+ * It is {@link managedModeLocked}, the very predicate {@link gateFormFields}
+ * disables every drawn field on, read for its reason: `create` for a create
+ * form, `edit` for an edit form. The locked form's notice
+ * (`ClosedAffordanceNotice`) and the wizard's navigation gate read THIS, not a
+ * verdict of their own, so a form cannot explain a lock it did not draw, nor
+ * draw one it does not explain.
+ *
+ * A per-field lock never answers here: a field the caller may read but not
+ * edit ({@link applyFieldPermissions}) or a field declared `readonly` locks
+ * that one field while the form's affordance stays open.
+ */
+export declare function closedFormAffordance({ perms, objectName, mode, objectSchema, }: Pick<GateFormFieldsOptions, 'perms' | 'objectName' | 'mode' | 'objectSchema'>): ClosedFormAffordance | undefined;
+/**
+ * The ONE field-gate step every `ObjectForm` layout draws its RESOLVED fields
+ * through (objectui#10612): the default arm (flat and sectioned), `DrawerForm`
+ * and `ModalForm` (sections, derived field groups and flat), and `TabbedForm`,
+ * `SplitForm` and `WizardForm` (sections).
+ *
+ * Two gates, in one pass, so no layout can apply one and skip the other:
+ *
+ *  1. field-level security — {@link applyFieldPermissions}: drop what the
+ *     caller may not READ, lock what they may read but not WRITE;
+ *  2. the form-wide lock — every drawn field is `disabled` when
+ *     {@link managedModeLocked} says the mode's affordance is closed. Only
+ *     `disabled`, not `readOnly`: the default arm's lock always drew a
+ *     disabled input, and the submit button is left as it is.
+ *
+ * Before this step the lock was stamped by the default arm's field generator
+ * alone, so the drawer, modal, tabbed, split and wizard layouts drew live
+ * inputs on a managed object whose write the server refuses (objectui#10613,
+ * folded into objectui#10612). It runs on the resolved list rather than in a
+ * generator, so every drawn field is locked — an inline `customFields` member
+ * and an already-built section entry as much as a field generated from the
+ * object — which is what "blanket" says.
+ *
+ * Entries with no `name` pass through untouched, as in the render pass.
+ */
+export declare function gateFormFields<T extends Record<string, any>>(fields: T[] | undefined, { objectSchema, ...options }: GateFormFieldsOptions): T[] | undefined;
+/**
+ * The render half for a line-items GRID: the same pass over its columns — drop
+ * what the caller may not READ, and lock the cells of what they may read but
+ * not WRITE (objectui#10163).
+ *
+ * ⛔ Not a second gate: the verdict is {@link gateByPermission}'s, the same one
+ * the three form containers render through, so the grid and the form above it
+ * cannot disagree about which field is refused. A column that is refused
+ * replaces any `readonlyWhen` it declared — a lock on every row already covers
+ * every row a narrower lock would. Rows are untouched: whether a line may be
+ * added or removed stays the container's own answer.
+ *
+ * `mode` is the form the grid sits in, and picks the question the cells ask
+ * the same way it does for a form's fields (objectui#12082): a CREATE form's
+ * lines are all new child records, so their cells ask the create question. A
+ * grid anywhere else — an edit form, a record page's line-items block — may
+ * hold existing lines beside new ones, and one lock per column cannot split
+ * per row, so it asks the edit question, as it always did.
+ */
+export declare function applyColumnPermissions<T extends Record<string, any>>(columns: T[] | undefined, { perms, objectName, mode }: Pick<ApplyFieldPermissionsOptions, 'perms' | 'objectName' | 'mode'>): T[] | undefined;
+//# sourceMappingURL=fieldWriteGate.d.ts.map

package/dist/fieldWriteGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldWriteGate.d.ts","sourceRoot":"","sources":["../src/fieldWriteGate.ts"],"names":[],"mappings":"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"}

package/dist/flatFields.d.ts

@@ -1,5 +1,5 @@
 import { FormField } from '@object-ui/types';
-import { SectionFieldsContext } from './sectionFields';
+import { SectionFieldsContext } from './sectionFields.js';
 export interface FlatFieldsContext extends SectionFieldsContext {
     /**
      * The caller's explicit field whitelist, in render order. Entries are field
@@ -7,6 +7,13 @@ export interface FlatFieldsContext extends SectionFieldsContext {
      * object schema declares, in schema order.
      */
     fields?: Array<string | Record<string, any>>;
+    /**
+     * The authored inline members (`schema.customFields`), MERGED over the
+     * generated set exactly as `ObjectForm` merges them — override by name in
+     * place, keep the rest, append the unmatched in authored order
+     * (objectui#10073; the rule lives in `customFieldsMerge.ts`).
+     */
+    customFields?: FormField[];
 }
 /**
  * Build the runtime `FormField` list for a container rendering an object's
@@ -15,7 +22,9 @@ export interface FlatFieldsContext extends SectionFieldsContext {
  * Fields the object schema does not declare are SKIPPED — the flat containers
  * have always dropped them rather than rendering `fromObjectSchema`'s bare
  * `input` stub, and a whitelist naming a field the object does not have is an
- * authoring error the form should not paper over with an untyped control.
+ * authoring error the form should not paper over with an untyped control. A
+ * `customFields` member naming such a field is drawn in its place: the member
+ * is a whole definition, not an untyped stub.
  */
 export declare function buildFlatFields(ctx: FlatFieldsContext): FormField[];
 //# sourceMappingURL=flatFields.d.ts.map

package/dist/flatFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flatFields.d.ts","sourceRoot":"","sources":["../src/flatFields.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAoB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE9E,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;CAC9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,iBAAiB,GAAG,SAAS,EAAE,CAuBnE"}
+{"version":3,"file":"flatFields.d.ts","sourceRoot":"","sources":["../src/flatFields.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAiD,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG3G,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,YAAY,CAAC,EAAE,SAAS,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,iBAAiB,GAAG,SAAS,EAAE,CA8BnE"}

package/dist/formChrome.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * What the submitter is told when a DECLARED `navigateOnSuccess` produced no
+ * destination — objectui#5034 point 2.
+ *
+ * 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.
+ *
+ * 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."
+ *
+ * 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
+ * an acceptance rule into user-visible prose, which objectui#5034 has since
+ * narrowed once already. The diagnosable detail — the template the author
+ * actually wrote — goes to `console.warn` at each call site instead.
+ *
+ * The submitter sees it (it is the toast's description), so it is pack key
+ * `form.navigateRefused` and each form renders `t('form.navigateRefused')`
+ * (objectui#11039). This constant is that key's English default, read from the
+ * table above so there is one spelling of it; `WizardForm` re-exports it,
+ * because that is where it used to live and where its tests import it from.
+ * 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.
+ */
+export declare const NAVIGATE_ON_SUCCESS_REFUSED_NOTE: string;
+/**
+ * The form family's feedback chrome. Falls back to the English table above
+ * when no i18n provider is mounted, or when the mounted catalogue predates
+ * these keys (`form.errorLoading` is the probe).
+ */
+export declare const useFormChromeTranslation: () => {
+    t: (key: string, options?: Record<string, unknown>) => string;
+    language: string;
+} | {
+    t: import('i18next').TFunction<string, undefined>;
+    language: string;
+};
+//# sourceMappingURL=formChrome.d.ts.map

package/dist/formChrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formChrome.d.ts","sourceRoot":"","sources":["../src/formChrome.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA6EH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,gCAAgC,QAA+C,CAAC;AAE7F;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;4BAvHpC,CAAC;;;;;CA0HD,CAAC"}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { ObjectForm } from './ObjectForm';
+import { ObjectForm } from './ObjectForm.js';
 export { ObjectForm };
-export type { ObjectFormComponentProps } from './ObjectForm';
+export type { ObjectFormComponentProps } from './ObjectForm.js';
 /**
  * @deprecated Use `ObjectFormComponentProps`. Renamed in objectui#4650 because
  * `@objectstack/spec/ui` owns `ObjectFormProps` from 17.0.0, where it means the
@@ -8,28 +8,151 @@ export type { ObjectFormComponentProps } from './ObjectForm';
  * props. The alias denotes the SAME type and is kept only so existing importers
  * keep compiling.
  */
-export type { ObjectFormComponentProps as ObjectFormProps } from './ObjectForm';
-export { FormSectionContainer } from './FormSection';
-export type { FormSectionContainerProps } from './FormSection';
-export { applyAutoLayout, inferColumns, inferModalSize, isWideFieldType, isAutoGeneratedFieldType, applyAutoColSpan, containerGridColsFor, filterCreateModeFields, filterSystemFields, filterAutoGeneratedFields, } from './autoLayout';
-export { TabbedForm } from './TabbedForm';
-export type { TabbedFormProps, TabbedFormSchema, FormSectionConfig } from './TabbedForm';
-export { WizardForm } from './WizardForm';
-export type { WizardFormProps, WizardFormSchema } from './WizardForm';
-export { SplitForm } from './SplitForm';
-export type { SplitFormProps, SplitFormSchema } from './SplitForm';
-export { DrawerForm } from './DrawerForm';
-export type { DrawerFormProps, DrawerFormSchema } from './DrawerForm';
-export { ModalForm } from './ModalForm';
-export type { ModalFormProps, ModalFormSchema } from './ModalForm';
-export { EmbeddableForm } from './EmbeddableForm';
-export type { EmbeddableFormProps, EmbeddableFormConfig, EmbeddableFormTexts } from './EmbeddableForm';
-export { FormAnalytics } from './FormAnalytics';
-export type { FormAnalyticsProps, FormSubmissionMetric } from './FormAnalytics';
-export { MasterDetailForm } from './MasterDetailForm';
-export type { MasterDetailFormProps, MasterDetailFormSchema, MasterDetailDetailConfig, } from './MasterDetailForm';
-export { LineItemsPanel } from './LineItemsPanel';
-export type { LineItemsPanelSchema } from './LineItemsPanel';
-export { deriveDetail, deriveColumns, deriveFormFields, findRelationshipField, resolveInlineMode } from './deriveMasterDetail';
-export type { DerivedDetail, InlineMode } from './deriveMasterDetail';
+export type { ObjectFormComponentProps as ObjectFormProps } from './ObjectForm.js';
+export { FormSectionContainer } from './FormSection.js';
+export type { FormSectionContainerProps } from './FormSection.js';
+export { applyAutoLayout, inferColumns, inferModalSize, isWideFieldType, isAutoGeneratedFieldType, applyAutoColSpan, containerGridColsFor, filterCreateModeFields, filterSystemFields, filterAutoGeneratedFields, } from './autoLayout.js';
+export { TabbedForm } from './TabbedForm.js';
+export type { TabbedFormProps, TabbedFormSchema, FormSectionConfig } from './TabbedForm.js';
+export { WizardForm } from './WizardForm.js';
+export type { WizardFormProps, WizardFormSchema, WizardStepConfig } from './WizardForm.js';
+export { SplitForm } from './SplitForm.js';
+export type { SplitFormProps, SplitFormSchema } from './SplitForm.js';
+export { DrawerForm } from './DrawerForm.js';
+export type { DrawerFormProps, DrawerFormSchema } from './DrawerForm.js';
+export { ModalForm } from './ModalForm.js';
+export type { ModalFormProps, ModalFormSchema } from './ModalForm.js';
+export { EmbeddableForm } from './EmbeddableForm.js';
+export type { EmbeddableFormProps, EmbeddableFormConfig, EmbeddableFormTexts } from './EmbeddableForm.js';
+export { FormAnalytics } from './FormAnalytics.js';
+export type { FormAnalyticsProps, FormSubmissionMetric } from './FormAnalytics.js';
+export { MasterDetailForm } from './MasterDetailForm.js';
+export type { MasterDetailFormProps, MasterDetailFormSchema, MasterDetailDetailConfig, } from './MasterDetailForm.js';
+export { LineItemsPanel } from './LineItemsPanel.js';
+export type { LineItemsPanelSchema } from './LineItemsPanel.js';
+export { deriveDetail, deriveColumns, deriveFormFields, findRelationshipField, resolveInlineMode } from './deriveMasterDetail.js';
+export type { DerivedDetail, InlineMode, ChildObjectSchemaLike } from './deriveMasterDetail.js';
+/**
+ * The CREATE-payload rule this package owns, published for the OTHER form
+ * renderer (objectui#6059).
+ *
+ * `omitServerResolvedDefaults` is a pure function over a values object and an
+ * object schema — no React, no registry, no container — and it is the
+ * COMPOSITION of two `@object-ui/core` predicates (`isRuntimeDefault` AND
+ * `isMissingForRequired`, on create only) rather than a third opinion about
+ * either. It stayed module-private through the whole #4047 / #4068 / #4069 /
+ * #4085 / #5683 / #5727 / #5883 chain, so the console's `FormPage` — the SECOND
+ * form renderer in this repo — had to spell that composition out by hand for
+ * #5883, and the next renderer would have had to as well. Neither PREDICATE was
+ * ever copied (both live in `@object-ui/core` precisely so they cannot fork),
+ * but two hand-written copies of the composition are still free to disagree
+ * about a case neither author had in mind. One importable function is not.
+ *
+ * `isRequiredInForm` travels with it because each one's docblock names the
+ * other as its half: excusing a server-owned field from `required` and then
+ * submitting the key anyway is not half a fix, it is no fix. A consumer able to
+ * reach one and not the other can build exactly that state, which is the defect
+ * #4069 and #5883 closed on the two chains separately.
+ *
+ * `optionListDefault` joined them for a named consumer (objectui#13049): the
+ * console's public form page (`/f/:slug`) seeds its own create values and had
+ * no reading of an option's `default: true`, so a required select the server
+ * would default opened empty and the client refused the submit. That page now
+ * calls the very function `schemaDefaultValues` calls (objectui#11914), so the
+ * two renderers cannot disagree about which option is the default. It travels
+ * with its parameter type, `OptionListFieldLike` (objectui#7324).
+ *
+ * Deliberately NOT the rest of `schemaDefaults.ts`. `seedCreateValues`,
+ * `schemaDefaultValues`, `isSeedableDefault`, `isCreateFormMode` and
+ * `SeedContext` are adjacent, not asked for — no consumer outside this package
+ * has needed them, and every added name is published surface somebody then has
+ * to keep. The public form page needed the option-list reading alone: its
+ * literal-default and runtime-default rules were already its own (#5727), and
+ * the precedence gate (`defaultValue == null`) is the caller's. `isRuntimeDefault`
+ * stays out for a stronger reason: it is `@object-ui/core`'s to publish, this
+ * module only re-exports it for its own call sites, and a second published
+ * spelling of one classifier is the very thing #4085 collapsed.
+ */
+export { omitServerResolvedDefaults, isRequiredInForm, optionListDefault } from './schemaDefaults.js';
+/**
+ * The `form.sections[].group` RESOLVER, published for the third form-section
+ * consumer (objectui#8641).
+ *
+ * `resolveSectionGroupReferences` replaces every `{ group: 'x' }` section with
+ * the section that group declares, and returns its input UNCHANGED — the same
+ * array reference — when no section uses the reference form. It is a pure
+ * function over plain data: no React, no registry, no container.
+ *
+ * ## Why it is published rather than copied
+ *
+ * `apps/console`'s `FormPage` has its OWN section builder (`buildSections`),
+ * on none of this package's code path, and it read `sec.fields ?? []` — so a
+ * spec-legal `{ group }` section produced a section with no label and no
+ * fields, measured in the DOM as an empty bordered card with zero inputs on
+ * both the internal `/forms/:name` and public `/f/:slug` routes. That is the
+ * silent-drop class objectui#7051 closed HERE, arriving at a renderer #7051's
+ * fix could not reach.
+ *
+ * The standing constraint of objectui#7051 / objectstack#13855 is that no
+ * assembly rule may be re-implemented on the objectui side — not declared
+ * order, not the empty-group drop, not the ungrouped trailing bucket, not the
+ * collapse / `visibleWhen` passthrough. Every one of those comes from
+ * `deriveFieldGroupLayout` (ADR-0085 §5) through this package's ONE adapter,
+ * `deriveFieldGroupSections`, which this resolver calls. A consumer that
+ * reached for `deriveFieldGroupLayout` directly would have to re-spell the
+ * `collapse` enum -> `{ collapsible, collapsed }` mapping and the `visibleWhen`
+ * passthrough to land on a section shape, which is that constraint's exact
+ * prohibition. So the importable resolver is the only arm that keeps one
+ * assembler and one behaviour for all three consumers.
+ *
+ * This is the same surface decision as objectui#6059's create-payload pair,
+ * for the same file, and it is deliberately as small: the resolver and the
+ * options type its signature requires (objectui#7324's rule — a consumer must
+ * be able to NAME what it passes; a type adds no runtime surface).
+ * `hasSectionGroupReference` stays module-private because the resolver already
+ * answers it by returning its input unchanged, and `resetSectionGroupReports`
+ * stays private because it is this package's own test seam.
+ */
+export { resolveSectionGroupReferences } from './sectionGroups.js';
+export type { ResolveSectionGroupsOptions } from './sectionGroups.js';
+/**
+ * The field name a section entry resolves to — the identity rule of the three
+ * entry shapes `ObjectFormSection.fields` declares, spelled once
+ * (objectui#11615): a bare string is the name, the form view's `{ field }`
+ * entry names its field by `field`, an inline `FormField` by `name`;
+ * `undefined` when the entry names nothing.
+ *
+ * Published beside the resolver because the resolver RETURNS that union, and
+ * objectui#7324's rule applies to reading what a published function hands
+ * back as much as to naming what it takes: a consumer narrowing an entry by
+ * hand reads `.name` off a `{ field }` entry — the second dialect this one
+ * spelling exists to prevent. A pure function over plain data.
+ */
+export { sectionEntryName } from './sectionFields.js';
+/**
+ * The parameter types those published signatures require, so a consumer can
+ * NAME what it must pass (objectui#7324).
+ *
+ * Both were unnameable: `ChildObjectSchemaLike` is the `childSchema` of the
+ * five derive functions exported above, and `FieldDefaultsSchemaLike` is the
+ * `objectSchema` of `omitServerResolvedDefaults`. Neither reached this barrel,
+ * so a host held them in a variable it could not annotate and wrote the shape
+ * out by hand instead — a producer-owned shape copied into every consumer,
+ * which is what `declared = enforced` exists to prevent.
+ *
+ * Two names, not one. They arrived carrying the SAME name (`ObjectSchemaLike`)
+ * in two files, and they are not the same type: measured with `tsc`, the
+ * defaults one is a strict subtype of the child one, and the compiler calls
+ * them mutually assignable ONLY because the child one's field values are
+ * `any` — swap that single `any` for `unknown` and the child -> defaults
+ * direction fails (TS2322). Lifting either under the shared name would have
+ * put a name on this package's public surface that already meant something
+ * else two files over, with nothing in the name to say which.
+ *
+ * These are types, not values: they add no runtime surface, and each is the
+ * type a signature already published requires — not an adjacent name lifted
+ * because it was nearby. `OptionListFieldLike` is the `field` of
+ * `optionListDefault` (objectui#13049), on the same rule.
+ */
+export type { FieldDefaultsSchemaLike, OptionListFieldLike } from './schemaDefaults.js';
 //# sourceMappingURL=index.d.ts.map