@object-ui/plugin-form 17.6.0 → 18.0.0

package/dist/schemaDefaults.d.ts

@@ -1,14 +1,75 @@
 import { isRuntimeDefault } from '@object-ui/core';
 export { isRuntimeDefault };
-/** An object schema as the data source serves it (`{ fields: { [name]: def } }`). */
-interface ObjectSchemaLike {
+/**
+ * An object schema as the data source serves it (`{ fields: { [name]: def } }`),
+ * narrowed to `defaultValue` and the two members the `current_user` seed reads
+ * (`type`, `reference`). The keys the option-list fallback reads
+ * (objectui#11914) sit on the package-local `SeedFieldLike` below instead: the
+ * one published function that reads them, `optionListDefault`, names its own
+ * `OptionListFieldLike` (objectui#13049), and every member added here is
+ * published surface somebody then has to keep.
+ *
+ * Exported and published (objectui#7324) because `omitServerResolvedDefaults`
+ * is published and this is its second parameter: a host with its own form
+ * renderer has to hold that schema in a variable or a prop, and until now it
+ * could not name the variable's type. Structural typing meant such a host
+ * still compiled by writing the shape out by hand — which is a copy of a
+ * producer-owned shape in every consumer, invisible to every gate until the
+ * producer's shape moves.
+ *
+ * `FieldDefaults`, not `ObjectSchema`: `deriveMasterDetail.ts` holds a
+ * different shape that used to carry the same `ObjectSchemaLike` name, and the
+ * two are NOT interchangeable — see `ChildObjectSchemaLike` there. This one is
+ * the stricter of the pair (its field values are pinned, not `any`), so a
+ * value legal here is legal there but not the reverse.
+ *
+ * NOT `@object-ui/types`' `ObjectSchemaMetadata`: that type requires `name`
+ * and requires a `type` on every field. `isCurrentUserSeedField` below reads
+ * the target as `reference`, the one spelling the spec declares and ObjectUI
+ * reads (objectui#11070 round 4).
+ */
+export interface FieldDefaultsSchemaLike {
     fields?: Record<string, {
         defaultValue?: unknown;
         type?: unknown;
         reference?: unknown;
-        reference_to?: unknown;
     } | undefined>;
 }
+/**
+ * One field as the SEEDING half of this module reads it: the published
+ * {@link FieldDefaultsSchemaLike} member set plus the two keys the option-list
+ * fallback reads (objectui#11914) — `options`, and `multiple` for the arity.
+ *
+ * Package-local, and derived from the published type rather than restating
+ * it: seeding is not on the package entry (`schemaDefaultValues` and
+ * `seedCreateValues` are withheld, see `index.tsx`), so the keys only it reads
+ * stay off the published shape, whose members are pinned to what the
+ * published pair reads (`parameterTypesNameable-7324.test.ts`). Every value of
+ * the published type is still a value of this one.
+ */
+type SeedFieldLike = NonNullable<NonNullable<FieldDefaultsSchemaLike['fields']>[string]> & {
+    options?: unknown;
+    multiple?: unknown;
+};
+/**
+ * One field as {@link optionListDefault} reads it: the option list and the two
+ * arity inputs, nothing else (objectui#13049).
+ *
+ * Published because `optionListDefault` is, and a consumer must be able to
+ * name what it passes (objectui#7324). Its own shape rather than a widening of
+ * {@link FieldDefaultsSchemaLike}, whose members are pinned to what the
+ * published `omitServerResolvedDefaults` / `isRequiredInForm` pair reads. A
+ * served object field is assignable to it as it arrives.
+ */
+export interface OptionListFieldLike {
+    type?: unknown;
+    multiple?: unknown;
+    options?: unknown;
+}
+/** An object schema as the seeding half reads it — see {@link SeedFieldLike}. */
+interface SeedSchemaLike {
+    fields?: Record<string, SeedFieldLike | undefined>;
+}
 /**
  * The session facts create-form seeding may draw on (#5683). Callers thread it
  * from `usePermissions()`; every key is optional so existing call sites keep
@@ -76,8 +137,10 @@ export declare function isCreateFormMode(form: {
  *
  * Note this drops the required MARKER (and `aria-required`) too, since both are
  * driven by this one boolean — which is the honest reading: in create mode the
- * user really is not required to provide the value. Surfacing what the server
- * WILL supply is issue #4069's option B, a separate follow-up card.
+ * user really is not required to provide the value. The form renderer says
+ * THAT the server supplies it — "Set automatically when saved." under the
+ * empty control (objectui#12108), keyed on the same classifier. Previewing
+ * WHAT it will supply is issue #4069's option B, still a separate card.
  *
  * The CONDITIONAL spelling (`requiredWhen`) reaches the same verdict, ruled
  * identically in #4085 — but it cannot be decided here, because it is resolved
@@ -95,12 +158,44 @@ export declare function isRequiredInForm(field: {
     defaultValue?: unknown;
 } | null | undefined, isCreateForm: boolean): boolean;
 /**
- * The static `defaultValue`s an object schema declares, as a form-values patch.
+ * The static defaults an object schema declares, as a form-values patch: each
+ * field's `defaultValue`, or — for a field that declares none — the option its
+ * option list marks `default: true` ({@link optionListDefault}).
  *
  * Returns a fresh object (never shared), and `{}` for a missing/!object schema
  * so callers can spread it unconditionally.
  */
-export declare function schemaDefaultValues(objectSchema: ObjectSchemaLike | null | undefined, ctx?: SeedContext): Record<string, unknown>;
+export declare function schemaDefaultValues(objectSchema: SeedSchemaLike | null | undefined, ctx?: SeedContext): Record<string, unknown>;
+/**
+ * The value a field's option list declares as its initial value — the option
+ * marked `default: true` — or `undefined` when it marks none (objectui#11914).
+ *
+ * The client reading of `ObjectQL.resolveOptionDefault` (objectstack#7246),
+ * rule for rule, so a create form preselects exactly what omitting the field
+ * would store:
+ *
+ *   - **Only `default === true`, on the canonical key.** The authoring aliases
+ *     (`isDefault`, `selected`) are normalized by `SelectOptionSchema` before
+ *     metadata is served, and the engine reads the canonical key alone.
+ *   - **A marked option with no value declares nothing** and is skipped.
+ *   - **Single-valued: the FIRST marked option wins** — the schema does not
+ *     dedupe the flag, so declaration order decides.
+ *   - **Multi-valued: every marked option, as an array** — even one, since the
+ *     field stores an array. Arity is `@objectstack/spec`'s `isMultiValueField`,
+ *     the one predicate the engine asks too (`declaredMultiValued`), ⛔ never a
+ *     raw `multiple` read: `multiselect` stores an array without the flag.
+ *
+ * Not gated on `type: 'select'`, as the engine's is not: `options` is a
+ * field-level key, and a field the server defaults must not open empty here.
+ *
+ * Applies only to a field that declares no `defaultValue` — the caller's gate,
+ * not this function's: {@link schemaDefaultValues} reaches it through
+ * `dv == null`, the engine's own presence test, and so must every other
+ * reader. Published on the package entry for the SECOND form renderer, the
+ * console's public form page (objectui#13049), so both renderers seed from
+ * this one reading instead of two.
+ */
+export declare function optionListDefault(field: OptionListFieldLike | null | undefined): unknown;
 /**
  * The initial values a CREATE form opens with: the schema's static defaults,
  * overlaid with whatever the caller supplied.
@@ -110,7 +205,7 @@ export declare function schemaDefaultValues(objectSchema: ObjectSchemaLike | nul
  * carrying state forward), and an explicit `null` from a caller is a real
  * "leave this blank", not an absence.
  */
-export declare function seedCreateValues(objectSchema: ObjectSchemaLike | null | undefined, initial?: Record<string, unknown> | null, ctx?: SeedContext): Record<string, unknown>;
+export declare function seedCreateValues(objectSchema: SeedSchemaLike | null | undefined, initial?: Record<string, unknown> | null, ctx?: SeedContext): Record<string, unknown>;
 /**
  * Drop the fields a CREATE payload must leave to the producer (#4069).
  *
@@ -138,5 +233,5 @@ export declare function seedCreateValues(objectSchema: ObjectSchemaLike | null |
  * column there is a deliberate removal, and dropping the key would silently
  * discard the user's edit.
  */
-export declare function omitServerResolvedDefaults(data: Record<string, unknown>, objectSchema: ObjectSchemaLike | null | undefined): Record<string, unknown>;
+export declare function omitServerResolvedDefaults(data: Record<string, unknown>, objectSchema: FieldDefaultsSchemaLike | null | undefined): Record<string, unknown>;
 //# sourceMappingURL=schemaDefaults.d.ts.map

package/dist/schemaDefaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaDefaults.d.ts","sourceRoot":"","sources":["../src/schemaDefaults.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,OAAO,EAAwB,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAQzE,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAE5B,qFAAqF;AACrF,UAAU,gBAAgB;IACxB,MAAM,CAAC,EAAE,MAAM,CACb,MAAM,EACN;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CACpG,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAGrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GACpE,OAAO,CAET;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACxE,YAAY,EAAE,OAAO,GACpB,OAAO,CAIT;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,EACjD,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBzB;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACxC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,YAAY,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GAChD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB"}
+{"version":3,"file":"schemaDefaults.d.ts","sourceRoot":"","sources":["../src/schemaDefaults.ts"],"names":[],"mappings":"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"}

package/dist/sectionFields.d.ts

@@ -26,7 +26,57 @@ export interface SectionFieldsContext {
      * passes it.
      */
     fieldLabel: (objectName: string, fieldName: string, fallback: string) => string;
+    /**
+     * The authored inline members (`schema.customFields`). A member naming the
+     * field a section entry names is that entry's BASE definition, in place of
+     * the one generated from the object schema — the precedence `ObjectForm`'s
+     * default arm resolves its section members with (`findCustomFieldMember`,
+     * objectui#10254). Only the base moves: the entry's own overrides still
+     * apply on top, by the rules below. Omitted or empty → every base is
+     * generated, as before.
+     */
+    customFields?: readonly FormField[] | null;
+    /**
+     * The parent field POOL the section resolves its members against, for the
+     * one caller that has one: `ObjectForm`'s default arm (`SimpleObjectForm`),
+     * whose pool is built from top-level `fields` (or the object) merged with
+     * `customFields` (objectui#10475).
+     *
+     * When set, {@link buildSectionFields} still walks the section's entries in
+     * AUTHORED order and applies each entry's overrides by the same rules as
+     * every other arm; for a NAME-ONLY entry — shape (1) or (2), which names a
+     * field and leaves its definition to be resolved — two things change, both
+     * the pool's to decide:
+     *
+     *   - membership — an entry naming a field the pool does not hold is
+     *     dropped. That is objectui#9884's INTERSECTION of `fields` and
+     *     `sections`; the caller emits its warning
+     *     (`warnSectionMemberExcludedByFields`), this module only drops;
+     *   - the BASE — the pooled field is what a name string draws and what a
+     *     spec entry's overrides are written onto (a copy), in place of
+     *     `fromObjectSchema` / the member lookup. The pool already resolved the
+     *     member-over-generated precedence, and its generated fields carry the
+     *     default arm's own per-field facts (the lock on a computed `formula` /
+     *     `summary` / `auto_number` field, the input type, the step), which only
+     *     LAYOUT and per-entry overrides may move. The managed-object lock is
+     *     not one of them: every arm applies it after this builder, in
+     *     `gateFormFields` (objectui#10612).
+     *
+     * An already-built runtime FormField entry (shape 3) carrying its own
+     * `name` is its own definition, and the pool decides NOTHING about it: it is
+     * drawn whatever the pool holds, exactly as the pool-less arms draw it
+     * (objectui#11615). The intersection catches a NAME the object does not
+     * declare or `fields` does not list — a typo, a stale name — and an entry
+     * that declares itself names nothing to resolve, so dropping it guarded
+     * nothing and made this arm the one that skipped what the other five drew.
+     * "Self-describing" is `isInlineFieldDef` (`submitTarget.ts`), the one
+     * predicate the submit-target rule already reads.
+     * Omitted → no pool: every entry is drawn, from the bases above.
+     */
+    pool?: readonly FormField[] | null;
 }
+export declare function warnUnresolvedTopLevelField(entry: unknown, objectName: string): void;
+export declare function warnSectionMemberExcludedByFields(memberName: string, objectName: string, sectionLabel?: string): void;
 /**
  * Build a runtime FormField from object-schema metadata for `fieldName`.
  *
@@ -36,13 +86,28 @@ export interface SectionFieldsContext {
  * costs.
  */
 export declare function fromObjectSchema(fieldName: string, ctx: SectionFieldsContext): FormField;
+/**
+ * The field name a section entry resolves to — the identity rule of the three
+ * shapes above, spelled once: a string is the name; a spec entry's identity is
+ * its `field` STRING; an already-built runtime FormField's is its `name`.
+ * `undefined` when the entry names nothing.
+ */
+export declare function sectionEntryName(fieldDef: unknown): string | undefined;
 /**
  * Normalize one section field definition (string | spec object | runtime
  * FormField) into a runtime FormField with a guaranteed `name`.
  */
 export declare function normalizeSectionField(fieldDef: string | Record<string, any>, ctx: SectionFieldsContext): FormField;
-/** Normalize every field def in a section. */
+/**
+ * Normalize every field def in a section, in the section's AUTHORED order.
+ *
+ * With a {@link SectionFieldsContext.pool}, a name-only entry naming a field
+ * the pool does not hold is dropped, and a pooled field is the base the entry
+ * starts from; a self-describing inline entry is drawn as it stands, pooled
+ * or not (objectui#11615); the order stays the section's own either way
+ * (objectui#10475).
+ */
 export declare function buildSectionFields(section: {
-    fields: Array<string | Record<string, any>>;
+    fields?: Array<string | Record<string, any>>;
 }, ctx: SectionFieldsContext): FormField[];
 //# sourceMappingURL=sectionFields.d.ts.map

package/dist/sectionFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sectionFields.d.ts","sourceRoot":"","sources":["../src/sectionFields.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAIlD,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,YAAY,EAAE,GAAG,CAAC;IAClB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sDAAsD;IACtD,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACjF;AA2CD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,SAAS,CAgCxF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtC,GAAG,EAAE,oBAAoB,GACxB,SAAS,CA2FX;AAED,8CAA8C;AAC9C,wBAAgB,kBAAkB,CAChC,OAAO,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;CAAE,EACxD,GAAG,EAAE,oBAAoB,GACxB,SAAS,EAAE,CAEb"}
+{"version":3,"file":"sectionFields.d.ts","sourceRoot":"","sources":["../src/sectionFields.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAOlD,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,YAAY,EAAE,GAAG,CAAC;IAClB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sDAAsD;IACtD,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAChF;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,CAAC;IAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,IAAI,CAAC,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,CAAC;CACpC;AA0FD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAepF;AAkCD,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAaN;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,SAAS,CAmCxF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAMtE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtC,GAAG,EAAE,oBAAoB,GACxB,SAAS,CAEX;AA+HD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;CAAE,EACzD,GAAG,EAAE,oBAAoB,GACxB,SAAS,EAAE,CAyBb"}

package/dist/sectionGroups.d.ts

@@ -0,0 +1,62 @@
+import { ObjectFormSection } from '@object-ui/types';
+/**
+ * The keys `@objectstack/spec` REFUSES beside `group`, measured against
+ * `FormSectionSchema` in `@objectstack/spec` 17.3.0 and pinned in
+ * `__tests__/formSectionGroupReference-7051.test.tsx`.
+ *
+ * There are no override semantics: each of these is something the object's
+ * `fieldGroups` entry declares, so restating one on the referencing section
+ * would be a second writable spelling of one fact. Authored metadata carrying
+ * one never reaches this renderer (the spec door rejects it); a programmatic
+ * SDUI caller, which does not pass that door, is reported instead of quietly
+ * having its key honoured or quietly having it dropped.
+ */
+export declare const GROUP_OWNED_SECTION_KEYS: readonly ["name", "label", "description", "collapsible", "collapsed", "visibleWhen"];
+/**
+ * The keys the spec PERMITS beside `group`. They describe how THIS form lays
+ * the section out, which is the form's business and not the group's, so the
+ * authored value wins over the derived section.
+ */
+export declare const SECTION_LAYOUT_KEYS: readonly ["columns", "pane"];
+/** Test seam — forget which section-group diagnostics have been reported. */
+export declare function resetSectionGroupReports(): void;
+/** Does any section in this list use the reference form? */
+export declare function hasSectionGroupReference(sections: unknown): boolean;
+export interface ResolveSectionGroupsOptions {
+    /** Object name — diagnostics say WHICH object is missing the group. */
+    objectName: string;
+    /** The form's layout. `wizard` is the one the spec bans `group` on. */
+    formType?: string;
+    /**
+     * The object definition (`{ fields, fieldGroups }`), or `null`/`undefined`
+     * while it is still loading. A `group` section is rendered EMPTY until it
+     * arrives — never dropped, see the note on the return value.
+     */
+    objectDef: any;
+    /**
+     * `false` when this form can never load an object definition (no
+     * DataSource), so an unresolvable reference is reported as such instead of
+     * being left to look like a load that never finished.
+     */
+    resolvable?: boolean;
+}
+/**
+ * Replace every `{ group }` section with the section that group declares.
+ *
+ * Returns the SAME array reference when nothing uses the reference form, so a
+ * caller can keep this in a `useMemo` without perturbing any existing form.
+ *
+ * ⚠️ A reference that cannot be resolved yields `{ fields: [] }` — an empty
+ * section — and NOT a dropped one. Both render nothing, which is what the spec
+ * assigns to an unresolvable reference (`deriveFieldGroupLayout` already drops
+ * a declared group nothing references, and `@objectstack/lint`'s
+ * `form-section-group-unknown` is the declared reporter of a dangling key).
+ * The choice between them is forced by THIS surface and was measured: a form
+ * whose `sections` array empties out stops being a sectioned form at all and
+ * falls back to the flat every-field layout, so dropping would make a single
+ * mistyped key render MORE than the author asked for. Emptying renders
+ * exactly nothing, and leaves the array length — which is the wizard's step
+ * count and the container routing's condition — untouched.
+ */
+export declare function resolveSectionGroupReferences(sections: ObjectFormSection[] | undefined, opts: ResolveSectionGroupsOptions): ObjectFormSection[] | undefined;
+//# sourceMappingURL=sectionGroups.d.ts.map

package/dist/sectionGroups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sectionGroups.d.ts","sourceRoot":"","sources":["../src/sectionGroups.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,sFAO3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,8BAA+B,CAAC;AAWhE,6EAA6E;AAC7E,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,4DAA4D;AAC5D,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAKnE;AAcD,MAAM,WAAW,2BAA2B;IAC1C,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,EAAE,GAAG,CAAC;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,iBAAiB,EAAE,GAAG,SAAS,EACzC,IAAI,EAAE,2BAA2B,GAChC,iBAAiB,EAAE,GAAG,SAAS,CAyEjC"}

package/dist/sectionPredicateDiagnostic.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+/**
+ * The one layout arm that still DROPS an authored `FormSection.visibleWhen`
+ * (objectui#6237).
+ *
+ * Of the six layout routes in `ObjectForm`, five honour the predicate:
+ * `split` / `drawer` / `modal` rebuild each section key by key and copy it
+ * (#6111), the flat arm carries it on the `section-divider` pseudo-field
+ * (#6236), and `tabbed` joined them by copying it onto the tab `TabbedForm`
+ * synthesises, where the renderer evaluates it (#6237). `wizard` is the
+ * remainder.
+ *
+ * ⛔ The wizard's gap is a DESIGN boundary, not an oversight, and it is not one
+ * copy line away. A step predicate would be step-boundary reactive against the
+ * ruled live-record reactivity, and it needs navigation, indicator, final-gate
+ * and re-selection semantics that the tab arm's machinery does not supply —
+ * `WizardStepConfig` carries the full measurement. Until that contract is ruled,
+ * an author who writes the key on a wizard is told so rather than watching it do
+ * nothing.
+ *
+ * Since objectstack#13622 (ruled 2026-08-31) the boundary is ALSO enforced at
+ * the author door: `@objectstack/spec` refuses `visibleWhen` on a wizard step
+ * at parse, so authored form-view metadata can no longer arrive here carrying
+ * it. This report is deliberately KEPT (Card R of that ruling): programmatic
+ * SDUI callers do not pass the spec door, and metadata published before the
+ * tightening still round-trips — for both, this warning is the only signal.
+ *
+ * Single-sourced so the runtime report and the pin that holds its wording cannot
+ * drift apart.
+ */
+export declare function sectionPredicateUnsupportedWarning(layout: 'wizard', sectionNames: string): string;
+//# sourceMappingURL=sectionPredicateDiagnostic.d.ts.map

package/dist/sectionPredicateDiagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sectionPredicateDiagnostic.d.ts","sourceRoot":"","sources":["../src/sectionPredicateDiagnostic.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,QAAQ,EAChB,YAAY,EAAE,MAAM,GACnB,MAAM,CASR"}

package/dist/submitTarget.d.ts

@@ -0,0 +1,136 @@
+/**
+ * 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.
+ */
+/**
+ * Does a form have anything to submit TO? — the ONE answer for every renderer
+ * `ObjectForm` routes to (objectui#6300).
+ *
+ * ## What went wrong
+ *
+ * Each of the five variant containers opened `handleSubmit` with
+ *
+ *     if (!dataSource) { await schema.onSuccess?.(data); return data; }
+ *
+ * — a SUCCESS signal emitted without consulting `submitHandler` and without
+ * persisting anything. Measured on `main` with a `submitHandler` supplied and no
+ * `dataSource`, all five read `onSuccess 1 / submitHandler 0`. Through
+ * `MasterDetailForm` — whose parent schema declares BOTH
+ * `submitHandler: submitViaBatch` and `onSuccess: handleSaved` — that early
+ * return reached `handleSaved` directly: a success toast (measured:
+ * `toast.success("Created")`) and, in create mode, a form reset clearing the
+ * line items nobody wrote. Silent data loss in the worst direction, because the
+ * submitter is told it worked.
+ *
+ * ## The rule this module carries
+ *
+ * A form has a submit target when it has EITHER a `dataSource` (it writes) or a
+ * declared `submitHandler` (the host writes — objectui#6176's seam, which needs
+ * no adapter of its own). With neither, exactly one shape is still legitimate:
+ * fields authored INLINE, where the author's `onSuccess` IS the write. Anything
+ * else must refuse, loudly, instead of confirming.
+ *
+ * ## What counts as inline, and why it has two limbs
+ *
+ * Neither limb is a new predicate. Both name a shape this package already
+ * documents as working with no adapter, and the test refuses everything else.
+ *
+ * **(a) `customFields` is non-empty.** `SimpleObjectForm` (`ObjectForm.tsx`)
+ * gates its own carve-out on exactly this, the `object-form` element gate
+ * (`index.tsx`) declares `requiresDataSource={!(schema?.customFields?.length > 0)
+ * && …}` and says so in as many words — *"The one escape hatch is inline
+ * `customFields`, which is exactly what `hasInlineFields` gates on inside the
+ * component, so the two stay in step"* — and `ObjectFormSchema` glosses the key
+ * as *"when used with inline field definitions (without dataSource), this
+ * becomes the primary field source"*.
+ *
+ * **(b) every section field is an inline runtime `FormField`.** This limb is not
+ * optional and not an invention: it is how a sectioned form expresses the same
+ * thing with no `customFields` at all — its sections carry the definitions.
+ * This package's README documents the shape and ships an example of
+ * it, `<WizardForm schema={wizard} />` under the comment *"dataSource omitted:
+ * every step lists inline fields"*, introduced by *"The inline shape is what
+ * lets a wizard run with no data source at all"*. Measured before this module
+ * existed: that example renders and submits. A `customFields`-only test would
+ * have made the repo's own published example throw — which is why the limb is
+ * here.
+ *
+ * The limb is deliberately ALL-or-nothing, and it is the taxonomy
+ * `normalizeSectionField` already keeps: a section field is a name string
+ * (shape 1), a spec `FormFieldSchema` whose identity key `field` is a STRING
+ * (shape 2), or an inline runtime `FormField` carrying its own `name` (shape 3).
+ * Only shape 3 is self-describing; shapes 1 and 2 name fields that only an
+ * object schema — and therefore only an adapter — can resolve. So one bare name
+ * anywhere in the sections means the form DID need metadata it could not get,
+ * and it refuses. Erring that way is the loud direction; the silent one is the
+ * defect.
+ *
+ * `TabbedForm` / `SplitForm` / `WizardForm` receive `customFields` through
+ * `ObjectForm`'s `{...schema}` spread. Until objectui#10254 they neither
+ * declared nor rendered it, and limb (a) read it there only as a SIGNAL; they
+ * now declare it and draw a member a section names, as the drawer and modal do.
+ */
+/** The shape this module reads — deliberately narrower than any form schema. */
+export interface InlineFieldSource {
+    customFields?: unknown;
+    sections?: unknown;
+}
+/**
+ * `normalizeSectionField`'s shape (3): an already-built runtime `FormField`,
+ * carrying its own `name`, needing no object schema to resolve.
+ *
+ * A STRING `field` is the disambiguator for shape (2), the spec
+ * `FormFieldSchema` — there `field` is the field NAME; on a runtime `FormField`
+ * the `field` slot holds the metadata OBJECT. A missing `name` is not treated as
+ * inline either: shape 3 without one is what used to crash the form renderer on
+ * `name.split('.')`, so it is malformed rather than self-describing.
+ *
+ * Exported because it is also what `buildSectionFields` (`sectionFields.ts`)
+ * asks of a section entry before its parent field pool may drop it
+ * (objectui#11615): a self-describing entry is drawn whatever the pool holds,
+ * as the pool-less arms draw it. One predicate, so "inline enough to need no
+ * adapter" and "inline enough to need no pool" cannot drift apart.
+ */
+export declare function isInlineFieldDef(def: unknown): boolean;
+/**
+ * Whether the author declared the form's fields inline, i.e. the form is a
+ * self-contained collector whose `onSuccess` is the write.
+ *
+ * Literally `SimpleObjectForm`'s test, kept in one place so the six renderers
+ * cannot answer it six ways.
+ *
+ * The parameter is `object`, not `InlineFieldSource`: TypeScript's weak-type
+ * check rejects an argument sharing no property with a wholly-optional
+ * interface, so a caller whose schema type declares neither key could not pass
+ * it. `TabbedFormSchema` / `SplitFormSchema` / `WizardFormSchema` declared no
+ * `customFields` while they did not render it, since declaring a field source a
+ * renderer ignores is the declared-≠-enforced shape objectui#6300 set out to
+ * undo; they declare it since objectui#10254, which made them render it.
+ */
+export declare function hasInlineFieldSource(schema: object | null | undefined): boolean;
+/**
+ * The refusal message. `SimpleObjectForm`'s own wording, verbatim, so a host
+ * that already matches on it sees one string from all six renderers.
+ */
+export declare const NO_SUBMIT_TARGET_MESSAGE = "DataSource is required for form submission (inline mode not configured)";
+/**
+ * The refusal itself.
+ *
+ * Thrown from INSIDE each container's persistence chain — as the branch taken
+ * when none of the real routes (host seam / create / OCC-guarded edit) applies
+ * — rather than from a pre-`try` guard, for two reasons:
+ *
+ *  1. it is where the fact belongs: "there is no route to persist by" is a
+ *     verdict about the persistence chain, and expressing it there is also what
+ *     lets TypeScript narrow `dataSource` for the routes that use it, with no
+ *     assertion;
+ *  2. the container's `catch` runs `schema.onError?.(err)` and RETHROWS, so the
+ *     host learns why. That is what turns the `MasterDetailForm` reading above
+ *     from `toast.success("Created")` into `toast.error(<this message>)` with
+ *     the form left intact — the visible half of the fix.
+ */
+export declare function noSubmitTargetError(): Error;
+//# sourceMappingURL=submitTarget.d.ts.map

package/dist/submitTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submitTarget.d.ts","sourceRoot":"","sources":["../src/submitTarget.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAItD;AAkBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAI/E;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,4EACsC,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,IAAI,KAAK,CAE3C"}

package/dist/successBehavior.d.ts

@@ -9,34 +9,53 @@
  * for another entry (`resetOnSuccess`).
  *
  * Kept dependency-free on purpose: importing the redirect guard from
- * EmbeddableForm would create a cycle (EmbeddableForm → ObjectForm → WizardForm
- * → here), so the same-origin check is inlined.
+ * EmbeddableForm would create a cycle (EmbeddableForm -> ObjectForm ->
+ * WizardForm -> here), so the destination test below is local to this module.
  */
 export type { SubmitBehavior } from '@object-ui/types';
 /**
- * Same-origin guard for declarative navigation (relative or absolute URLs).
- *
- * **Scope note (objectui#4989).** This guard used to gate `submitBehavior:
- * { kind: 'redirect' }` too. It no longer does: objectstack#7496 ruled that key
- * RELATIVE-ONLY, and `submitRedirect.ts` gets that verdict from the spec's own
- * `FormViewSchema`. Relative-only is strictly stronger than same-origin — a
- * rooted relative path is same-origin by construction — so keeping this call in
- * that arm as defence-in-depth would add no defence, while its converse (it says
- * yes to `https://own-host/thanks`) was exactly the defect: this consumer
- * accepted a spelling the authoring door now refuses, which is how a rejected
- * spelling stays alive in a corpus.
- *
- * It survives because {@link resolveSuccessNavigate} still needs it. That serves
- * `navigateOnSuccess` — a DIFFERENT declared key with its own `{id}` /
- * `{recordId}` dialect, no relative-only ruling, and its own contract question
- * still open. Deleting the guard would silently widen that key.
- */
-export declare function isSameOriginUrl(rawUrl: string): boolean;
-/**
- * Resolve a `navigateOnSuccess` template into a safe URL: interpolate
- * `{id}` / `{recordId}` from the created/updated record and same-origin-guard it.
- * Returns null when there's no template, no usable id, or the URL fails the
- * guard — callers then fall back to a toast.
+ * Resolve a `navigateOnSuccess` template into the relative destination to
+ * navigate to, or refuse it. Returns null when there is no template, no usable
+ * id, or the resolved value is out of contract — callers then show the success
+ * toast carrying `NAVIGATE_ON_SUCCESS_REFUSED_NOTE`.
+ *
+ * ## The contract (maintainer ruling, 2026-08-17, objectui#5034)
+ *
+ * `navigateOnSuccess` is the pre-ruling ancestor of the `submitBehavior` family,
+ * not a second dialect, and it is **deprecated in favour of `submitBehavior`**
+ * (which already takes precedence over it, pinned). As a compat alias it runs
+ * under the semantics objectstack#7496 ruled for that family:
+ *
+ *   1. **relative paths only.** A same-origin ABSOLUTE value is refused like any
+ *      other out-of-contract value — not routed differently, refused. The
+ *      destination is authored metadata, which is exactly where an address
+ *      somebody else chose gets copied in.
+ *   2. **the interpolated value is URL-escaped** when the destination is built.
+ *   3. the `{id}` / `{recordId}` dialect **stays** for existing authors of this
+ *      key. It is the one part deliberately not converged: the ruling keeps the
+ *      spelling working and points new authoring at `submitBehavior` instead.
+ *
+ * ## Why both halves are needed, and neither substitutes for the other
+ *
+ * The escape is what stops a token from adding path STRUCTURE. Interpolated raw,
+ * `{id}` with an address in it becomes the whole destination, and `/r/{id}` with
+ * `a/b` in it silently grows a path segment. Relative-only is a rule about where
+ * a destination STARTS, so it has nothing to say about structure injected
+ * further along — the argument `submitRedirect.ts` records for the ruled sibling,
+ * which holds here verbatim.
+ *
+ * Conversely the escape alone would not refuse an authored absolute, because the
+ * template is the AUTHOR's and only the substituted value passes through
+ * `encodeURIComponent`. So: escape the data, judge the result.
+ *
+ * ## This can only narrow what is reachable
+ *
+ * Every destination this returns is a relative reference, and every relative
+ * reference was already accepted by the same-origin guard it replaces (a
+ * relative reference cannot carry an authority, RFC 3986, so it always resolves
+ * to the current origin). Escaping only ever maps an id onto one opaque segment.
+ * So the set of addresses reachable through this key is a strict subset of the
+ * set reachable before — there is no value that was refused and is now followed.
  */
 export declare function resolveSuccessNavigate(template: string | undefined, record: any): string | null;
 //# sourceMappingURL=successBehavior.d.ts.map

package/dist/successBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"successBehavior.d.ts","sourceRoot":"","sources":["../src/successBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQvD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,GAAG,GACV,MAAM,GAAG,IAAI,CAMf"}
+{"version":3,"file":"successBehavior.d.ts","sourceRoot":"","sources":["../src/successBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA0DvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,GAAG,GACV,MAAM,GAAG,IAAI,CAWf"}

package/dist/thankYouRedirectCountdown.d.ts

@@ -1,4 +1,4 @@
-import { PendingThankYouRedirect } from './thankYouRedirectNavigation';
+import { PendingThankYouRedirect } from './thankYouRedirectNavigation.js';
 /** One tick per displayed second — matches the `{{seconds}}` unit the copy promises. */
 export declare const REDIRECT_COUNTDOWN_TICK_MS = 1000;
 /**