@wildo-ai/saas-models 1.1.5 → 1.1.6

package/dist/esm/resources/utils/resources-config-operations.dtos-builder.utils.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { markEmbeddedResourceSchema } from '../embedded-resource-mark.shared.utils.js';
 import { CoreResourceOperation } from '../resources.shared.core.definitions.js';
 import { wrapRequestDtoAsBulk, resolveBulkOperationMaxSelection, DataMode, OPERATION_VARIANT_KEY, createPaginationResponseMetadataSchema, DEFAULT_LIST_PAGE_CEILING, DEFAULT_SEARCH_PAGE_CEILING, getChildDirectionRelationships, getParentDirectionRelationships, ResourceGeneratedOperationKind } from '../resources-config.shared.schemas.js';
 import { ResourceRelationshipCardinality, isOneToOneCardinality, isArrayCardinality, getDefaultResponseSchemaForOperation, isOutputEnvelopeOperation, operationShouldHaveRequestDto, DefaultBulkDeleteResponseSchema, CONTEXT_AUTO_POPULATED_FIELD_IDENTIFIERS, createOrUpdateMandatoryDiscardFields } from '../resources.shared.schemas.js';
@@ -9,7 +10,7 @@ import { ResourcesSummaryUtils } from './resources-summary.utils.js';
 import { RepositoryDtoBuilderUtils } from './repository-dto-builder.utils.js';
 import { stripTemplatableFileFieldsRecursively as stripTemplatableFileFieldsSchema, } from './templatable-file-fields.shared.utils.js';
 import { widenFileFieldsForPopulatedReads } from './populated-file-fields.shared.utils.js';
-import { describeCaughtError } from '../../errors/errors.shared.utils.js';
+import { describeCaughtError } from '../../errors/caught-error-description.shared.utils.js';
 /**
  * Canonical placeholder shown to clients in place of a `.isWriteOnlySecret()`
  * field's real value. It doubles as the write-back sentinel: when a client
@@ -19,6 +20,22 @@ import { describeCaughtError } from '../../errors/errors.shared.utils.js';
  * single constant so the output mask and the input sentinel never drift.
  */
 export const WRITE_ONLY_SECRET_MASK = '••••••••';
+function createDtoDerivationMemoScope() {
+    return {
+        networkBoundaryCoercion: new WeakMap(),
+        backendOnlyStrip: new WeakMap(),
+        backendOnlyStripKeepingReturnedAtCreation: new WeakMap(),
+        contextRelative: new WeakMap(),
+        clientContextRelative: new WeakMap(),
+    };
+}
+/** One memo scope per resource configuration object; see {@link DtoDerivationMemoScope}. */
+const DTO_DERIVATION_MEMO_SCOPE_BY_RESOURCE = new WeakMap();
+/**
+ * The scope `createApiParsingSchema` runs in. Its callers parse configuration and wire payloads with
+ * the result; none of them is an operation DTO, so no per-resource overlay can reach it.
+ */
+const API_PARSING_MEMO_SCOPE = createDtoDerivationMemoScope();
 /**
  * Type guard to check if schema is a ZodAny
  * In Zod v4, any schemas have type: "any"
@@ -27,6 +44,23 @@ function isZodAny(schema) {
     return hasZodType(schema, 'any');
 }
 export class ResourcesConfigOperationsDtosBuilderUtils {
+    /**
+     * The memo scope of the resource whose DTOs are being built, or `null` outside a resource build.
+     * The builder is synchronous, so a scope set on entry and restored on exit cannot leak into
+     * another resource's build. See {@link DtoDerivationMemoScope}.
+     */
+    static activeMemoScope = null;
+    /** Run `derive` with `scope` active, restoring whatever was active before. */
+    static withMemoScope(scope, derive) {
+        const previousScope = this.activeMemoScope;
+        this.activeMemoScope = scope;
+        try {
+            return derive();
+        }
+        finally {
+            this.activeMemoScope = previousScope;
+        }
+    }
     /**
      * Carry field/schema decorators across a wrapper or leaf rebuild.
      *
@@ -42,6 +76,34 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
         if (sourceMetadata !== undefined) {
             rebuilt[SCHEMA_METADATA] = sourceMetadata;
         }
+        this.preserveRegistryMetadata(source, rebuilt);
+        return rebuilt;
+    }
+    /**
+     * Carry Zod's own `z.globalRegistry` metadata across a rebuild (#1625).
+     *
+     * That registry is where `.describe()` and `.meta()` live: the description the API reference
+     * publishes, and the mark naming the resource an embedded record belongs to
+     * (`EMBEDDED_RESOURCE_SCHEMA_KEY`). A clone keeps it through Zod's parent link; a fresh
+     * `z.object(...)` does not. So every rebuild here (backend-only stripping, date coercion, omission)
+     * used to publish the rebuilt object undescribed, and a response whose records the DTO builder
+     * rebuilt lost its embedded-record mark. Measured on the generated file-regenerate response: its
+     * `file` and `resource` descriptions and the mark all disappeared before the DTO was used.
+     *
+     * Carried even when fields were omitted: an object's description and the resource its record
+     * belongs to do not depend on which of its fields a DTO exposes. `id` is NOT carried: it names ONE
+     * schema, and Zod refuses to register the same id twice. Nothing is overwritten on a rebuilt schema
+     * that already has its own registration.
+     */
+    static preserveRegistryMetadata(source, rebuilt) {
+        if (source === rebuilt || z.globalRegistry.has(rebuilt))
+            return rebuilt;
+        const registered = z.globalRegistry.get(source);
+        if (registered === undefined)
+            return rebuilt;
+        const { id: _id, ...carried } = registered;
+        if (Object.keys(carried).length > 0)
+            z.globalRegistry.add(rebuilt, carried);
         return rebuilt;
     }
     static buildSchemaWithInheritance(mainSchema, inheritanceDefinition) {
@@ -74,6 +136,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
             ? z.object(rebuiltShape).catchall(sourceCatchall)
             : z.object(rebuiltShape);
         if (options?.preserveChecks === false) {
+            this.preserveRegistryMetadata(schema, rebuiltSchema);
             return rebuiltSchema;
         }
         const checks = getZodDefArrayProperty(schema, 'checks');
@@ -104,6 +167,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
         if (sourceMetadata !== undefined) {
             rebuiltSchema[SCHEMA_METADATA] = sourceMetadata;
         }
+        this.preserveRegistryMetadata(schema, rebuiltSchema);
         return rebuiltSchema;
     }
     /**
@@ -202,6 +266,17 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
      * @returns Operation with all DTOs pre-computed and stored
      */
     static buildAllOperationDtos(operation, resourceConfig, registry) {
+        // Every operation of one resource shares the resource's derivation memos, and no other
+        // resource can see them — see `DtoDerivationMemoScope` for why the boundary is the resource.
+        let scope = DTO_DERIVATION_MEMO_SCOPE_BY_RESOURCE.get(resourceConfig);
+        if (scope === undefined) {
+            scope = createDtoDerivationMemoScope();
+            DTO_DERIVATION_MEMO_SCOPE_BY_RESOURCE.set(resourceConfig, scope);
+        }
+        return this.withMemoScope(scope, () => this.buildAllOperationDtosInResourceScope(operation, resourceConfig, registry));
+    }
+    /** {@link buildAllOperationDtos}, run inside its resource's memo scope. */
+    static buildAllOperationDtosInResourceScope(operation, resourceConfig, registry) {
         // 1. Apply inheritance to mainSchema (from resourceConfig.inheritenceSchemaDefinition)
         const inheritenceSchemaDefinition = resourceConfig.inheritenceSchemaDefinition;
         const enhancedMainSchema = (inheritenceSchemaDefinition
@@ -419,7 +494,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
         const contextBaseDto = isListOrSearch
             ? this.extractPaginatedCollectionItemDto(responseDto, effectiveOperation)
             : responseDto;
-        const contextDto = this.addRelationshipPlaceholders(contextBaseDto, operation.resourceRelationships, effectiveOperation, registry);
+        const contextDto = this.addRelationshipPlaceholders(contextBaseDto, operation.resourceRelationships, effectiveOperation, registry, true);
         // 7. Build internalDto base (before variant overrides):
         //    - Start with mainSchema (with inheritance)
         //    - Include backend-only fields (DO NOT strip)
@@ -767,7 +842,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 const modifiedOptions = options.map(option => this.applyCreateOmissionsToSchema(option));
                 // Recreate discriminated union with modified variants
                 if (modifiedOptions.length >= 2) {
-                    return z.discriminatedUnion(discriminator, modifiedOptions);
+                    return this.preserveRegistryMetadata(mainSchema, z.discriminatedUnion(discriminator, modifiedOptions));
                 }
                 else if (modifiedOptions.length === 1) {
                     return modifiedOptions[0];
@@ -1098,7 +1173,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 const modifiedOptions = options.map(option => this.applyVirtualFieldExclusionToSchema(option));
                 // Recreate discriminated union with modified variants
                 if (modifiedOptions.length >= 2) {
-                    return z.discriminatedUnion(discriminator, modifiedOptions);
+                    return this.preserveRegistryMetadata(mainSchema, z.discriminatedUnion(discriminator, modifiedOptions));
                 }
                 else if (modifiedOptions.length === 1) {
                     return modifiedOptions[0];
@@ -1977,7 +2052,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                     : option);
                 if (extendedOptions.every((option) => isZodObject(option))) {
                     if (extendedOptions.length >= 2) {
-                        return z.discriminatedUnion(discriminator, extendedOptions);
+                        return this.preserveRegistryMetadata(baseDto, z.discriminatedUnion(discriminator, extendedOptions));
                     }
                     if (extendedOptions.length === 1) {
                         return extendedOptions[0];
@@ -2032,7 +2107,8 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
             const childConfig = resourceRegistry.get(compiledRel.resourceType2);
             if (!childConfig)
                 continue;
-            const childSchema = this.buildNestedChildSchema(compiledRel, nestedConfig, operation, childConfig.mainSchema, resourceRegistry);
+            // A nested write carries records of the CHILD resource, so it is described by the child (#1625).
+            const childSchema = markEmbeddedResourceSchema(this.buildNestedChildSchema(compiledRel, nestedConfig, operation, childConfig.mainSchema, resourceRegistry), String(compiledRel.resourceType2));
             // Add nested field (array for 1:N/N:N, object for 1:1)
             nestedFields[fieldName] = isArrayCardinality(compiledRel.cardinality2)
                 ? z.array(childSchema).optional()
@@ -2068,7 +2144,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
             const childConfig = resourceRegistry.get(compiledRel.resourceType2);
             if (!childConfig)
                 continue;
-            const childSchema = this.getChildSchemaForDataMode(childConfig.mainSchema, readConfig.dataMode);
+            const childSchema = markEmbeddedResourceSchema(this.getChildSchemaForDataMode(childConfig.mainSchema, readConfig.dataMode), String(compiledRel.resourceType2));
             // Add nested field (array for 1:N/N:N, object for 1:1)
             nestedFields[fieldName] = isArrayCardinality(compiledRel.cardinality2)
                 ? z.array(childSchema).optional()
@@ -2175,6 +2251,32 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
      * @returns New schema without backend-only fields
      */
     static stripBackendOnlyFields(schema, options) {
+        /*
+         * Memoized by input identity within the active resource scope, per effective mode (#1587;
+         * see {@link DtoDerivationMemoScope}). The two options only ever act
+         * TOGETHER — a field is kept for `isReturnedAtCreation` exactly when both are set for CREATE —
+         * so they collapse to one boolean, and the walk is otherwise a pure function of the schema.
+         * Without the memo every operation rebuilt its nested objects afresh, which also defeated the
+         * network-boundary coercion memo downstream: that one is keyed by identity too, and a fresh
+         * nested object is never a hit.
+         */
+        const keepsReturnedAtCreation = options?.respectIsReturnedAtCreation === true
+            && options.operationType === CoreResourceOperation.CREATE;
+        const scope = this.activeMemoScope;
+        if (scope === null)
+            return this.stripBackendOnlyFieldsUncached(schema, options);
+        const memo = keepsReturnedAtCreation
+            ? scope.backendOnlyStripKeepingReturnedAtCreation
+            : scope.backendOnlyStrip;
+        const cached = memo.get(schema);
+        if (cached !== undefined)
+            return cached;
+        const stripped = this.stripBackendOnlyFieldsUncached(schema, options);
+        memo.set(schema, stripped);
+        return stripped;
+    }
+    /** The uncached walk behind {@link stripBackendOnlyFields}; recursion goes through the memo. */
+    static stripBackendOnlyFieldsUncached(schema, options) {
         // Handle discriminated unions - strip from all variants
         const zodType = getZodType(schema);
         if (zodType === 'union') {
@@ -2184,12 +2286,25 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 const strippedOptions = unionOptions.map((option) => this.stripBackendOnlyFields(option, options));
                 // Recreate discriminated union with modified variants
                 if (strippedOptions.length >= 2) {
-                    return z.discriminatedUnion(discriminator, strippedOptions);
+                    return this.preserveRegistryMetadata(schema, z.discriminatedUnion(discriminator, strippedOptions));
                 }
                 else if (strippedOptions.length === 1) {
                     return strippedOptions[0];
                 }
             }
+            // A PLAIN union is stripped option by option too. The context placeholder for a related
+            // record is exactly this shape — `z.union([typedRelative, untypedRelative])`, with the typed
+            // branch built from the related resource's full schema so the service-layer DTO can carry its
+            // backend-only fields. Returning it unchanged left those fields in the CLIENT response DTO, so
+            // the API reference published e.g. `application.ownerOrganizationSerializationToken` on every
+            // context read that embeds the application (#1625).
+            if (!discriminator && unionOptions && unionOptions.length >= 2) {
+                const strippedOptions = unionOptions.map((option) => this.stripBackendOnlyFields(option, options));
+                if (strippedOptions.every((option, index) => option === unionOptions[index])) {
+                    return schema;
+                }
+                return this.preserveRegistryMetadata(schema, z.union(strippedOptions));
+            }
             return schema;
         }
         // Handle arrays - strip from array element schema.
@@ -2295,7 +2410,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
      * ```
      */
     static createApiParsingSchema(schema) {
-        return this.applyNetworkBoundaryCoercion(schema);
+        return this.withMemoScope(API_PARSING_MEMO_SCOPE, () => this.applyNetworkBoundaryCoercion(schema));
     }
     /**
      * Recursively transpose the two network-boundary leaf types that do NOT survive
@@ -2337,8 +2452,36 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
      *
      * @param schema - Schema to transform (typically a database/internal schema with z.date()/z.bigint())
      * @returns New schema with coerced dates + string-accepting bigints
+     *
+     * **Memoized by input identity, and idempotent (#1587).** The walk is a pure function of the
+     * schema instance it is given, and the registry calls it on the SAME sub-schemas over and over:
+     * one registry build made 263,963 calls over 69,771 distinct inputs, 14,627 of them on a schema
+     * this function had itself just produced (`responseDtoInternal` coerced, then coerced again).
+     * Every call that reached an object containing a date rebuilt that object, so 146,352 calls
+     * returned a NEW tree. Zod 4 classic installs ~40 closures on every instance, which is why one
+     * resource registry retained ~735 MB, and why a platform process holding two of them outgrew a
+     * 2 GB heap and died in INIT.
+     *
+     * Every metadata write in this builder targets a freshly created instance, so sharing a coerced
+     * output among one resource's DTOs is safe. The memo is scoped to that resource, and why it must
+     * not be wider is on {@link DtoDerivationMemoScope}.
      */
     static applyNetworkBoundaryCoercion(schema) {
+        const memo = this.activeMemoScope?.networkBoundaryCoercion;
+        if (memo === undefined)
+            return this.coerceNetworkBoundaryLeaves(schema);
+        const cached = memo.get(schema);
+        if (cached !== undefined)
+            return cached;
+        const coerced = this.coerceNetworkBoundaryLeaves(schema);
+        memo.set(schema, coerced);
+        // A coerced schema is a fixed point: its dates are already `z.coerce.date()` (whose type still
+        // reads `date`, which is what made re-coercion rebuild everything) and its bigints are pipes.
+        memo.set(coerced, coerced);
+        return coerced;
+    }
+    /** The uncached walk behind {@link applyNetworkBoundaryCoercion}; recursion goes through the memo. */
+    static coerceNetworkBoundaryLeaves(schema) {
         // Handle discriminated unions - transform dates in all variants
         const zodType = getZodType(schema);
         if (zodType === 'union') {
@@ -2347,7 +2490,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
             if (discriminator && unionOptions && unionOptions.length > 0) {
                 const transformedOptions = unionOptions.map((option) => this.applyNetworkBoundaryCoercion(option));
                 if (transformedOptions.length >= 2) {
-                    return z.discriminatedUnion(discriminator, transformedOptions);
+                    return this.preserveRegistryMetadata(schema, z.discriminatedUnion(discriminator, transformedOptions));
                 }
                 else if (transformedOptions.length === 1) {
                     return transformedOptions[0];
@@ -2467,7 +2610,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 // Extract summary from each variant and rebuild union
                 const summaryOptions = unionOptions.map((option) => this.extractSummaryFields(option)).filter(opt => opt !== null && opt !== undefined);
                 if (summaryOptions.length >= 2) {
-                    return z.discriminatedUnion(discriminator, summaryOptions);
+                    return this.preserveRegistryMetadata(schema, z.discriminatedUnion(discriminator, summaryOptions));
                 }
                 else if (summaryOptions.length === 1) {
                     return summaryOptions[0];
@@ -2567,20 +2710,51 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
      * @param registry - Resource registry; empty during the factory pass
      * @returns A single-object schema for one relative (callers wrap it in `.optional()` / `z.array`)
      */
-    static buildContextRelativeObjectSchema(relatedResourceType, contextPolicy, effectiveOperation, registry) {
+    static buildContextRelativeObjectSchema(relatedResourceType, contextPolicy, effectiveOperation, registry, stripBackendOnly = false) {
         // Zod 4 requires key and value schemas for z.record
         const untypedRelative = z.record(z.string(), z.any());
+        // Every placeholder is marked as an embedded `relatedResourceType` record (#1625). Marked HERE,
+        // inside the memo, because `.meta()` clones: marked at the call site, each context DTO received
+        // its own outer instance and the sharing the memo exists for (#1587) never reached the DTO. The
+        // mark reads only `relatedResourceType`, which the memo key (its main schema) already fixes.
+        const mark = (relative) => markEmbeddedResourceSchema(relative, String(relatedResourceType));
         const objectMode = contextPolicy?.operationOverrides?.[effectiveOperation]?.objectMode
             ?? contextPolicy?.objectMode
             ?? DEFAULT_RELATIONSHIP_CONTEXT_POLICY.objectMode;
         // ID_ONLY carries a bare reference: no fetch, so no leaf to coerce.
         if (objectMode === ContextPolicy_ObjectMode.ID_ONLY) {
-            return untypedRelative;
+            return mark(untypedRelative);
         }
         const relatedMainSchema = registry.get(relatedResourceType)?.mainSchema;
         if (!relatedMainSchema || !isZodObject(relatedMainSchema)) {
-            return untypedRelative;
+            return mark(untypedRelative);
         }
+        /*
+         * Memoized by (related main schema, resolved objectMode, stripBackendOnly) — the only three inputs
+         * the shape below reads (#1587, #1625); the flag selects the memo map rather than keying it. It is built per operation × relationship, so the same summary derivation,
+         * coercion and union were rebuilt for every operation of every resource that embeds a relative:
+         * 107 MB of one resource registry's heap. Callers only ever WRAP the result (`.optional()`,
+         * `z.array`), never write to it, so within the active resource scope one instance serves every
+         * placeholder that asks for it.
+         */
+        const memoScope = this.activeMemoScope;
+        const memo = stripBackendOnly ? memoScope?.clientContextRelative : memoScope?.contextRelative;
+        if (memo === undefined)
+            return mark(this.composeContextRelativeObjectSchema(relatedMainSchema, objectMode, untypedRelative, stripBackendOnly));
+        let byObjectMode = memo.get(relatedMainSchema);
+        const cachedRelative = byObjectMode?.get(objectMode);
+        if (cachedRelative !== undefined)
+            return cachedRelative;
+        if (byObjectMode === undefined) {
+            byObjectMode = new Map();
+            memo.set(relatedMainSchema, byObjectMode);
+        }
+        const composedRelative = mark(this.composeContextRelativeObjectSchema(relatedMainSchema, objectMode, untypedRelative, stripBackendOnly));
+        byObjectMode.set(objectMode, composedRelative);
+        return composedRelative;
+    }
+    /** The uncached shape behind {@link buildContextRelativeObjectSchema}. */
+    static composeContextRelativeObjectSchema(relatedMainSchema, objectMode, untypedRelative, stripBackendOnly) {
         let relativeSchema = relatedMainSchema;
         if (objectMode === ContextPolicy_ObjectMode.SUMMARY) {
             // Mirrors the summary DTO's own derivation, including its fallback: a resource that marks NO
@@ -2599,15 +2773,24 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 });
             }
         }
+        // The CLIENT placeholder drops the related resource's backend-only fields, stripped here BEFORE
+        // coercion because coercion rebuilds wrappers and can erase the `isBackendOnly` mark the strip
+        // reads. The client context DTO is assembled AFTER the response DTO's own strip pass, so nothing
+        // later would remove them, and the API reference published them (#1625). The service-layer
+        // placeholder keeps them. Runtime parsing is unchanged either way: the typed branch is `.loose()`
+        // and the union falls back to any record, so this changes what the contract DECLARES.
+        if (stripBackendOnly) {
+            relativeSchema = this.stripBackendOnlyFields(relativeSchema);
+        }
         // Coerced HERE rather than left to a later pass: the CONTEXT variant's `responseDto` IS this
         // `contextDto`, and nothing re-coerces it after the variant override (step 10).
         const coercedRelativeSchema = this.applyNetworkBoundaryCoercion(relativeSchema);
         if (!isZodObject(coercedRelativeSchema)) {
             return untypedRelative;
         }
-        // Backend-only fields are deliberately NOT stripped. They never reach the wire, and the same
-        // placeholder types the service-layer `internalDto`, where they legitimately appear — `.loose()`
-        // would pass them through either way, and declaring them means their dates are coerced too.
+        // Backend-only fields are kept on the SERVICE-layer placeholder (`stripBackendOnly: false`): it
+        // types the `internalDto`, where they legitimately appear, and declaring them means their dates
+        // are coerced too. The client placeholder was stripped above.
         const typedRelative = coercedRelativeSchema.partial().loose();
         // The union is what makes "can only ADD coercion" true rather than nearly true.
         //
@@ -2631,7 +2814,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
      * @param registry - Resource registry for type resolution
      * @returns Schema with relationship placeholders added
      */
-    static addRelationshipPlaceholders(schema, relationships, effectiveOperation, registry) {
+    static addRelationshipPlaceholders(schema, relationships, effectiveOperation, registry, stripBackendOnly = false) {
         // A POLYMORPHIC resource's response is a discriminated union: every variant carries the same
         // relationships, so every variant gets the same placeholders, and the union is rebuilt with the
         // discriminator it had — the pattern `excludeVirtualFieldsFromSchema` already uses. Returning a
@@ -2644,9 +2827,9 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
             const discriminator = getZodDefStringProperty(schema, 'discriminator');
             const options = getZodDefArrayProperty(schema, 'options');
             if (discriminator && options && options.length > 0) {
-                const withPlaceholders = options.map((option) => this.addRelationshipPlaceholders(option, relationships, effectiveOperation, registry));
+                const withPlaceholders = options.map((option) => this.addRelationshipPlaceholders(option, relationships, effectiveOperation, registry, stripBackendOnly));
                 return withPlaceholders.length >= 2
-                    ? z.discriminatedUnion(discriminator, withPlaceholders)
+                    ? this.preserveRegistryMetadata(schema, z.discriminatedUnion(discriminator, withPlaceholders))
                     : withPlaceholders[0];
             }
             return schema;
@@ -2672,7 +2855,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 // It was once `z.object({ _id })`, which stripped every SUMMARY/FULL field even under the
                 // right name: no parent object had ever reached a client, on any resource (#579). That is
                 // why the typed form below can only ever ADD coercion.
-                placeholderFields[fieldName] = this.buildContextRelativeObjectSchema(relationship.resourceType1, relationship.contextPolicy, effectiveOperation, registry).optional();
+                placeholderFields[fieldName] = this.buildContextRelativeObjectSchema(relationship.resourceType1, relationship.contextPolicy, effectiveOperation, registry, stripBackendOnly).optional();
             }
         }
         // Add child relationship placeholders (includes self-refs acting as children)
@@ -2698,7 +2881,7 @@ export class ResourcesConfigOperationsDtosBuilderUtils {
                 // Typed from the child's own schema by the relationship's resolved `objectMode`, with every
                 // field optional and unknown keys passed through, so the declaration coerces the child's
                 // date and money leaves without being able to strip or refuse anything (#1189).
-                const childPlaceholder = this.buildContextRelativeObjectSchema(relationship.resourceType2, relationship.contextPolicy, effectiveOperation, registry);
+                const childPlaceholder = this.buildContextRelativeObjectSchema(relationship.resourceType2, relationship.contextPolicy, effectiveOperation, registry, stripBackendOnly);
                 if (isOneToOne) {
                     // 1:1: single object (optional)
                     placeholderFields[fieldName] = childPlaceholder.optional();