@wildo-ai/saas-frontend-lib 1.1.3 → 1.1.5

package/dist/esm/core/automated-layout/composite-value-defaults.frontend.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-value-defaults.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/automated-layout/composite-value-defaults.frontend.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The draft a money or duration control starts from, in ONE place.\n *\n * Two consumers need it and must agree: the control itself (its uncontrolled initial value and its\n * empty-display fallback), and `AutomatedLayoutFrontendUtils.getDefaultValueForSchema`, which seeds a\n * new item of a list of money or duration values. When the seed was a bare `0` / `''` it was not a\n * `MoneyValue` / `DurationValue` at all, so an added item could never become valid (#990); when the\n * control picked its currency or unit without looking at what the field allows, the select showed a\n * value that was not one of its options.\n *\n * Both drafts carry a ZERO amount, which the controls render as an empty input. Zero is a real value\n * for either type, so a draft is valid unless the schema bounds it (`minAmount`, `minValue`) — in which\n * case it is refused until the user types, exactly like a blank address.\n */\n\nimport type { z } from 'zod';\nimport {\n  AvailableCurrency,\n  CurrencyAllowed,\n  DurationUnit,\n  getDurationMetadata,\n  getDurationUI,\n  getMoneyMetadata,\n  getMoneyUI,\n  type DurationValue,\n  type MoneyValue,\n} from '@wildo-ai/zod-decorators';\nimport { CURRENCY_INFO_MAP, getCurrencyInfo, getEnabledCurrencies, getMajorCurrencies } from '@wildo-ai/presets-components-models';\n\n/** The currency a money field starts in when its authored default is absent or not selectable. */\nconst FALLBACK_CURRENCY = AvailableCurrency.USD;\n\n/** The unit a duration field starts in when its authored default is absent or not selectable. */\nconst FALLBACK_DURATION_UNIT = DurationUnit.MINUTES;\n\n/** Decimals for a currency the catalogue does not know — the ISO 4217 majority. */\nconst FALLBACK_CURRENCY_DECIMALS = 2;\n\n/**\n * The currencies a money field offers, in catalogue order: every currency, narrowed to the ones the\n * application enables when `appEnabledOnly`, then to the declared `currenciesAllowed` categories.\n */\nexport function listSelectableCurrencies(\n  currenciesAllowed: readonly CurrencyAllowed[] | undefined,\n  appEnabledOnly: boolean,\n): AvailableCurrency[] {\n  let currencies: AvailableCurrency[] = appEnabledOnly ? getEnabledCurrencies() : (Object.keys(CURRENCY_INFO_MAP) as AvailableCurrency[]);\n\n  if (currenciesAllowed && currenciesAllowed.length > 0) {\n    const majorCurrencies = getMajorCurrencies();\n    currencies = currencies.filter((currency) => {\n      const info = CURRENCY_INFO_MAP[currency];\n      return currenciesAllowed.some((category) => {\n        switch (category) {\n          case CurrencyAllowed.FIAT:\n            return !info.isCrypto;\n          case CurrencyAllowed.FIAT_MAJOR:\n            return !info.isCrypto && majorCurrencies.includes(currency);\n          case CurrencyAllowed.CRYPTO:\n            return info.isCrypto;\n          case CurrencyAllowed.CRYPTO_MAJOR:\n            return info.isCrypto && majorCurrencies.includes(currency);\n          default:\n            return false;\n        }\n      });\n    });\n  }\n\n  return currencies;\n}\n\n/**\n * The currency a money field starts in: the authored `moneyUI.edit.defaultCurrency`, else USD — each\n * only if the field can select it. Otherwise the first selectable currency, majors first, in catalogue\n * order (so a crypto-only field starts in BTC). Only a field that can select nothing keeps the\n * authored or fallback code, since there is no better answer to give.\n */\nexport function resolveMoneyFieldDefaultCurrency(schema: z.ZodTypeAny): string {\n  const metadata = getMoneyMetadata(schema);\n  const authored = getMoneyUI(schema)?.edit?.defaultCurrency;\n  const selectable = listSelectableCurrencies(metadata?.currenciesAllowed, metadata?.appEnabledOnly ?? true);\n\n  for (const candidate of [authored, FALLBACK_CURRENCY]) {\n    if (candidate !== undefined && selectable.includes(candidate)) {\n      return candidate;\n    }\n  }\n  const firstSelectable = selectable.find((currency) => CURRENCY_INFO_MAP[currency].isMajor) ?? selectable[0];\n  return firstSelectable ?? authored ?? FALLBACK_CURRENCY;\n}\n\n/** A zero amount in the field's default currency, with that currency's decimals. */\nexport function createMoneyFieldDefaultValue(schema: z.ZodTypeAny): MoneyValue {\n  const currency = resolveMoneyFieldDefaultCurrency(schema);\n  return {\n    amount: 0n,\n    currency,\n    decimals: getCurrencyInfo(currency as AvailableCurrency)?.decimals ?? FALLBACK_CURRENCY_DECIMALS,\n  };\n}\n\n/**\n * The unit a duration field starts in: the authored `durationUI.edit.defaultUnit`, else minutes — each\n * only if `allowedUnits` admits it — otherwise the first allowed unit. A field that declares no\n * `allowedUnits` accepts every unit, so the authored default stands as written.\n */\nexport function resolveDurationFieldDefaultUnit(schema: z.ZodTypeAny): DurationUnit {\n  const allowedUnits = getDurationMetadata(schema)?.allowedUnits;\n  const authored = getDurationUI(schema)?.edit?.defaultUnit;\n\n  if (!allowedUnits || allowedUnits.length === 0) {\n    return authored ?? FALLBACK_DURATION_UNIT;\n  }\n  for (const candidate of [authored, FALLBACK_DURATION_UNIT]) {\n    if (candidate !== undefined && allowedUnits.includes(candidate)) {\n      return candidate;\n    }\n  }\n  return allowedUnits[0];\n}\n\n/** A zero duration in the field's default unit. */\nexport function createDurationFieldDefaultValue(schema: z.ZodTypeAny): DurationValue {\n  return { value: 0, unit: resolveDurationFieldDefaultUnit(schema) };\n}\n"]}

package/dist/esm/core/automated-layout/default-layout-generator.frontend.utils.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { z } from 'zod';
 import type { ShowWhenParams } from '@wildo-ai/zod-decorators';
 import { FieldSchemaType } from '@wildo-ai/zod-decorators';
+import type { AnyFrontendResourceConfiguration } from '../../core/resources/resources.frontend.schemas';
 import type { InheritanceSchemaDefinition } from './automated-layout.frontend.schemas';
 /**
  * Label resolver function signature for layout template generators.
@@ -81,12 +82,17 @@ export interface FormTemplateGeneratorOptions {
  * For resources that need sections, wizard steps, or custom layouts, provide an
  * explicit `layout.edit` template in the resource config.
  *
- * Limitation — ONE, and it is the only authored shape that renders nothing:
- * - **A nested field whose schema is a discriminated union** cannot be laid out.
- *   The generator has no discriminator to switch on below the root, so the field
- *   falls back to a single `<FormField>` and renders nothing. It is reported at
- *   generation time in development (see {@link reportUnrenderableNestedObjectFields});
- *   the remedy is an explicit `layout.edit` template.
+ * - **Discriminated unions nested below the root**: produce an `<ObjectScope>` carrying the union's
+ *   discriminator, its common fields and a `<DiscriminatorSwitch>` (see `renderNestedDiscriminatedUnion`).
+ *
+ * A discriminated-union ROOT given no `inheritanceConfig` derives one from its own schema, so its
+ * variant-only fields are laid out rather than dropped (#525). The only authored shape left that
+ * renders nothing is a union whose discriminator or options cannot be read, and it is reported at
+ * generation time in development (see {@link reportUnrenderableNestedObjectFields}).
+ *
+ * THIS PARAGRAPH SAID, until #525, that a nested discriminated union "cannot be laid out". That had
+ * already been false for the form since the nested-union fix, and the stale sentence sat directly
+ * above the correction recording two earlier false limitations — the same failure, one more time.
  *
  * TWO LIMITATIONS PREVIOUSLY DOCUMENTED HERE WERE FALSE, and the correction is kept
  * because the stale text did measurable damage — it was read as a specification and
@@ -147,5 +153,13 @@ export declare function generateDefaultDisplayTemplate(schema: z.ZodTypeAny): Re
  * @param schema - The root Zod object schema for the resource
  * @returns React.FC component using SummaryLayout + name-only DisplayField components
  */
-export declare function generateDefaultSummaryTemplate(schema: z.ZodTypeAny): React.FC;
+export declare function generateDefaultSummaryTemplate(schema: z.ZodTypeAny, 
+/**
+ * The resource this summary belongs to. OPTIONAL only because the generator predates the
+ * argument; supply it wherever it is available, because without it the identity exclusions
+ * below cannot run and the template renders the record's raw `_id` and tenant id as two
+ * labelled rows — which is exactly what a foreign-key popover used to show for any resource
+ * with no authored `layout.summary`.
+ */
+resourceConfig?: AnyFrontendResourceConfiguration): React.FC;
 //# sourceMappingURL=default-layout-generator.frontend.utils.d.ts.map

package/dist/esm/core/automated-layout/default-layout-generator.frontend.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default-layout-generator.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/automated-layout/default-layout-generator.frontend.utils.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,0BAA0B,CAAC;AAClF,OAAO,EACL,eAAe,EAahB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAavF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;AAMhE;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC;IACrB,iEAAiE;IACjE,UAAU,EAAE,eAAe,CAAC;IAC5B,4EAA4E;IAC5E,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,gDAAgD;IAChD,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,sEAAsE;IACtE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,kBAAkB,CAAC,EAAE,MAAM,GAC1B,eAAe,EAAE,CAgBnB;AAoOD;;;;;;;GAOG;AACH,MAAM,WAAW,4BAA4B;IAC3C,qFAAqF;IACrF,iBAAiB,CAAC,EAAE,2BAA2B,CAAC;IAChD,8EAA8E;IAC9E,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,OAAO,CAAC,EAAE,4BAA4B,GACrC,KAAK,CAAC,EAAE,CA4DV;AAyQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,CAAC,CAAC,UAAU,GACnB,KAAK,CAAC,EAAE,CAyBV;AA2CD;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,CAAC,CAAC,UAAU,GACnB,KAAK,CAAC,EAAE,CA6CV"}
+{"version":3,"file":"default-layout-generator.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../../src/core/automated-layout/default-layout-generator.frontend.utils.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,0BAA0B,CAAC;AAClF,OAAO,EACL,eAAe,EAahB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,+DAA+D,CAAC;AAEtH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAcvF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;AAMhE;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC;IACrB,iEAAiE;IACjE,UAAU,EAAE,eAAe,CAAC;IAC5B,4EAA4E;IAC5E,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,gDAAgD;IAChD,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,sEAAsE;IACtE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,kBAAkB,CAAC,EAAE,MAAM,GAC1B,eAAe,EAAE,CAgBnB;AAgQD;;;;;;;GAOG;AACH,MAAM,WAAW,4BAA4B;IAC3C,qFAAqF;IACrF,iBAAiB,CAAC,EAAE,2BAA2B,CAAC;IAChD,8EAA8E;IAC9E,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,OAAO,CAAC,EAAE,4BAA4B,GACrC,KAAK,CAAC,EAAE,CA4DV;AAyQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,CAAC,CAAC,UAAU,GACnB,KAAK,CAAC,EAAE,CA4BV;AA0ED;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,CAAC,CAAC,UAAU;AACpB;;;;;;GAMG;AACH,cAAc,CAAC,EAAE,gCAAgC,GAChD,KAAK,CAAC,EAAE,CA2DV"}

package/dist/esm/core/automated-layout/default-layout-generator.frontend.utils.js

@@ -3,6 +3,8 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import React from 'react';
 import { FieldSchemaType, getSchemaType, getObjectShape, getObjectKeys, getZodObjectShape, getZodDefArrayProperty, getZodDefStringProperty, isDiscriminatedUnion, unwrapSchema, isVirtualField, isBackendOnlyField, isSummaryField, getShowWhenParams, } from '@wildo-ai/zod-decorators';
 import { AutomatedLayoutFrontendUtils } from './automated-layout.frontend.utils.js';
+import { FrontendResourceUtils } from '../../core/resources/frontend-resource.utils.js';
+import { AutomatedLayoutTemplateKind } from './automated-layout.frontend.schemas.js';
 import { FormLayout } from '../../components/resources/skeleton/FormLayout.js';
 import { DisplayLayout } from '../../components/resources/skeleton/DisplayLayout.js';
 import { SummaryLayout, SummaryTitlePlacement } from '../../components/resources/skeleton/SummaryLayout.js';
@@ -10,6 +12,7 @@ import { FormErrorSummarySlot } from '../../components/resources/skeleton/FormEr
 import { SubmitButton } from '../../components/resources/skeleton/SubmitButton.js';
 import { ObjectScope } from '../../components/resources/skeleton/ObjectScope.js';
 import { DiscriminatorSwitch } from '../../components/resources/skeleton/DiscriminatorSwitch.js';
+import { DisplayDiscriminatorSwitch } from '../../components/resources/skeleton/DisplayDiscriminatorSwitch.js';
 import { FormField } from '../../components/form/automated/FormField.js';
 import { useOptionalFormTemplateContext } from '../../components/form/automated/FormTemplateContext.js';
 import { DisplayField } from '../../components/data-display/DisplayField.js';
@@ -98,76 +101,88 @@ export function extractSchemaFieldList(schema, discriminatorField) {
 function readNestedObjectShape(schema) {
     return getZodObjectShape(schema);
 }
-/**
- * Builds the nested equivalent of the ROOT discriminated-union layout: a scope for
- * the union field, its discriminator, and a `<DiscriminatorSwitch>` carrying each
- * variant's own fields.
- *
- * This is the case the generator used to drop in silence. A field declared
- * `payload: z.discriminatedUnion('t', [...])` is `FieldSchemaType.OBJECT`, so it
- * took the object path, produced no readable shape, fell back to a single
- * `<FormField>` — and `FormFieldComposite` gets `null` from `getObjectShape` for a
- * union, so the authored field rendered NOTHING. Measured 2026-09-08: a two-variant
- * nested union contributed not one element to the generated form.
- *
- * Nothing new is invented here. `<DiscriminatorSwitch>` already resolves its
- * `field` through `useResolvedFieldName`, so placed inside `<ObjectScope name="payload">`
- * it watches `payload.t` and its children resolve to `payload.xv` / `payload.yv`.
- * The root union path (`renderDiscriminatorAndVariants`) composes the same two
- * primitives; the only reason it could not serve here is that it is driven by the
- * caller-supplied `inheritanceConfig`, which describes the ROOT resource schema and
- * says nothing about an arbitrary nested field. The discriminator and the variant
- * literals are read from the schema instead, which is where they already are.
- *
- * Variant fields are filtered to those a variant OWNS: the fields shared by every
- * variant are rendered once, outside the switch, so switching the discriminator
- * does not remount them (and does not, via `shouldUnregister`, drop their values).
- *
- * Returns `null` when the schema is not a usable discriminated union, so callers
- * fall through to their existing behaviour rather than rendering half a union.
- */
-function renderNestedDiscriminatedUnion(field) {
-    const unwrapped = unwrapSchema(field.schema);
+function readDiscriminatedUnionLayout(schema) {
+    const unwrapped = unwrapSchema(schema);
     if (!isDiscriminatedUnion(unwrapped))
         return null;
     const discriminator = getZodDefStringProperty(unwrapped, 'discriminator');
     const options = (getZodDefArrayProperty(unwrapped, 'options') ?? []);
     if (!discriminator || options.length === 0)
         return null;
-    // Fields every variant declares (the union's common base). Rendered once,
-    // outside the switch — see the JSDoc above for why that matters beyond tidiness.
+    const renderable = (fieldSchema) => !!fieldSchema && !isVirtualField(fieldSchema) && !isBackendOnlyField(fieldSchema);
     const perVariantKeys = options.map(option => new Set(getObjectKeys(option)));
     const commonKeys = [...(perVariantKeys[0] ?? new Set())]
         .filter(key => key !== discriminator && perVariantKeys.every(keys => keys.has(key)));
-    const variants = {};
+    const firstShape = getObjectShape(options[0]);
+    const commonFields = firstShape
+        ? commonKeys.filter(key => renderable(firstShape[key])).map(key => createSchemaFieldInfo(key, firstShape[key]))
+        : [];
+    const variants = [];
     for (const option of options) {
         const optionShape = getObjectShape(option);
         if (!optionShape)
             continue;
-        /*
-         * A variant's discriminator is a LITERAL (`z.literal('x')`), and Zod 4 stores a
-         * literal's value in an ARRAY under `values` — the same shape
-         * `resolveDiscriminatedUnionVariant` reads to match a variant to a value. Reading
-         * it here is what keys the switch on the exact authored value rather than on the
-         * variant's position in the options array.
-         */
         const literalValues = getZodDefArrayProperty(optionShape[discriminator], 'values') ?? [];
         const variantValue = literalValues[0];
         if (variantValue === undefined || variantValue === null)
             continue;
-        const variantOnlyKeys = Object.keys(optionShape).filter(key => key !== discriminator
-            && !commonKeys.includes(key)
-            && !isVirtualField(optionShape[key])
-            && !isBackendOnlyField(optionShape[key]));
-        if (variantOnlyKeys.length === 0)
+        variants.push({
+            value: String(variantValue),
+            schema: option,
+            fields: Object.keys(optionShape)
+                .filter(key => key !== discriminator && !commonKeys.includes(key) && renderable(optionShape[key]))
+                .map(key => createSchemaFieldInfo(key, optionShape[key])),
+        });
+    }
+    return { discriminator, commonFields, variants };
+}
+/**
+ * The inheritance config a discriminated-union ROOT implies, for a caller that passed none (#525).
+ *
+ * `generateDefaultFormTemplate` lays out a union root only through `inheritanceConfig`. Without one,
+ * `extractSchemaFieldList` keeps the fields common to every variant and emits no switch, so every
+ * variant-only field was dropped in silence. `ResourceAutomatedForm` always passes the config, so no
+ * screen showed it — which made it a trap for the next caller rather than a live defect. Deriving
+ * the config from the schema closes it by construction instead of by documentation.
+ */
+function deriveInheritanceConfigFromUnionSchema(schema) {
+    const layout = readDiscriminatedUnionLayout(schema);
+    if (!layout)
+        return undefined;
+    return {
+        discriminatorField: layout.discriminator,
+        inheritedSchemas: layout.variants.map(variant => ({
+            discriminatorFieldValue: variant.value,
+            schema: variant.schema,
+        })),
+    };
+}
+/**
+ * Builds the nested FORM equivalent of the root discriminated-union layout: a scope for the union
+ * field, its discriminator, its common fields and a `<DiscriminatorSwitch>` carrying each variant's
+ * own fields.
+ *
+ * This is the case the generator used to drop in silence. A field declared
+ * `payload: z.discriminatedUnion('t', [...])` is `FieldSchemaType.OBJECT`, so it took the object
+ * path, produced no readable shape, fell back to a single `<FormField>` — and `FormFieldComposite`
+ * gets `null` from `getObjectShape` for a union, so the authored field rendered NOTHING.
+ *
+ * `<DiscriminatorSwitch>` resolves its `field` through `useResolvedFieldName`, so placed inside
+ * `<ObjectScope name="payload">` it watches `payload.t` and its children resolve to `payload.xv`.
+ * Every child is a plain `<FormField>` by name, because `FormField` is the dispatcher that already
+ * handles nested objects and arrays.
+ */
+function renderNestedDiscriminatedUnion(field) {
+    const layout = readDiscriminatedUnionLayout(field.schema);
+    if (!layout)
+        return null;
+    const variants = {};
+    for (const variant of layout.variants) {
+        if (variant.fields.length === 0)
             continue;
-        variants[String(variantValue)] = (_jsx(_Fragment, { children: variantOnlyKeys.map(key => _jsx(FormField, { name: key }, key)) }));
+        variants[variant.value] = _jsx(_Fragment, { children: variant.fields.map(f => _jsx(FormField, { name: f.name }, f.name)) });
     }
-    const commonShape = getObjectShape(options[0]);
-    const renderableCommonKeys = commonShape
-        ? commonKeys.filter(key => !isVirtualField(commonShape[key]) && !isBackendOnlyField(commonShape[key]))
-        : [];
-    return (_jsxs(ObjectScope, { name: field.name, children: [_jsx(FormField, { name: discriminator }), renderableCommonKeys.map(key => _jsx(FormField, { name: key }, key)), Object.keys(variants).length > 0 && (_jsx(DiscriminatorSwitch, { field: discriminator, variants: variants }))] }, field.name));
+    return (_jsxs(ObjectScope, { name: field.name, children: [_jsx(FormField, { name: layout.discriminator }), layout.commonFields.map(f => _jsx(FormField, { name: f.name }, f.name)), Object.keys(variants).length > 0 && (_jsx(DiscriminatorSwitch, { field: layout.discriminator, variants: variants }))] }, field.name));
 }
 function dedupeShowWhenWatchFields(params) {
     const conditions = Array.isArray(params.conditions)
@@ -176,29 +191,17 @@ function dedupeShowWhenWatchFields(params) {
     return [...new Set(conditions.map(c => c.field))];
 }
 /**
- * Reports a nested discriminated-union field that will render NOTHING, walking the
- * whole nested tree rather than only its top level.
- *
- * This is the residue of the drop `renderNestedDiscriminatedUnion` fixes. The FORM
- * generator now lays a nested union out, so it reports only a union it could not
- * build (no discriminator, or no options). The DISPLAY generator has no equivalent
- * branch, and the reason is structural rather than unfinished work:
- * `<DiscriminatorSwitch>` picks the live variant with `useWatch`, and a display
- * surface has no form to watch. Picking one there means reading the VALUE — which
- * `resolveDiscriminatedUnionVariant` will do, but the display generator is
- * schema-only at generation time and holds no value. Until that path exists the
- * field renders nothing, and an authored field that renders nothing must say so.
+ * Reports a nested discriminated-union field that will render NOTHING, walking the whole nested tree
+ * rather than only its top level.
  *
- * Deliberately a development-only `console.warn` rather than a throw:
+ * Both generators now lay a nested union out from its schema — the form through
+ * `<DiscriminatorSwitch>`, the display through `<DisplayDiscriminatorSwitch>`, which picks the
+ * variant from the displayed row's value at render time (#525). So this reports only a union that
+ * {@link readDiscriminatedUnionLayout} cannot read: no discriminator, or no options.
  *
- * - Throwing would turn a layout limitation into a broken screen, on the render
- *   path of every resource that has no authored template.
- * - It fires at GENERATION time (once per `generateDefault*Template()` call, which
- *   callers memoize per schema), not per render, so it cannot repeat on keystrokes.
- * - Measured 2026-09-08: neither dogfood application authors a nested
- *   discriminated-union field anywhere, so this is silent on the installed base. It
- *   reaches only the author who would otherwise be looking at a blank space
- *   wondering which layer ate their field, and it names the remedy that works.
+ * Deliberately a development-only `console.warn` rather than a throw: throwing would turn a layout
+ * limitation into a broken screen on every resource without an authored template, and it fires at
+ * GENERATION time (callers memoize per schema), so it cannot repeat on keystrokes.
  */
 function reportUnrenderableNestedObjectFields(fields, templateKind, parentPathPrefix = '') {
     if (process.env.NODE_ENV === 'production')
@@ -208,15 +211,8 @@ function reportUnrenderableNestedObjectFields(fields, templateKind, parentPathPr
             continue;
         const fieldPath = parentPathPrefix ? `${parentPathPrefix}.${field.name}` : field.name;
         if (isDiscriminatedUnion(unwrapSchema(field.schema))) {
-            // The FORM generator now lays a nested union out (`renderNestedDiscriminatedUnion`),
-            // so it only reports one it could not build — a union with no discriminator or
-            // no options. The DISPLAY generator has no equivalent, and the reason is not
-            // laziness: `<DiscriminatorSwitch>` decides the live variant with `useWatch`,
-            // and a display surface has no form to watch. Choosing the variant there means
-            // reading the VALUE (`resolveDiscriminatedUnionVariant` takes one), which the
-            // schema-only display generator does not have at generation time. Until that
-            // path exists, the field renders nothing and must at least say so.
-            if (templateKind === 'form' && renderNestedDiscriminatedUnion(field) !== null)
+            // Both generators lay out any union this reader can read, so only an unreadable one is left.
+            if (readDiscriminatedUnionLayout(field.schema) !== null)
                 continue;
             // eslint-disable-next-line no-console -- authoring-time diagnostic; see the JSDoc above for why this is a warn and not a throw
             console.warn(`[DefaultLayoutGenerator] Field "${fieldPath}" is a nested discriminated union, and the generated `
@@ -258,12 +254,17 @@ function reportUnrenderableNestedObjectFields(fields, templateKind, parentPathPr
  * For resources that need sections, wizard steps, or custom layouts, provide an
  * explicit `layout.edit` template in the resource config.
  *
- * Limitation — ONE, and it is the only authored shape that renders nothing:
- * - **A nested field whose schema is a discriminated union** cannot be laid out.
- *   The generator has no discriminator to switch on below the root, so the field
- *   falls back to a single `<FormField>` and renders nothing. It is reported at
- *   generation time in development (see {@link reportUnrenderableNestedObjectFields});
- *   the remedy is an explicit `layout.edit` template.
+ * - **Discriminated unions nested below the root**: produce an `<ObjectScope>` carrying the union's
+ *   discriminator, its common fields and a `<DiscriminatorSwitch>` (see `renderNestedDiscriminatedUnion`).
+ *
+ * A discriminated-union ROOT given no `inheritanceConfig` derives one from its own schema, so its
+ * variant-only fields are laid out rather than dropped (#525). The only authored shape left that
+ * renders nothing is a union whose discriminator or options cannot be read, and it is reported at
+ * generation time in development (see {@link reportUnrenderableNestedObjectFields}).
+ *
+ * THIS PARAGRAPH SAID, until #525, that a nested discriminated union "cannot be laid out". That had
+ * already been false for the form since the nested-union fix, and the stale sentence sat directly
+ * above the correction recording two earlier false limitations — the same failure, one more time.
  *
  * TWO LIMITATIONS PREVIOUSLY DOCUMENTED HERE WERE FALSE, and the correction is kept
  * because the stale text did measurable damage — it was read as a specification and
@@ -295,9 +296,9 @@ function reportUnrenderableNestedObjectFields(fields, templateKind, parentPathPr
  * @returns React.FC — a component function (memoize with useMemo/useRef for stable identity)
  */
 export function generateDefaultFormTemplate(schema, options) {
-    const inheritanceConfig = options?.inheritanceConfig;
+    const inheritanceConfig = options?.inheritanceConfig ?? deriveInheritanceConfigFromUnionSchema(schema);
     const fields = extractSchemaFieldList(schema, inheritanceConfig?.discriminatorField);
-    reportUnrenderableNestedObjectFields(fields, 'form');
+    reportUnrenderableNestedObjectFields(fields, AutomatedLayoutTemplateKind.FORM);
     const showSubmit = options?.includeSubmitButton !== false;
     const showErrorSummary = options?.includeErrorSummary !== false;
     if (fields.length === 0) {
@@ -502,28 +503,57 @@ function evaluateShowWhenFromWatch(params, watchValues, allWatchFields) {
  * @returns React.FC component using DisplayLayout + name-only DisplayField components
  */
 export function generateDefaultDisplayTemplate(schema) {
+    // A discriminated-union ROOT (a polymorphic resource's read DTO) goes through the same reader as a
+    // nested union. `extractSchemaFieldList` keeps only the fields common to every variant, so without
+    // this a generated read view showed none of a variant's own fields (#525).
+    const rootUnion = readDiscriminatedUnionLayout(schema);
+    if (rootUnion) {
+        const UnionDisplayTemplate = () => (_jsx(DisplayLayout, { children: renderDisplayUnionBody(rootUnion) }));
+        return UnionDisplayTemplate;
+    }
     const fields = extractSchemaFieldList(schema);
-    // Same nested-union limitation as the form generator, reported at the same
-    // moment — the display side falls back to a `<DisplayField>` that resolves no
-    // child shape and renders nothing, so the silence is identical.
-    reportUnrenderableNestedObjectFields(fields, 'display');
+    reportUnrenderableNestedObjectFields(fields, AutomatedLayoutTemplateKind.DISPLAY);
     if (fields.length === 0) {
         const EmptyDisplayTemplate = () => _jsx(DisplayLayout, {});
         return EmptyDisplayTemplate;
     }
-    const renderDisplayField = (field) => {
-        if (field.schemaType === FieldSchemaType.OBJECT) {
-            return renderDisplayObjectScope(field);
-        }
-        return _jsx(DisplayField, { name: field.name }, field.name);
-    };
-    const DefaultDisplayTemplate = () => (_jsx(DisplayLayout, { children: fields.map(renderDisplayField) }));
+    const DefaultDisplayTemplate = () => (_jsx(DisplayLayout, { children: fields.map(renderDisplayFieldNode) }));
     return DefaultDisplayTemplate;
 }
+/** One generated display node: an OBJECT field becomes a scope, anything else a name-only `<DisplayField>`. */
+function renderDisplayFieldNode(field) {
+    if (field.schemaType === FieldSchemaType.OBJECT) {
+        return renderDisplayObjectScope(field);
+    }
+    return _jsx(DisplayField, { name: field.name }, field.name);
+}
+/**
+ * The display body of a discriminated union: its discriminator, its common fields, and a
+ * `<DisplayDiscriminatorSwitch>` that picks the variant from the displayed row at render time.
+ *
+ * Every variant's fields are EMITTED and only the row's variant RENDERS. That keeps the generator
+ * schema-only, which is what it is — the alternative, threading the row into the generator, would
+ * make the template depend on data and defeat the memoization callers rely on (#525).
+ */
+function renderDisplayUnionBody(layout) {
+    const variants = {};
+    for (const variant of layout.variants) {
+        if (variant.fields.length === 0)
+            continue;
+        variants[variant.value] = _jsx(_Fragment, { children: variant.fields.map(renderDisplayFieldNode) });
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(DisplayField, { name: layout.discriminator }), layout.commonFields.map(renderDisplayFieldNode), Object.keys(variants).length > 0 && (_jsx(DisplayDiscriminatorSwitch, { field: layout.discriminator, variants: variants }))] }));
+}
 /**
  * Renders a nested OBJECT field for display using ObjectScope + recursive DisplayField.
  */
 function renderDisplayObjectScope(field) {
+    // BEFORE the shape read: a union answers it with an empty shape and would fall through to a
+    // `<DisplayField>` that resolves no child shape and renders nothing — the drop #525 fixed.
+    const unionLayout = readDiscriminatedUnionLayout(field.schema);
+    if (unionLayout) {
+        return (_jsx(ObjectScope, { name: field.name, children: renderDisplayUnionBody(unionLayout) }, field.name));
+    }
     const innerShape = readNestedObjectShape(field.schema);
     const innerKeys = Object.keys(innerShape);
     const renderableKeys = innerKeys.filter(k => {
@@ -533,19 +563,7 @@ function renderDisplayObjectScope(field) {
     if (renderableKeys.length === 0) {
         return _jsx(DisplayField, { name: field.name }, field.name);
     }
-    return (_jsx(ObjectScope, { name: field.name, children: renderableKeys.map(key => {
-            const childSchema = innerShape[key];
-            const childType = getSchemaType(childSchema);
-            if (childType === FieldSchemaType.OBJECT) {
-                const nestedField = {
-                    name: key,
-                    schema: childSchema,
-                    schemaType: childType,
-                };
-                return renderDisplayObjectScope(nestedField);
-            }
-            return _jsx(DisplayField, { name: key }, key);
-        }) }, field.name));
+    return (_jsx(ObjectScope, { name: field.name, children: renderableKeys.map(key => renderDisplayFieldNode(createSchemaFieldInfo(key, innerShape[key]))) }, field.name));
 }
 // =============================================================================
 // SUMMARY TEMPLATE GENERATION
@@ -563,7 +581,15 @@ function renderDisplayObjectScope(field) {
  * @param schema - The root Zod object schema for the resource
  * @returns React.FC component using SummaryLayout + name-only DisplayField components
  */
-export function generateDefaultSummaryTemplate(schema) {
+export function generateDefaultSummaryTemplate(schema, 
+/**
+ * The resource this summary belongs to. OPTIONAL only because the generator predates the
+ * argument; supply it wherever it is available, because without it the identity exclusions
+ * below cannot run and the template renders the record's raw `_id` and tenant id as two
+ * labelled rows — which is exactly what a foreign-key popover used to show for any resource
+ * with no authored `layout.summary`.
+ */
+resourceConfig) {
     // Union-aware shape (matches the display/form generators): `getObjectShape`
     // returns null for a discriminated union, so a polymorphic resource with no
     // authored `layout.summary` would otherwise fall into the empty branch and
@@ -581,19 +607,31 @@ export function generateDefaultSummaryTemplate(schema) {
         const EmptySummaryTemplate = () => (_jsx(SummaryLayout, { titlePlacement: SummaryTitlePlacement.TEMPLATE_OWNED }));
         return EmptySummaryTemplate;
     }
-    // Summaries are `isSummaryField`-scoped (a DIFFERENT axis from the display
-    // view's all-non-hidden selection), so — unlike the display generator — we do
-    // NOT exclude virtual fields: a virtual field can legitimately be an authored
-    // summary field, and `ResourceLayoutUtils.detectSummaryFields` (the sibling
-    // path feeding table columns + card bodies) includes them too. We keep them in
-    // sync; only backend-only fields (no client value) are dropped.
+    // Summaries are `isSummaryField`-scoped (a DIFFERENT axis from the display view's
+    // all-non-hidden selection), so — unlike the display generator — we do NOT exclude virtual
+    // fields: a virtual field can legitimately be an authored summary field, and
+    // `FrontendResourceUtils.detectSummaryFields` (the sibling path feeding table columns and
+    // list-card bodies) includes them too.
+    //
+    // Two kinds of field ARE dropped, on BOTH branches below. Backend-only fields, because they
+    // carry no client value. And IDENTITY PLUMBING — anything `_`-prefixed, the resource's own
+    // field identifier, the primary-scope column — because those name the row rather than
+    // describe it.
+    //
+    // That second exclusion is why this takes a `resourceConfig` at all. `detectSummaryFields`
+    // has always applied it and this generator never did, so two paths answering the same
+    // question ("which fields does a summary show?") disagreed, and the disagreement was visible:
+    // a foreign-key popover on a resource with no authored `layout.summary` opened with a raw
+    // object id and a tenant id as its first two rows. They now share ONE predicate rather than a
+    // comment asserting they are in step.
+    const isReadable = (key) => !FrontendResourceUtils.isIdentityOnlySummaryField(key, resourceConfig);
     const summaryKeys = keys.filter(key => {
         const fieldSchema = shape[key];
-        return !isBackendOnlyField(fieldSchema) && isSummaryField(fieldSchema);
+        return isReadable(key) && !isBackendOnlyField(fieldSchema) && isSummaryField(fieldSchema);
     });
     const targetKeys = summaryKeys.length > 0
         ? summaryKeys
-        : keys.filter(key => !isBackendOnlyField(shape[key]));
+        : keys.filter(key => isReadable(key) && !isBackendOnlyField(shape[key]));
     const DefaultSummaryTemplate = () => (_jsx(SummaryLayout, { titlePlacement: SummaryTitlePlacement.TEMPLATE_OWNED, children: targetKeys.map(key => (_jsx(DisplayField, { name: key }, key))) }));
     return DefaultSummaryTemplate;
 }