@wildo-ai/saas-frontend-lib 1.0.1

package/dist/esm/components/form/automated/ResourceAutomatedForm.js

@@ -0,0 +1,1622 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * ResourceAutomatedForm Component
+ *
+ * A fully autonomous form component that derives all configuration from a
+ * FrontendResourceOperationContext. It automatically:
+ * - Uses the operation's requestDto (or mainSchema) as the form schema
+ * - Resolves labels from i18n based on resource type and operation
+ * - Fetches current data for UPDATE operations
+ * - Submits data via the resource registry's doOperation
+ * - Handles success notifications based on operation configuration
+ * - Determines wizard mode from frontEndApplication configuration
+ */
+import React, { useEffect, useMemo, useState, useCallback, useRef } from 'react';
+import { useFormContext } from 'react-hook-form';
+import { CoreResourceOperation, CoreUserNotificationChannel, CoreUserNotificationTarget, RelationshipNature, ResourceRelationshipBulkAction, ResourcesConfig_OperationPathUtils, ResourceOperationVariantType, ErrorCustomMessageReference, ErrorType, UserNotificationLevel, ResourcesConfigOperationsUrlsBuilderUtils, Resources_SharedUtils, } from '@wildo-ai/saas-models';
+import { Button, ButtonVariants_Variant } from '../../../components/actions/button.js';
+import { AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogCancel, AlertDialogAction, } from '../../../components/overlays/containers/alert-dialog.js';
+import { prepareFormSchema, AutosaveTrigger } from '@wildo-ai/zod-decorators';
+import { FrontendComponentType, } from '@wildo-ai/presets-components-models';
+import { AutomatedForm } from './AutomatedForm.js';
+import { useOptionalFormTemplateContext } from './FormTemplateContext.js';
+import { pickSubmissionDataPaths, sanitizeAutomatedFormSubmissionData } from './automated-form-submit.utils.js';
+import { AutomatedLayoutFrontendUtils } from '../../../core/automated-layout/automated-layout.frontend.utils.js';
+import { generateDefaultFormTemplate } from '../../../core/automated-layout/default-layout-generator.frontend.utils.js';
+import { AutosaveProvider } from '../../../components/form/automated/AutosaveContext.js';
+import { useOptionalAutosave } from '../../../components/form/automated/AutosaveContext.js';
+import { extractServerValidationErrors } from '../../../components/form/validation-errors/form-error-extraction.utils.js';
+import { useServerErrorInjection } from '../../../components/form/validation-errors/useServerErrorInjection.js';
+import { LoggerFrontendService } from '../../../core/monitoring/logger.frontend.service.js';
+import { useResourceRegistry } from '../../../core/resources/useResourceRegistry.js';
+import { isSingleResourceUpdateLikeOperation, isUpdateLikeCoreOperation, mergeBulkSelectionIntoRequestData, pickPreferredOperationForCoreSemantic, resolveEffectiveCoreOperation, } from '../../../core/resources/operation-semantics.frontend.utils.js';
+import { frontendResourceUtils, FrontendResourceUtils } from '../../../core/resources/frontend-resource.utils.js';
+import { resolveRelationshipWriteSurface, } from '../../../core/resources/relationship-surface-runtime.frontend.utils.js';
+import { useEventBus } from '../../../core/events/useEventBus.js';
+import { useI18n } from '../../../core/i18n/useI18n.js';
+import { LoadingGate } from '../../../core/loading/LoadingGate.js';
+import { ErrorBuilderFrontend } from '../../../core/errors/errors-builder.frontend.services.js';
+import { FrontendEvents } from '../../../core/events/events.frontend.schemas.js';
+import { isForeignKey, isUnique, getZodObjectShape } from '@wildo-ai/zod-decorators';
+import { envLoader } from '../../../core/runtime/env-variable-loader.frontend.service.js';
+import { NavigationUtils } from '../../../core/navigation/navigation.utils.js';
+import { MutationPriority, MutationType, MutationSourceType, MutationErrorType, RMMEventType, ConflictStrategy, ConflictReason, MutationCancelledError, } from '../../../core/resources/rmm/types.js';
+import { useResourceRMM } from '../../../core/resources/rmm/useResourceRMM.js';
+import { performCanonicalRMMRead, resolveCanonicalRMMReadOperationPathKey, } from '../../../core/resources/rmm/canonical-read.frontend.utils.js';
+import { allowsDirectOperationFallback, MissingRMMRuntimeError, UpdateLikeMutationFallbackMode, } from '../../../core/resources/rmm/update-like-mutation-fallback.frontend.js';
+import { RemoteChangeNotification } from '../../../components/form/feedback/RemoteChangeNotification.js';
+import { emitQuickCreateCompleted, resolveQuickCreateCreatedResourceId, } from '../../../core/resources/relationship-quick-create.frontend.utils.js';
+import { GeneratedAssociationRelationshipField } from './GeneratedAssociationRelationshipField.js';
+import { GeneratedReferenceRelationshipField } from './GeneratedReferenceRelationshipField.js';
+const logger = LoggerFrontendService.getLogger();
+const logDebug = logger.debugByType('ResourceAutomatedForm');
+logger.setDebugTypeLogging('ResourceAutomatedForm', false);
+function readPathValue(value, path) {
+    const normalizedPath = path.replace(/\[(\d+)\]/g, '.$1');
+    return normalizedPath
+        .split('.')
+        .filter(Boolean)
+        .reduce((currentValue, segment) => {
+        if (currentValue === null || currentValue === undefined || typeof currentValue !== 'object') {
+            return undefined;
+        }
+        return currentValue[segment];
+    }, value);
+}
+// =============================================================================
+// VALIDATION HELPERS
+// =============================================================================
+/**
+ * Validates fileId format (MongoDB ObjectId or UUID)
+ *
+ * Supports both:
+ * - MongoDB ObjectId: 24 hexadecimal characters
+ * - PostgreSQL UUID: 36 characters with dashes (8-4-4-4-12)
+ *
+ * @param fileId - The fileId to validate
+ * @returns true if valid, false otherwise
+ */
+const validateFileId = (fileId) => {
+    if (!fileId || typeof fileId !== 'string') {
+        return false;
+    }
+    return Resources_SharedUtils.isValidResourceId(fileId.trim());
+};
+const ResourceFormActionsContext = React.createContext(null);
+/**
+ * Get the frontend notification configuration if configured for the current user.
+ *
+ * Extracts both the notification identifier (for i18n) and the level (for toast type).
+ * Looks for FRONT_END_SUCCESS channel notifications targeting USER_SELF.
+ */
+function getFrontendNotification(operation) {
+    // Type assertion: All FrontendResourceConfiguration_Operation variants extend ResourceConfiguration_Operation_Base
+    // which includes userNotifications: UserNotificationDefinition[]
+    const operationWithNotifications = operation;
+    const userNotifications = operationWithNotifications.userNotifications || [];
+    // Find a FRONT_END_SUCCESS notification targeting USER_SELF
+    const frontendNotification = userNotifications.find((n) => {
+        const channel = n.channel;
+        const target = n.target;
+        return channel === CoreUserNotificationChannel.FRONT_END_SUCCESS &&
+            target === CoreUserNotificationTarget.USER_SELF;
+    });
+    if (!frontendNotification) {
+        return null;
+    }
+    return {
+        identifier: frontendNotification.identifier,
+        level: frontendNotification.level || UserNotificationLevel.SUCCESS,
+    };
+}
+/**
+ * Get the i18n key for the default submit button based on operation type.
+ */
+function getDefaultSubmitLabelKey(operationIdentifier) {
+    switch (operationIdentifier) {
+        case CoreResourceOperation.CREATE:
+            return 'create';
+        case CoreResourceOperation.UPDATE:
+        case CoreResourceOperation.UPDATE_MANY:
+            return 'saveChanges';
+        case CoreResourceOperation.DELETE:
+            return 'delete';
+        default:
+            return 'submit';
+    }
+}
+function isConflictMutationFailure(result) {
+    return !result.success && result.error?.type === MutationErrorType.CONFLICT;
+}
+/**
+ * Determine if operation requires fetching existing data (e.g., UPDATE).
+ */
+function shouldFetchExistingData(operation) {
+    const effectiveOperation = resolveEffectiveCoreOperation(operation.operationIdentifier, operation.resourceOperationLike);
+    return effectiveOperation === CoreResourceOperation.READ
+        || isSingleResourceUpdateLikeOperation(operation);
+}
+// =============================================================================
+// COMPONENT
+// =============================================================================
+export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, disabled = false, className, labelsOverride, showErrorSummary = true, validationMode, autosaveConfig, draftConfig, onSectionSave: onSectionSaveProp, defaultValuesOverride, navigationZone, updateLikeMutationFallbackMode = UpdateLikeMutationFallbackMode.RMM_REQUIRED, }) {
+    // Contexts
+    const { doOperation, registry } = useResourceRegistry();
+    const { emit } = useEventBus();
+    const { tComponent, isReady } = useI18n({
+        component: FrontendComponentType.RESOURCES_LAYOUTS_CREATE,
+    });
+    // Refs for stable function references (avoid infinite loops in useEffect)
+    const doOperationRef = useRef(doOperation);
+    const emitRef = useRef(emit);
+    const onErrorRef = useRef(onError);
+    const onSuccessRef = useRef(onSuccess);
+    // Ref to store autosave cancel function (set by AutosaveProvider wrapper)
+    const cancelPendingAutosavesRef = useRef(null);
+    // Ref for section save callback
+    const onSectionSaveRef = useRef(onSectionSaveProp);
+    // Keep refs updated
+    doOperationRef.current = doOperation;
+    emitRef.current = emit;
+    onErrorRef.current = onError;
+    onSuccessRef.current = onSuccess;
+    onSectionSaveRef.current = onSectionSaveProp;
+    // Error builder (memoized to prevent recreation)
+    const errorBuilder = useMemo(() => new ErrorBuilderFrontend(), []);
+    // Extract from resource context
+    const { resourceType, operation, contextResourceIdentifiers } = resourceContext;
+    const operationIdentifier = String(operation.operationIdentifier);
+    const effectiveCoreOperation = resolveEffectiveCoreOperation(operationIdentifier, operation.resourceOperationLike ? String(operation.resourceOperationLike) : undefined);
+    // Derive operationType and operationLike for decorator-based field filtering
+    // operationType is the actual operation being performed (create, update, or custom)
+    // operationLike is for custom operations that behave like core operations (e.g., 'rotate' behaves like 'update')
+    const operationType = operationIdentifier;
+    const operationLike = operation.resourceOperationLike
+        ? String(operation.resourceOperationLike)
+        : undefined;
+    const effectiveFormOperationType = operationLike ?? operationType;
+    // State
+    const [hasLoadedOnce, setHasLoadedOnce] = useState(false);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [isSavingDraft, setIsSavingDraft] = useState(false);
+    const [defaultValues, setDefaultValues] = useState(undefined);
+    const [fetchError, setFetchError] = useState(null);
+    // Store form methods for setting server errors on individual fields
+    const formMethodsRef = useRef(null);
+    const { initAutoClearing, injectServerErrors, clearServerErrors } = useServerErrorInjection(formMethodsRef);
+    // State for pending publish data (waiting for confirmation dialog)
+    const [pendingPublish, setPendingPublish] = useState(null);
+    // Track current draft status
+    const [isDraft, setIsDraft] = useState(draftConfig?.isDraft ?? false);
+    // Conflict banner (persists until user acknowledges)
+    const [conflictBanner, setConflictBanner] = useState(null);
+    // Remote update indicator (auto-dismisses after 3s)
+    const [remoteUpdateIndicator, setRemoteUpdateIndicator] = useState(null);
+    const remoteUpdateTimerRef = useRef(null);
+    // Get the form schema from the operation
+    const formSchema = useMemo(() => {
+        // requestDto is pre-computed by the factory (Phase 2.1)
+        const schema = operation.requestDto;
+        if (!schema) {
+            logger.error(`[ResourceAutomatedForm] No requestDto found for operation ${operationIdentifier} on resource ${resourceType}`);
+        }
+        return schema;
+    }, [operation, operationIdentifier, resourceType]);
+    // Get resource configuration for frontendConfiguration
+    const resourceConfig = useMemo(() => {
+        return registry.resourceConfigurations[resourceType];
+    }, [registry, resourceType]);
+    // Get frontEndApplication config for current app type
+    const feAppConfig = useMemo(() => {
+        return operation.operationFrontendConfig;
+    }, [operation]);
+    // Resolve layout refs for i18n label resolution
+    const layoutRefs = resourceConfig?.frontendConfiguration?.layout?.refs;
+    // Resolve explicit edit template from layout config
+    const explicitEditTemplate = resourceConfig?.frontendConfiguration?.layout?.edit;
+    // Extract inheritanceConfig from resource configuration for discriminated union support
+    const inheritanceConfig = useMemo(() => {
+        // Access inheritenceSchemaDefinition from resource config (note the typo in the property name is intentional - matches existing API)
+        const inheritenceDef = resourceConfig?.inheritenceSchemaDefinition;
+        if (!inheritenceDef)
+            return undefined;
+        // Transform to InheritanceSchemaDefinition format expected by AutomatedForm
+        return {
+            discriminatorField: inheritenceDef.discriminatorField,
+            withoutInheritanceDiscriminatorFieldValues: inheritenceDef.withoutInheritanceDiscriminatorFieldValues,
+            inheritedSchemas: inheritenceDef.inheritedSchemas,
+        };
+    }, [resourceConfig]);
+    const formFieldShape = useMemo(() => {
+        if (!formSchema) {
+            return undefined;
+        }
+        return AutomatedLayoutFrontendUtils.getObjectLikeFieldShape(formSchema);
+    }, [formSchema]);
+    // Extract draft config from resource-level configuration
+    const resourceDraftConfig = resourceConfig?.frontendConfiguration?.draftableConfig;
+    // Merge resource-level draft config with prop-provided config (props take precedence)
+    const effectiveDraftConfig = useMemo(() => {
+        if (!resourceDraftConfig && !draftConfig)
+            return undefined;
+        // If only prop config provided, use it
+        if (!resourceDraftConfig && draftConfig) {
+            return draftConfig;
+        }
+        // If only resource config provided, enable draft mode with resource values
+        if (resourceDraftConfig && !draftConfig) {
+            return {
+                enabled: true,
+                isDraft: false,
+                discriminator: resourceDraftConfig.discriminator,
+                draftValue: resourceDraftConfig.draftValue,
+                publishedValue: resourceDraftConfig.publishedValue,
+                requireConfirmationToPublish: resourceDraftConfig.requireConfirmationToPublish,
+            };
+        }
+        // Merge both, with props taking precedence
+        return {
+            ...resourceDraftConfig,
+            ...draftConfig,
+            enabled: draftConfig?.enabled ?? !!resourceDraftConfig,
+        };
+    }, [resourceDraftConfig, draftConfig]);
+    // Sync isDraft state when effectiveDraftConfig changes
+    useEffect(() => {
+        if (effectiveDraftConfig?.isDraft !== undefined) {
+            setIsDraft(effectiveDraftConfig.isDraft);
+        }
+    }, [effectiveDraftConfig?.isDraft]);
+    // Build a stable key from contextResourceIdentifiers for memoization
+    const contextResourceIdentifiersKey = useMemo(() => {
+        return FrontendResourceUtils.buildContextResourceIdentifiersKey(contextResourceIdentifiers);
+    }, [contextResourceIdentifiers]);
+    // Build contextual parameters for API calls
+    const contextualParameters = useMemo(() => {
+        return FrontendResourceUtils.buildContextualParameters(contextResourceIdentifiers, registry);
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [contextResourceIdentifiersKey, registry]);
+    // Compute context field values - fields from the navigation context that should be
+    // hidden from the form and auto-populated on submit
+    const contextFieldValues = useMemo(() => {
+        if (!formFieldShape) {
+            return {};
+        }
+        const semanticContextFieldValues = FrontendResourceUtils.resolveSemanticContextFieldValues({
+            resourceType,
+            parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+            contextResourceIdentifiers,
+            contextualParameters,
+            registry,
+        });
+        const values = {};
+        for (const [fieldName, fieldValue] of Object.entries(semanticContextFieldValues)) {
+            if (formFieldShape[fieldName]) {
+                values[fieldName] = fieldValue;
+            }
+        }
+        return values;
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key for contextualParameters
+    }, [contextResourceIdentifiersKey, contextualParameters, formFieldShape, registry, resourceContext.parentResourcesRequirements, resourceType]);
+    const relationshipWriteSurfacesByFieldName = useMemo(() => {
+        if (!formFieldShape) {
+            return {};
+        }
+        const writeSurfaces = {};
+        for (const fieldName of Object.keys(formFieldShape)) {
+            const writeSurface = resolveRelationshipWriteSurface({
+                resourceType,
+                fieldName,
+                operationType: effectiveFormOperationType,
+                registry,
+            });
+            if (writeSurface) {
+                writeSurfaces[fieldName] = writeSurface;
+            }
+        }
+        return writeSurfaces;
+    }, [effectiveFormOperationType, formFieldShape, registry, resourceType]);
+    const resourceOperations = resourceConfig?.operations ?? [];
+    // Resource-aware hidden-field derivation stays here on purpose.
+    // `AutomatedForm` only consumes these names as opaque infrastructure input.
+    const hiddenFieldNames = useMemo(() => {
+        if (!formFieldShape) {
+            return [];
+        }
+        const hiddenNames = [];
+        for (const writeSurface of Object.values(relationshipWriteSurfacesByFieldName)) {
+            const relationshipField = writeSurface.rootFieldName;
+            const findOperation = (action) => resourceOperations.find((candidate) => candidate.isBulkOperation === true
+                && String(candidate.operationIdentifier) === Resources_SharedUtils.buildRelationshipBulkOperationIdentifier(action, relationshipField));
+            const hasBusinessFacingEditor = (() => {
+                if (writeSurface.semantics.nature === RelationshipNature.COMPOSITION
+                    && writeSurface.nestedMutationConfig) {
+                    return true;
+                }
+                if (writeSurface.semantics.nature === RelationshipNature.REFERENCE) {
+                    const foreignKeyFieldName = writeSurface.foreignKeyIdentity?.fieldIdentifier;
+                    const foreignKeySchema = foreignKeyFieldName ? formFieldShape[foreignKeyFieldName] : undefined;
+                    const hasVisibleSiblingForeignKeyField = Boolean(foreignKeySchema
+                        && isForeignKey(foreignKeySchema)
+                        && !Object.prototype.hasOwnProperty.call(contextFieldValues, foreignKeyFieldName ?? ''));
+                    return hasVisibleSiblingForeignKeyField || Boolean(findOperation(ResourceRelationshipBulkAction.SET));
+                }
+                if (writeSurface.semantics.nature === RelationshipNature.ASSOCIATION) {
+                    return Boolean(findOperation(ResourceRelationshipBulkAction.REPLACE));
+                }
+                return false;
+            })();
+            if (!hasBusinessFacingEditor) {
+                if (envLoader.isDevelopment()) {
+                    logger.warn('[ResourceAutomatedForm] Keeping relationship root visible because no business-facing editor is available', {
+                        resourceType,
+                        operationType: effectiveFormOperationType,
+                        fieldName: relationshipField,
+                        relationshipNature: writeSurface.semantics.nature,
+                        hasNestedMutationConfig: Boolean(writeSurface.nestedMutationConfig),
+                    });
+                }
+                continue;
+            }
+            hiddenNames.push(relationshipField);
+        }
+        return hiddenNames;
+    }, [
+        contextFieldValues,
+        effectiveFormOperationType,
+        formFieldShape,
+        relationshipWriteSurfacesByFieldName,
+        resourceOperations,
+        resourceType,
+    ]);
+    // Build operation path key from the operation object on context
+    const operationPathKey = useMemo(() => {
+        return ResourcesConfig_OperationPathUtils.createOperationPathKeyFromOperation(operation);
+    }, [operation]);
+    // =============================================================================
+    // RMM (Registry-based, UPDATE-like operations only)
+    // =============================================================================
+    const isUpdateLikeOperation = useMemo(() => {
+        return isSingleResourceUpdateLikeOperation(operation);
+    }, [operation]);
+    const currentOperationTransportOverride = useMemo(() => {
+        const requiresAuthoritativeReadBack = isUpdateLikeOperation
+            && effectiveCoreOperation === CoreResourceOperation.UPDATE
+            && operationIdentifier !== CoreResourceOperation.UPDATE;
+        return {
+            operationPathKey,
+            contextualParameters,
+            parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+            ...(requiresAuthoritativeReadBack ? { readBackOnSuccess: true } : {}),
+        };
+    }, [
+        contextualParameters,
+        effectiveCoreOperation,
+        isUpdateLikeOperation,
+        operationIdentifier,
+        operationPathKey,
+        resourceContext.parentResourcesRequirements,
+    ]);
+    const mergeRequestDataWithBulkSelection = useCallback((requestData) => {
+        return mergeBulkSelectionIntoRequestData({
+            operation,
+            requestData,
+            additionalContext: resourceContext.additionalContext,
+        });
+    }, [operation, resourceContext.additionalContext]);
+    const resourceId = useMemo(() => {
+        const id = contextResourceIdentifiers[resourceType];
+        if (!id)
+            return null;
+        return typeof id === 'string' ? id : id.resourceId;
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [contextResourceIdentifiersKey, resourceType]);
+    const { rmm, rmmSnapshot } = useResourceRMM({
+        resourceType,
+        resourceId,
+        doOperationRef,
+        contextualParameters,
+        parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+        contextResourceIdentifiers,
+        resourceSchema: resourceConfig?.mainSchema,
+        enabled: isUpdateLikeOperation && !!resourceId,
+        conflictPolicy: { strategy: ConflictStrategy.ACCEPT_REMOTE },
+    });
+    // Wrapper-level forms only acquire an RMM when the surface can address one
+    // stable resource id on an UPDATE-like lane. ACCEPT_REMOTE keeps the form on
+    // the same conflict semantics as the rest of the registry-backed runtime:
+    // non-CRDT overlap resets the form to authoritative server truth.
+    const allowsDirectUpdateLikeMutationFallback = useMemo(() => {
+        return allowsDirectOperationFallback(updateLikeMutationFallbackMode);
+    }, [updateLikeMutationFallbackMode]);
+    const requiresRMMForDefaultUpdateLikeMutation = isUpdateLikeOperation && !allowsDirectUpdateLikeMutationFallback;
+    const assertRMMAvailableForDefaultUpdateLikeMutation = useCallback((surfaceName) => {
+        if (requiresRMMForDefaultUpdateLikeMutation && !rmm) {
+            throw new MissingRMMRuntimeError({
+                surfaceName,
+                resourceType,
+                operationIdentifier,
+            });
+        }
+    }, [operationIdentifier, requiresRMMForDefaultUpdateLikeMutation, resourceType, rmm]);
+    useEffect(() => {
+        if (!requiresRMMForDefaultUpdateLikeMutation || rmm || !envLoader.isDevelopment()) {
+            return;
+        }
+        logger.warn('[ResourceAutomatedForm] Default update-like mutation path is mounted without RMM. The surface will fail closed unless it explicitly opts into UpdateLikeMutationFallbackMode.DIRECT_OPERATION_FALLBACK.', {
+            resourceType,
+            operationIdentifier,
+            hasResourceId: resourceId !== null,
+            updateLikeMutationFallbackMode,
+        });
+    }, [
+        operationIdentifier,
+        requiresRMMForDefaultUpdateLikeMutation,
+        resourceId,
+        resourceType,
+        rmm,
+        updateLikeMutationFallbackMode,
+    ]);
+    // Resource-aware generated replacements also stay at the wrapper layer so the
+    // generic form runtime does not decide relationship semantics on its own.
+    // Together with hiddenFieldNames above, this gives relationship roots one
+    // explicit policy: hide the raw infrastructure field only when a business-
+    // facing replacement control exists for the same mutation surface.
+    const generatedFieldOverrides = useMemo(() => {
+        if (!resourceConfig || !isUpdateLikeOperation || !resourceId || !formFieldShape) {
+            return {};
+        }
+        const overrides = {};
+        for (const [fieldName, writeSurface] of Object.entries(relationshipWriteSurfacesByFieldName)) {
+            const relationshipField = writeSurface.rootFieldName;
+            const findOperation = (action) => resourceOperations.find((operation) => operation.isBulkOperation === true &&
+                String(operation.operationIdentifier) === Resources_SharedUtils.buildRelationshipBulkOperationIdentifier(action, relationshipField));
+            if (writeSurface.semantics.nature === RelationshipNature.REFERENCE) {
+                const foreignKeyFieldName = writeSurface.foreignKeyIdentity?.fieldIdentifier;
+                if (!foreignKeyFieldName) {
+                    continue;
+                }
+                const foreignKeySchema = formFieldShape[foreignKeyFieldName];
+                const isVisibleSiblingForeignKeyField = Boolean(foreignKeySchema &&
+                    isForeignKey(foreignKeySchema) &&
+                    !Object.prototype.hasOwnProperty.call(contextFieldValues, foreignKeyFieldName));
+                if (isVisibleSiblingForeignKeyField) {
+                    continue;
+                }
+                const setOperation = findOperation(ResourceRelationshipBulkAction.SET);
+                const clearOperation = findOperation(ResourceRelationshipBulkAction.CLEAR);
+                if (!setOperation) {
+                    if (envLoader.isDevelopment()) {
+                        logger.warn('[ResourceAutomatedForm] Skipping reference override because generated bulk set operation is unavailable', {
+                            resourceType,
+                            fieldName,
+                            foreignKeyFieldName,
+                        });
+                    }
+                    continue;
+                }
+                overrides[fieldName] = (_jsx(GeneratedReferenceRelationshipField, { writeSurface: writeSurface, setOperation: setOperation, clearOperation: clearOperation, rmm: rmm, allowDirectOperationFallback: allowsDirectUpdateLikeMutationFallback }));
+                continue;
+            }
+            if (writeSurface.semantics.nature === RelationshipNature.ASSOCIATION) {
+                const replaceOperation = findOperation(ResourceRelationshipBulkAction.REPLACE);
+                const initialRelationshipValue = defaultValues
+                    ? readPathValue(defaultValues, fieldName)
+                    : undefined;
+                const hasHydratedInitialValue = Boolean(defaultValues &&
+                    typeof defaultValues === 'object' &&
+                    Object.prototype.hasOwnProperty.call(defaultValues, fieldName));
+                if (!replaceOperation) {
+                    if (envLoader.isDevelopment()) {
+                        logger.warn('[ResourceAutomatedForm] Skipping association override because generated bulk replace operation is unavailable', {
+                            resourceType,
+                            fieldName,
+                        });
+                    }
+                    continue;
+                }
+                overrides[fieldName] = (_jsx(GeneratedAssociationRelationshipField, { writeSurface: writeSurface, replaceOperation: replaceOperation, initialRelationshipValue: initialRelationshipValue, hasHydratedInitialValue: hasHydratedInitialValue, rmm: rmm, allowDirectOperationFallback: allowsDirectUpdateLikeMutationFallback }));
+            }
+        }
+        return overrides;
+    }, [
+        contextFieldValues,
+        defaultValues,
+        effectiveFormOperationType,
+        formFieldShape,
+        isUpdateLikeOperation,
+        registry,
+        resourceConfig,
+        resourceId,
+        resourceOperations,
+        resourceType,
+        relationshipWriteSurfacesByFieldName,
+        rmm,
+        allowsDirectUpdateLikeMutationFallback,
+    ]);
+    // This is the wrapper's single RMM subscription seam. All authoritative
+    // mutation/read-back/remote-reset outcomes are translated here into form
+    // state updates, server validation injection, transient remote-update UI, and
+    // the persistent conflict banner.
+    useEffect(() => {
+        if (!rmm || !rmmSnapshot?.lastEvent)
+            return;
+        const event = rmmSnapshot.lastEvent;
+        switch (event.type) {
+            case RMMEventType.MUTATION_RESULT: {
+                const { result } = event;
+                if (result.success && result.savedFields) {
+                    if (formMethodsRef.current) {
+                        for (const field of result.savedFields) {
+                            formMethodsRef.current.setValue(field, readPathValue(rmmSnapshot.confirmedData, field), {
+                                shouldDirty: false,
+                                shouldValidate: false,
+                            });
+                        }
+                    }
+                }
+                if (!result.success && result.error?.type === MutationErrorType.VALIDATION) {
+                    if (result.error.validationErrors) {
+                        const syntheticError = {
+                            httpStatus: result.error.status ?? 400,
+                            validationErrors: result.error.validationErrors,
+                        };
+                        const serverValidation = extractServerValidationErrors(syntheticError);
+                        if (serverValidation) {
+                            injectServerErrors(serverValidation.validationErrors);
+                        }
+                    }
+                }
+                break;
+            }
+            case RMMEventType.REMOTE_UPDATE: {
+                if (formMethodsRef.current) {
+                    for (const field of event.changedFields) {
+                        const currentDirty = formMethodsRef.current.getFieldState(field).isDirty;
+                        if (!currentDirty) {
+                            formMethodsRef.current.setValue(field, readPathValue(rmmSnapshot.confirmedData, field), {
+                                shouldDirty: false,
+                                shouldValidate: false,
+                            });
+                        }
+                    }
+                }
+                setRemoteUpdateIndicator({
+                    changedFields: event.changedFields,
+                    initiatorUserId: event.initiatorUserId,
+                });
+                if (remoteUpdateTimerRef.current)
+                    clearTimeout(remoteUpdateTimerRef.current);
+                remoteUpdateTimerRef.current = setTimeout(() => {
+                    setRemoteUpdateIndicator(null);
+                    remoteUpdateTimerRef.current = null;
+                }, 3000);
+                break;
+            }
+            case RMMEventType.CONFLICT_RESET: {
+                if (formMethodsRef.current) {
+                    formMethodsRef.current.reset(event.currentData);
+                }
+                clearServerErrors();
+                setConflictBanner({
+                    discardedFields: event.discardedFields,
+                    conflictingFields: event.conflictDetails?.conflictingFields ?? event.discardedFields,
+                    reason: event.reason,
+                    conflictDetails: event.conflictDetails,
+                });
+                break;
+            }
+            case RMMEventType.RESOURCE_DELETED: {
+                logDebug('RMM resource deleted event', { reason: event.reason });
+                break;
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- react only to new events
+    }, [rmmSnapshot?.lastEvent?.id]);
+    useEffect(() => {
+        return () => {
+            if (remoteUpdateTimerRef.current) {
+                clearTimeout(remoteUpdateTimerRef.current);
+                remoteUpdateTimerRef.current = null;
+            }
+        };
+    }, []);
+    const handleAcknowledgeConflict = useCallback(() => {
+        rmm?.acknowledgeConflict();
+        setConflictBanner(null);
+    }, [rmm]);
+    // Build labels for AutomatedForm
+    const labels = useMemo(() => {
+        const resourceContextLabels = {
+            resourceContext: {
+                resourceType,
+                operationId: operationIdentifier,
+            },
+        };
+        // Merge with overrides
+        return {
+            ...resourceContextLabels,
+            ...labelsOverride,
+            // Override navigation if provided
+            navigation: {
+                ...resourceContextLabels.navigation,
+                ...labelsOverride?.navigation,
+            },
+        };
+    }, [resourceType, operationIdentifier, labelsOverride]);
+    // =============================================================================
+    // SHARED BASE PATH (used by fileUploadContext & validateFieldUrl)
+    // =============================================================================
+    /**
+     * Compute the routed API base identity for this resource.
+     * Uses CREATE operation URL resolution so file uploads and validate-field routes
+     * stay aligned with the same FK-aware contextual parameter contract as normal
+     * resource operations.
+     */
+    const resourceApiBase = useMemo(() => {
+        const isCreateOperation = effectiveCoreOperation === CoreResourceOperation.CREATE;
+        const isUpdateOperation = isSingleResourceUpdateLikeOperation(operation);
+        if (!isCreateOperation && !isUpdateOperation) {
+            return null;
+        }
+        try {
+            const primaryResourceId = frontendResourceUtils.getPrimaryResourceIdentifier(resourceContext);
+            const apiBaseUrl = envLoader.getApiUrl();
+            if (!resourceConfig?.resourceFieldIdentifier) {
+                throw FrontendResourceUtils.buildConfigurationError(ErrorCustomMessageReference.FRONTEND_RESOURCE_FIELD_IDENTIFIER_NOT_FOUND, { resourceType: resourceContext.resourceType, component: 'ResourceAutomatedForm' });
+            }
+            const resourceFieldIdentifier = resourceConfig.resourceFieldIdentifier;
+            const contextualParameters = FrontendResourceUtils.buildContextualParameters(contextResourceIdentifiers, registry);
+            if (isUpdateOperation && primaryResourceId) {
+                contextualParameters[resourceFieldIdentifier] = primaryResourceId;
+            }
+            const routeBearingMutationOperation = (operation.variantType === ResourceOperationVariantType.API_CALL
+                || operation.variantType === ResourceOperationVariantType.API_CALL_WITH_CALLBACK)
+                ? operation
+                : resourceConfig
+                    ? pickPreferredOperationForCoreSemantic(resourceConfig.operations ?? [], isUpdateOperation ? CoreResourceOperation.UPDATE : CoreResourceOperation.CREATE)
+                    : undefined;
+            let basePath;
+            if (routeBearingMutationOperation) {
+                const routePaths = ResourcesConfigOperationsUrlsBuilderUtils.buildOperationFrontendRoutePaths(resourceConfig, routeBearingMutationOperation, registry.allResourceFieldIdentifiers);
+                if (routePaths.length > 0) {
+                    const routePath = frontendResourceUtils.selectMatchingRoutePath(routePaths, contextResourceIdentifiers, resourceConfig.resourceIdentifier, resourceFieldIdentifier, resourceContext.parentResourcesRequirements);
+                    basePath = routePath.url;
+                    basePath = NavigationUtils.resolveUrlPath(basePath, contextualParameters);
+                    if (basePath && NavigationUtils.hasUnresolvedPlaceholders(basePath)) {
+                        logger.warn('[ResourceAutomatedForm] Unresolved placeholders in routed API basePath; disabling route-derived helpers', {
+                            basePath,
+                            resourceType,
+                            operationIdentifier,
+                        });
+                        basePath = undefined;
+                    }
+                }
+            }
+            if (!basePath) {
+                return null;
+            }
+            return {
+                apiBaseUrl,
+                basePath,
+                contextualParameters,
+                primaryResourceId,
+                resourceFieldIdentifier,
+            };
+        }
+        catch (error) {
+            logger.error('[ResourceAutomatedForm] Error computing resource API base:', error);
+            return null;
+        }
+    }, [effectiveCoreOperation, operation, resourceType, resourceConfig, contextResourceIdentifiers, registry, resourceContext]);
+    // Generate file upload context for file fields
+    // Detects file fields in schema and builds resource-integrated upload endpoints
+    // Decision 7.1: Use ResourcesConfigOperationsUrlsBuilderUtils for proper nested resource path building
+    const fileUploadContext = useMemo(() => {
+        if (!formSchema || !resourceApiBase || !resourceConfig?.resourceFieldIdentifier)
+            return {};
+        const context = {};
+        const isUpdateOperation = isSingleResourceUpdateLikeOperation(operation);
+        const { apiBaseUrl, contextualParameters } = resourceApiBase;
+        try {
+            const uploadOperation = (operation.variantType === ResourceOperationVariantType.API_CALL
+                || operation.variantType === ResourceOperationVariantType.API_CALL_WITH_CALLBACK)
+                ? operation
+                : pickPreferredOperationForCoreSemantic(resourceConfig.operations ?? [], isUpdateOperation ? CoreResourceOperation.UPDATE : CoreResourceOperation.CREATE);
+            if (!uploadOperation) {
+                return context;
+            }
+            const uploadRoutePaths = ResourcesConfigOperationsUrlsBuilderUtils.buildOperationFrontendRoutePaths(resourceConfig, uploadOperation, registry.allResourceFieldIdentifiers);
+            if (uploadRoutePaths.length === 0) {
+                return context;
+            }
+            const routePath = frontendResourceUtils.selectMatchingRoutePath(uploadRoutePaths, contextResourceIdentifiers, resourceConfig.resourceIdentifier, resourceConfig.resourceFieldIdentifier, resourceContext.parentResourcesRequirements);
+            const filesBasePath = `${apiBaseUrl}/api/v1/files`;
+            const fileFieldPaths = AutomatedLayoutFrontendUtils.collectFileFieldPaths(formSchema);
+            for (const fieldName of fileFieldPaths) {
+                const uploadRoute = ResourcesConfigOperationsUrlsBuilderUtils.buildFileUploadRouteForOperation({
+                    operationRouteUrl: routePath.url,
+                    operationParameters: routePath.parameters,
+                    targetResourceType: resourceType,
+                    targetResourceFieldIdentifier: resourceConfig.resourceFieldIdentifier,
+                    fieldName,
+                    requiresTargetResourceId: isUpdateOperation,
+                    isFrontend: true,
+                });
+                const resolvedUploadPath = NavigationUtils.resolveUrlPath(uploadRoute.url, contextualParameters);
+                if (NavigationUtils.hasUnresolvedPlaceholders(resolvedUploadPath)) {
+                    logger.warn('[ResourceAutomatedForm] Unresolved placeholders in file upload path, skipping endpoint', {
+                        fieldName,
+                        uploadPath: resolvedUploadPath,
+                    });
+                    continue;
+                }
+                const uploadEndpoint = `${apiBaseUrl}${resolvedUploadPath}`;
+                context[fieldName] = {
+                    upload: uploadEndpoint,
+                    override: isUpdateOperation ? uploadEndpoint : undefined,
+                    getMetadata: filesBasePath,
+                    // UPDATE remove must clear the field locally and let the later save own unlinking.
+                    delete: isUpdateOperation ? undefined : filesBasePath,
+                };
+            }
+        }
+        catch (error) {
+            logger.error('[ResourceAutomatedForm] Error generating file upload context:', error);
+        }
+        return context;
+    }, [formSchema, operation, resourceApiBase, resourceConfig, resourceContext.parentResourcesRequirements, resourceType]);
+    // =============================================================================
+    // SERVER-SIDE FIELD VALIDATION CONTEXT
+    // =============================================================================
+    /**
+     * Build the validate-field URL for server-side field pre-validation.
+     * Only computed when the resource's mainSchema has fields that require
+     * server-side validation (currently: isUnique; extensible to FK existence,
+     * external API checks, custom validators, etc.).
+     *
+     * The URL follows the same base path as the CREATE operation + "/validate-field".
+     * The backend handler dispatches to the appropriate validation strategy
+     * based on the field's decorators.
+     */
+    const validateFieldUrl = useMemo(() => {
+        if (!resourceApiBase || !resourceConfig)
+            return undefined;
+        // Check if the resource's main schema has any fields requiring server validation.
+        // Use the mainSchema (not requestDto) because decorators live on the main entity schema.
+        //
+        // Currently checks: isUnique()
+        // When new server-validated decorators are added (e.g., isExternallyValidated),
+        // add them to this check to enable the validate-field URL for those resources.
+        const mainSchema = resourceConfig.mainSchema;
+        if (!mainSchema)
+            return undefined;
+        const shape = getZodObjectShape(mainSchema);
+        const hasServerValidatedFields = Object.values(shape).some(fieldSchema => isUnique(fieldSchema)
+        // Future: || isExternallyValidated(fieldSchema)
+        // Future: || isServerValidated(fieldSchema)
+        );
+        if (!hasServerValidatedFields)
+            return undefined;
+        return `${resourceApiBase.apiBaseUrl}${resourceApiBase.basePath}/validate-field`;
+    }, [resourceApiBase, resourceConfig]);
+    /**
+     * Resource ID for UPDATE operations.
+     * Passed as excludeId to the validate-field endpoint so server-side validation
+     * strategies can exclude the current resource from checks (e.g., uniqueness
+     * validation shouldn't conflict with the resource's own values during UPDATE).
+     */
+    const primaryResourceId = useMemo(() => {
+        return frontendResourceUtils.getPrimaryResourceIdentifier(resourceContext) ?? undefined;
+    }, [resourceContext]);
+    const canonicalReadOperationPathKey = useMemo(() => {
+        return rmm?.readOperationPathKey ?? resolveCanonicalRMMReadOperationPathKey(resourceType, registry);
+    }, [registry, resourceType, rmm?.readOperationPathKey]);
+    // Determine if we need to fetch existing data
+    const needsFetch = useMemo(() => shouldFetchExistingData(operation), [operation]);
+    // Fetch existing data for UPDATE-like operations
+    // Use refs to avoid infinite loops from unstable function references
+    useEffect(() => {
+        if (!needsFetch) {
+            setDefaultValues(defaultValuesOverride ?? undefined);
+            setHasLoadedOnce(true);
+            return;
+        }
+        let cancelled = false;
+        const fetchData = async () => {
+            setFetchError(null);
+            try {
+                const data = await performCanonicalRMMRead({
+                    doOperation: doOperationRef.current,
+                    readOperationPathKey: canonicalReadOperationPathKey,
+                    contextualParameters,
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+                });
+                if (cancelled)
+                    return;
+                const dataRecord = data;
+                if (rmm) {
+                    rmm.setInitialState(dataRecord, dataRecord._version ?? 0, dataRecord._field_meta);
+                }
+                setDefaultValues(defaultValuesOverride
+                    ? { ...dataRecord, ...defaultValuesOverride }
+                    : data);
+                setHasLoadedOnce(true);
+            }
+            catch (error) {
+                if (cancelled)
+                    return;
+                // Create WildoError_Frontend for READ operation failure
+                const originalError = error instanceof Error ? error : new Error(String(error));
+                // Extract enhanced error info from HTTP client errors
+                const errorData = error;
+                const wildoError = errorBuilder.buildWildoError_Frontend(ErrorType.NOT_FOUND, {
+                    customMessageReference: ErrorCustomMessageReference.FRONTEND_FORM_READ_OPERATION_NOT_AVAILABLE,
+                    operationPathKey: canonicalReadOperationPathKey,
+                    context: {
+                        resourceType,
+                        operationIdentifier,
+                        originalErrorMessage: originalError.message,
+                        originalErrorStack: originalError.stack,
+                        // Include HTTP error details if available
+                        httpCode: errorData?.code,
+                        httpContext: errorData?.context,
+                    },
+                });
+                setFetchError(wildoError);
+                onErrorRef.current?.(originalError);
+            }
+        };
+        fetchData();
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using refs for unstable functions; `rmm` so seed runs when RMM becomes available
+    }, [needsFetch, canonicalReadOperationPathKey, resourceType, contextResourceIdentifiersKey, contextualParameters, errorBuilder, operationIdentifier, defaultValuesOverride, rmm]);
+    // Handle form submission - use refs to avoid stale closures and dependency issues
+    const handleSubmit = useCallback(async (data) => {
+        // Cancel any pending autosaves before full form submit to prevent race conditions
+        cancelPendingAutosavesRef.current?.();
+        setIsSubmitting(true);
+        // Clear previous server errors before new submission
+        clearServerErrors();
+        logDebug('handleSubmit: starting', { operationPathKey, dataKeys: Object.keys(data || {}) });
+        try {
+            let result;
+            // RMM path: queue full submit (cancelPendingAutosavesRef already called rmm.cancelPendingMutations())
+            if (rmm) {
+                const mutationResult = await rmm.queueMutation(data, {
+                    type: MutationType.SUBMIT,
+                    priority: MutationPriority.HIGH,
+                    source: { type: MutationSourceType.FORM, subscriberId: 'submit' },
+                    transportOverride: currentOperationTransportOverride,
+                });
+                if (!mutationResult.success) {
+                    if (isConflictMutationFailure(mutationResult)) {
+                        return;
+                    }
+                    if (mutationResult.error?.type === MutationErrorType.VALIDATION) {
+                        onErrorRef.current?.(new Error(mutationResult.error.message ?? 'Validation failed'));
+                        return;
+                    }
+                    throw new Error(mutationResult.error?.message ?? 'Submit failed');
+                }
+                result = mutationResult.responseData;
+            }
+            else {
+                assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm submit');
+                result = await doOperationRef.current(operationPathKey, {
+                    contextualParameters,
+                    requestData: mergeRequestDataWithBulkSelection(data),
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+                });
+            }
+            logDebug('handleSubmit: success', { operationPathKey });
+            // Emit success notification event if configured
+            const frontendNotification = getFrontendNotification(operation);
+            if (frontendNotification) {
+                const eventType = frontendNotification.level === UserNotificationLevel.WARNING
+                    ? FrontendEvents.NOTIFY_RESOURCE_WARNING
+                    : frontendNotification.level === UserNotificationLevel.ERROR
+                        ? FrontendEvents.NOTIFY_RESOURCE_ERROR
+                        : frontendNotification.level === UserNotificationLevel.INFO
+                            ? FrontendEvents.NOTIFY_RESOURCE_INFO
+                            : FrontendEvents.NOTIFY_RESOURCE_SUCCESS;
+                emitRef.current(eventType, {
+                    ...resourceContext,
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                    resultSummary: typeof result === 'object' && result !== null ? result : undefined,
+                    additionalContext: {
+                        ...resourceContext.additionalContext,
+                        notificationIdentifier: frontendNotification.identifier,
+                        notificationLevel: frontendNotification.level,
+                        result,
+                    },
+                });
+            }
+            const quickCreateRequest = resourceContext.additionalContext?.quickCreateRequest;
+            if (quickCreateRequest?.requestId && effectiveCoreOperation === CoreResourceOperation.CREATE) {
+                const createdResourceId = resolveQuickCreateCreatedResourceId({
+                    result,
+                    resourceType,
+                    registry,
+                });
+                if (createdResourceId) {
+                    emitQuickCreateCompleted({
+                        emit: emitRef.current,
+                        requestId: quickCreateRequest.requestId,
+                        resourceType,
+                        resourceId: createdResourceId,
+                        data: typeof result === 'object' && result !== null && !Array.isArray(result)
+                            ? result
+                            : undefined,
+                    });
+                }
+            }
+            onSuccessRef.current?.(result);
+        }
+        catch (error) {
+            if (error instanceof MutationCancelledError) {
+                return;
+            }
+            const err = error instanceof Error ? error : new Error(String(error));
+            logDebug('handleSubmit: error caught', { message: err.message, operationPathKey });
+            // Extract server-side validation errors (400/409 with field-level errors)
+            const serverValidation = extractServerValidationErrors(error);
+            if (serverValidation) {
+                logDebug('handleSubmit: server validation errors detected', {
+                    httpStatus: serverValidation.httpStatus,
+                    fields: Object.keys(serverValidation.validationErrors),
+                });
+                injectServerErrors(serverValidation.validationErrors);
+            }
+            else {
+                logDebug('handleSubmit: general error (not validation)', { message: err.message });
+                emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
+                    ...resourceContext,
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                    additionalContext: {
+                        ...resourceContext.additionalContext,
+                        error: err.message,
+                    },
+                });
+            }
+            onErrorRef.current?.(err);
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [
+        assertRMMAvailableForDefaultUpdateLikeMutation,
+        currentOperationTransportOverride,
+        mergeRequestDataWithBulkSelection,
+        operationPathKey,
+        contextualParameters,
+        operation,
+        resourceContext,
+        rmm,
+    ]);
+    // Handle validation errors (client-side, from RHF)
+    const handleError = (errors) => {
+        logDebug('handleError: client-side validation failed', {
+            errorCount: Object.keys(errors).length,
+            fields: Object.keys(errors),
+        });
+        logger.warn('[ResourceAutomatedForm] Form validation errors', errors);
+    };
+    // When defaultValuesOverride changes (e.g. after DISCOVER), reset form with merged values
+    useEffect(() => {
+        if (!defaultValuesOverride || !formMethodsRef.current)
+            return;
+        const merged = defaultValues
+            ? { ...defaultValues, ...defaultValuesOverride }
+            : defaultValuesOverride;
+        formMethodsRef.current.reset(merged);
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- only run when override changes
+    }, [defaultValuesOverride]);
+    // Callback to receive form methods from AutomatedForm
+    const handleFormReady = useCallback((formMethods) => {
+        formMethodsRef.current = formMethods;
+        initAutoClearing(formMethods);
+        // When defaultValuesOverride is set (e.g. from DISCOVER), reset form with merged values
+        if (defaultValuesOverride) {
+            const merged = defaultValues
+                ? { ...defaultValues, ...defaultValuesOverride }
+                : defaultValuesOverride;
+            formMethods.reset(merged);
+        }
+    }, [initAutoClearing, defaultValuesOverride]);
+    const validateAutosaveField = useCallback(async (fieldName) => {
+        if (!formMethodsRef.current) {
+            logDebug('validateAutosaveField: form methods unavailable, failing closed', { fieldName });
+            return false;
+        }
+        return formMethodsRef.current.trigger(fieldName);
+    }, []);
+    // Autosave handler - saves a single field via PATCH
+    // Uses abortSignal for proper cancellation handling
+    const handleAutosave = useCallback(async (fieldName, value, abortSignal) => {
+        assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm autosave');
+        // Helper to check abort and throw if aborted
+        const checkAborted = () => {
+            if (abortSignal.aborted) {
+                throw new DOMException('Autosave aborted', 'AbortError');
+            }
+        };
+        // Check if already aborted before starting
+        checkAborted();
+        const requestData = mergeRequestDataWithBulkSelection({ [fieldName]: value });
+        // Check abort again after shaping the request payload.
+        checkAborted();
+        const operationPromise = rmm
+            ? rmm.queueMutation({ [fieldName]: value }, {
+                type: MutationType.AUTOSAVE,
+                priority: MutationPriority.LOW,
+                transportOverride: {
+                    ...currentOperationTransportOverride,
+                    requestData,
+                },
+            }).then((mutationResult) => {
+                if (!mutationResult.success) {
+                    throw mutationResult.error ?? new Error('Autosave failed');
+                }
+            })
+            : doOperationRef.current(currentOperationTransportOverride.operationPathKey, {
+                contextualParameters: currentOperationTransportOverride.contextualParameters,
+                requestData,
+                parentResourcesRequirements: currentOperationTransportOverride.parentResourcesRequirements,
+            }, {
+                signal: abortSignal,
+                silent: true, // Don't show global error notifications for autosave
+            });
+        // Note: The Promise.race workaround below is kept as a fallback
+        // in case the abort signal propagation through doOperation fails.
+        // The native signal support (above) should handle most cases.
+        // Create abort promise that rejects when signal is aborted
+        const abortPromise = new Promise((_, reject) => {
+            if (abortSignal.aborted) {
+                reject(new DOMException('Autosave aborted', 'AbortError'));
+                return;
+            }
+            const abortHandler = () => {
+                reject(new DOMException('Autosave aborted', 'AbortError'));
+            };
+            abortSignal.addEventListener('abort', abortHandler, { once: true });
+            // Clean up listener when operation completes
+            operationPromise.finally(() => {
+                abortSignal.removeEventListener('abort', abortHandler);
+            });
+        });
+        // Race between operation and abort - abort wins if signal triggers
+        await Promise.race([operationPromise, abortPromise]);
+        // Final abort check after operation completes
+        checkAborted();
+    }, [
+        assertRMMAvailableForDefaultUpdateLikeMutation,
+        currentOperationTransportOverride,
+        mergeRequestDataWithBulkSelection,
+        rmm,
+    ]);
+    // Section save handler - saves a subset of fields via PATCH
+    const handleSectionSave = useCallback(async (sectionRef, fieldNames, data) => {
+        if (fieldNames.length === 0) {
+            if (envLoader.isDevelopment()) {
+                logger.warn('[ResourceAutomatedForm] Skipping section save because no fields were registered for the section.', {
+                    resourceType,
+                    sectionRef,
+                });
+            }
+            return;
+        }
+        const sectionScopedData = fieldNames.length > 0
+            ? pickSubmissionDataPaths(data, fieldNames)
+            : data;
+        const sanitizedData = sanitizeAutomatedFormSubmissionData(sectionScopedData, {
+            hiddenFieldNames,
+            contextFieldValues,
+        });
+        // If a custom callback is provided, use it
+        if (onSectionSaveRef.current) {
+            await onSectionSaveRef.current(sectionRef, fieldNames, sanitizedData);
+            return;
+        }
+        try {
+            let result;
+            const requestData = mergeRequestDataWithBulkSelection(sanitizedData);
+            if (rmm) {
+                const mutationResult = await rmm.queueMutation(sanitizedData, {
+                    type: MutationType.SECTION,
+                    priority: MutationPriority.NORMAL,
+                    source: { type: MutationSourceType.FORM, subscriberId: `section:${sectionRef}` },
+                    transportOverride: {
+                        ...currentOperationTransportOverride,
+                        requestData,
+                    },
+                });
+                if (!mutationResult.success) {
+                    if (isConflictMutationFailure(mutationResult)) {
+                        return;
+                    }
+                    if (mutationResult.error?.type === MutationErrorType.VALIDATION) {
+                        onErrorRef.current?.(new Error(mutationResult.error.message ?? 'Section save validation failed'));
+                        return;
+                    }
+                    throw new Error(mutationResult.error?.message ?? 'Section save failed');
+                }
+                result = mutationResult.responseData;
+            }
+            else {
+                assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm section save');
+                result = await doOperationRef.current(currentOperationTransportOverride.operationPathKey, {
+                    contextualParameters: currentOperationTransportOverride.contextualParameters,
+                    requestData,
+                    parentResourcesRequirements: currentOperationTransportOverride.parentResourcesRequirements,
+                });
+            }
+            // Emit success event for the section save
+            emitRef.current(FrontendEvents.NOTIFY_RESOURCE_SUCCESS, {
+                ...resourceContext,
+                parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                resultSummary: typeof result === 'object' && result !== null ? result : undefined,
+                additionalContext: {
+                    ...resourceContext.additionalContext,
+                    sectionRef,
+                    fieldNames,
+                    notificationIdentifier: 'section_saved',
+                    notificationLevel: UserNotificationLevel.SUCCESS,
+                },
+            });
+            onSuccessRef.current?.(result);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            onErrorRef.current?.(err);
+            throw error;
+        }
+    }, [
+        assertRMMAvailableForDefaultUpdateLikeMutation,
+        currentOperationTransportOverride,
+        contextFieldValues,
+        contextualParameters,
+        hiddenFieldNames,
+        mergeRequestDataWithBulkSelection,
+        resourceContext,
+        resourceType,
+        rmm,
+    ]);
+    // Autosave config for the provider
+    const autosaveProviderConfig = useMemo(() => ({
+        enabled: autosaveConfig?.enabled ?? false,
+        defaultTrigger: autosaveConfig?.defaultTrigger ?? AutosaveTrigger.DEBOUNCE,
+        debounceMs: autosaveConfig?.debounceMs ?? 500,
+        savedStateDurationMs: 2000,
+    }), [autosaveConfig]);
+    // Draft-relaxed schema for draft saves (makes isDraftRelaxed fields optional)
+    const draftSchema = useMemo(() => {
+        if (!formSchema || !effectiveDraftConfig?.enabled)
+            return null;
+        try {
+            // Map operationType to FormSchemaOperationType (CREATE/UPDATE/READ)
+            const formOperationType = operationType === CoreResourceOperation.CREATE ? 'CREATE' :
+                isUpdateLikeCoreOperation(operationType) ? 'UPDATE' : 'CREATE';
+            const formOperationLike = operationLike === CoreResourceOperation.CREATE ? 'CREATE' :
+                (operationLike && isUpdateLikeCoreOperation(operationLike)) ? 'UPDATE' :
+                    operationLike === CoreResourceOperation.READ ? 'READ' : undefined;
+            return prepareFormSchema(formSchema, {
+                operationType: formOperationType,
+                operationLike: formOperationLike,
+                isDraftMode: true,
+            });
+        }
+        catch {
+            // If schema preparation fails, fall back to null (no draft support)
+            return null;
+        }
+    }, [formSchema, effectiveDraftConfig?.enabled, operationType, operationLike]);
+    // Handle saving as draft
+    const handleSaveDraft = useCallback(async (data) => {
+        if (!effectiveDraftConfig?.enabled)
+            return;
+        cancelPendingAutosavesRef.current?.();
+        setIsSavingDraft(true);
+        clearServerErrors();
+        try {
+            let result;
+            let shouldEmitFrameworkSuccess = true;
+            if (effectiveDraftConfig?.onSaveDraft) {
+                result = await effectiveDraftConfig.onSaveDraft(data);
+                shouldEmitFrameworkSuccess = result !== undefined;
+            }
+            else {
+                const discriminator = effectiveDraftConfig?.discriminator || '_isDraft';
+                const draftValue = effectiveDraftConfig?.draftValue ?? true;
+                const draftData = { ...data, [discriminator]: draftValue };
+                if (rmm) {
+                    const mutationResult = await rmm.queueMutation(draftData, {
+                        type: MutationType.DRAFT,
+                        priority: MutationPriority.HIGH,
+                        source: { type: MutationSourceType.FORM, subscriberId: 'draft' },
+                        transportOverride: {
+                            ...currentOperationTransportOverride,
+                            requestData: draftData,
+                        },
+                    });
+                    if (!mutationResult.success) {
+                        if (isConflictMutationFailure(mutationResult)) {
+                            return;
+                        }
+                        throw new Error(mutationResult.error?.message ?? 'Draft save failed');
+                    }
+                    result = mutationResult.responseData;
+                }
+                else {
+                    assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm draft save');
+                    result = await doOperationRef.current(operationPathKey, {
+                        contextualParameters,
+                        requestData: mergeRequestDataWithBulkSelection(draftData),
+                        parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+                    });
+                }
+            }
+            setIsDraft(true);
+            if (shouldEmitFrameworkSuccess) {
+                emitRef.current(FrontendEvents.NOTIFY_RESOURCE_SUCCESS, {
+                    ...resourceContext,
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                    resultSummary: typeof result === 'object' && result !== null ? result : undefined,
+                    additionalContext: {
+                        ...resourceContext.additionalContext,
+                        notificationIdentifier: 'draftSaved',
+                    },
+                });
+                onSuccessRef.current?.(result);
+            }
+        }
+        catch (error) {
+            if (error instanceof MutationCancelledError) {
+                return;
+            }
+            const serverValidation = extractServerValidationErrors(error);
+            if (serverValidation) {
+                injectServerErrors(serverValidation.validationErrors);
+            }
+            else {
+                emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
+                    ...resourceContext,
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                    additionalContext: {
+                        ...resourceContext.additionalContext,
+                        notificationIdentifier: 'draftSaveFailed',
+                    },
+                });
+            }
+            onErrorRef.current?.(error);
+        }
+        finally {
+            setIsSavingDraft(false);
+        }
+    }, [
+        assertRMMAvailableForDefaultUpdateLikeMutation,
+        currentOperationTransportOverride,
+        effectiveDraftConfig,
+        mergeRequestDataWithBulkSelection,
+        operationPathKey,
+        contextualParameters,
+        resourceContext,
+        injectServerErrors,
+        rmm,
+    ]);
+    // Handle publishing (full validation, called after confirmation if needed)
+    const executePublish = useCallback(async (data) => {
+        if (!effectiveDraftConfig?.enabled)
+            return;
+        cancelPendingAutosavesRef.current?.();
+        setIsSubmitting(true);
+        clearServerErrors();
+        try {
+            let result;
+            let shouldEmitFrameworkSuccess = true;
+            if (effectiveDraftConfig?.onPublish) {
+                result = await effectiveDraftConfig.onPublish(data);
+                shouldEmitFrameworkSuccess = result !== undefined;
+            }
+            else {
+                const discriminator = effectiveDraftConfig?.discriminator || '_isDraft';
+                const publishedValue = effectiveDraftConfig?.publishedValue ?? false;
+                const publishData = { ...data, [discriminator]: publishedValue };
+                if (rmm) {
+                    const mutationResult = await rmm.queueMutation(publishData, {
+                        type: MutationType.PUBLISH,
+                        priority: MutationPriority.HIGH,
+                        source: { type: MutationSourceType.FORM, subscriberId: 'publish' },
+                        transportOverride: {
+                            ...currentOperationTransportOverride,
+                            requestData: publishData,
+                        },
+                    });
+                    if (!mutationResult.success) {
+                        if (isConflictMutationFailure(mutationResult)) {
+                            return;
+                        }
+                        throw new Error(mutationResult.error?.message ?? 'Publish failed');
+                    }
+                    result = mutationResult.responseData;
+                }
+                else {
+                    assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm publish');
+                    result = await doOperationRef.current(operationPathKey, {
+                        contextualParameters,
+                        requestData: mergeRequestDataWithBulkSelection(publishData),
+                        parentResourcesRequirements: resourceContext.parentResourcesRequirements,
+                    });
+                }
+            }
+            setIsDraft(false);
+            if (shouldEmitFrameworkSuccess) {
+                const frontendNotification = getFrontendNotification(operation);
+                if (frontendNotification) {
+                    emitRef.current(FrontendEvents.NOTIFY_RESOURCE_SUCCESS, {
+                        ...resourceContext,
+                        parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                        resultSummary: typeof result === 'object' && result !== null ? result : undefined,
+                        additionalContext: {
+                            ...resourceContext.additionalContext,
+                            notificationIdentifier: frontendNotification.identifier,
+                        },
+                    });
+                }
+                onSuccessRef.current?.(result);
+            }
+        }
+        catch (error) {
+            if (error instanceof MutationCancelledError) {
+                return;
+            }
+            const serverValidation = extractServerValidationErrors(error);
+            if (serverValidation) {
+                injectServerErrors(serverValidation.validationErrors);
+            }
+            else {
+                emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
+                    ...resourceContext,
+                    parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                    additionalContext: {
+                        ...resourceContext.additionalContext,
+                        notificationIdentifier: 'publishFailed',
+                    },
+                });
+            }
+            onErrorRef.current?.(error);
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [
+        assertRMMAvailableForDefaultUpdateLikeMutation,
+        currentOperationTransportOverride,
+        effectiveDraftConfig,
+        mergeRequestDataWithBulkSelection,
+        operationPathKey,
+        contextualParameters,
+        resourceContext,
+        operation,
+        injectServerErrors,
+        rmm,
+    ]);
+    // Public handlePublish that checks for confirmation requirement
+    const handlePublish = useCallback(async (data) => {
+        if (!effectiveDraftConfig?.enabled)
+            return;
+        // Check if confirmation is required
+        const requireConfirmation = effectiveDraftConfig?.requireConfirmationToPublish;
+        if (requireConfirmation) {
+            // Store data and show confirmation dialog
+            setPendingPublish(data);
+            return;
+        }
+        // No confirmation needed, execute directly
+        await executePublish(data);
+    }, [effectiveDraftConfig, executePublish]);
+    // Handler for confirmation dialog confirm action
+    const handleConfirmPublish = useCallback(async () => {
+        if (!pendingPublish)
+            return;
+        await executePublish(pendingPublish);
+        setPendingPublish(null);
+    }, [pendingPublish, executePublish]);
+    // Handler for confirmation dialog cancel action
+    const handleCancelPublish = useCallback(() => {
+        setPendingPublish(null);
+    }, []);
+    // Build default submit button if not provided
+    // When draft mode is enabled, show "Save as Draft" and "Publish" buttons
+    const resolvedSubmitButton = useMemo(() => {
+        const labelKey = getDefaultSubmitLabelKey(effectiveCoreOperation ?? operationIdentifier);
+        const label = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, labelKey);
+        const submittingLabel = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'submitting');
+        if (effectiveDraftConfig?.enabled && draftSchema) {
+            const publishLabel = effectiveDraftConfig?.publishLabel
+                ? tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, effectiveDraftConfig.publishLabel)
+                : tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'publish');
+            const publishingLabel = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'publishing');
+            return (_jsx(Button, { type: "submit", disabled: isSubmitting || isSavingDraft || disabled, children: isSubmitting ? publishingLabel : publishLabel }));
+        }
+        return (_jsx(Button, { type: "submit", disabled: isSubmitting || disabled, children: isSubmitting ? submittingLabel : label }));
+    }, [effectiveCoreOperation, operationIdentifier, isSubmitting, isSavingDraft, disabled, tComponent, effectiveDraftConfig, draftSchema]);
+    const draftSaveButton = useMemo(() => {
+        if (!effectiveDraftConfig?.enabled || !draftSchema)
+            return null;
+        const saveDraftLabel = effectiveDraftConfig?.saveDraftLabel
+            ? tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, effectiveDraftConfig.saveDraftLabel)
+            : tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'saveAsDraft');
+        const savingDraftLabel = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'savingDraft');
+        return (_jsx(DraftSaveButton, { draftSchema: draftSchema, onSaveDraft: handleSaveDraft, disabled: isSavingDraft || isSubmitting || disabled, isSavingDraft: isSavingDraft, label: saveDraftLabel, savingLabel: savingDraftLabel }));
+    }, [effectiveDraftConfig, draftSchema, handleSaveDraft, isSavingDraft, isSubmitting, disabled, tComponent]);
+    /**
+     * Context value for injecting resource-level form actions (submit button, draft button)
+     * into the generated template. The template wrapper reads from this context so that
+     * reactive state (isSubmitting, isSavingDraft) triggers re-renders without remounting
+     * the template component tree.
+     */
+    const formActionsValue = useMemo(() => ({
+        submitButton: resolvedSubmitButton,
+        draftSaveButton,
+    }), [resolvedSubmitButton, draftSaveButton]);
+    const loadingOperationIdentifier = useMemo(() => {
+        if (!needsFetch) {
+            return undefined;
+        }
+        return String(FrontendResourceUtils.resolveSingleResourceReadOperation(resourceType, registry)?.operationIdentifier
+            ?? CoreResourceOperation.READ);
+    }, [needsFetch, resourceType, registry]);
+    // LoadingGate scopes for data fetch (UPDATE-like operations only)
+    const loadingScopes = useMemo(() => {
+        if (!needsFetch || !loadingOperationIdentifier)
+            return [];
+        return [{ resourceType, operation: loadingOperationIdentifier }];
+    }, [needsFetch, resourceType, loadingOperationIdentifier]);
+    const i18nKeys = useMemo(() => [
+        `components.${FrontendComponentType.RESOURCES_LAYOUTS_CREATE}`,
+    ], []);
+    const readiness = useMemo(() => {
+        if (!needsFetch)
+            return [];
+        return [{ id: 'form-data', isReady: hasLoadedOnce }];
+    }, [needsFetch, hasLoadedOnce]);
+    // Error state if fetch failed
+    if (fetchError) {
+        const errorTitle = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'failedToLoadData');
+        // Type-safe access to error context - use type assertion to help TypeScript
+        const errorContext = fetchError.context;
+        const customMessageReference = fetchError.customMessageReference;
+        const errorMessage = (errorContext && typeof errorContext === 'object' && 'originalErrorMessage' in errorContext
+            ? errorContext.originalErrorMessage
+            : undefined) || customMessageReference;
+        return (_jsx("div", { className: className, children: _jsxs("div", { className: "p-card bg-destructive/10 border border-destructive rounded-lg", role: "alert", children: [_jsx("p", { className: "text-destructive font-medium", children: errorTitle }), _jsx("p", { className: "text-sm text-destructive/80 mt-item-xs", children: errorMessage })] }) }));
+    }
+    // For UPDATE operations, LoadingGate readiness now owns the "wait for fetched
+    // defaults" state. Avoid early returns here so the hook graph stays stable
+    // between the initial loading render and the later loaded render.
+    const effectiveDefaultValues = defaultValues ?? defaultValuesOverride;
+    // Guard against missing schema
+    if (!formSchema) {
+        const configErrorTitle = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'configurationError');
+        const noSchemaMsg = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'noSchemaFound', {
+            operation: operationIdentifier,
+            resource: resourceType,
+        });
+        return (_jsx("div", { className: className, children: _jsxs("div", { className: "p-card bg-destructive/10 border border-destructive rounded-lg", role: "alert", children: [_jsx("p", { className: "text-destructive font-medium", children: configErrorTitle }), _jsx("p", { className: "text-sm text-destructive/80 mt-item-xs", children: noSchemaMsg })] }) }));
+    }
+    // i18n labels for confirmation dialog
+    const confirmPublishTitle = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'confirmPublishTitle');
+    const confirmPublishMessage = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'confirmPublishMessage');
+    const confirmPublishCancel = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'cancel');
+    const confirmPublishConfirm = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'publish');
+    // i18n labels for conflict banner (reason-differentiated copy)
+    const conflictLabels = conflictBanner ? {
+        title: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, conflictBanner.reason === ConflictReason.VERSION_CONFLICT ? 'conflictTitleVersion' : 'conflictTitleRemote'),
+        message: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, conflictBanner.reason === ConflictReason.VERSION_CONFLICT ? 'conflictMessageVersion' : 'conflictMessageRemote'),
+        acknowledgeButton: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'conflictAcknowledge'),
+        currentValue: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'conflictCurrentValue'),
+        submittedValue: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'conflictSubmittedValue'),
+        emptyValue: tComponent(FrontendComponentType.LOW_LEVEL_FORM_FIELD, 'noValue'),
+    } : undefined;
+    // i18n labels for remote update indicator
+    const remoteUpdateLabels = remoteUpdateIndicator ? {
+        message: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'remoteUpdateMessage'),
+        dismissAriaLabel: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'dismiss'),
+    } : undefined;
+    const autosaveLabels = useMemo(() => ({
+        errorNetwork: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'autosaveErrorNetwork'),
+        errorValidation: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'autosaveErrorValidation'),
+        errorGeneric: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'autosaveErrorGeneric'),
+        errorConflict: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'autosaveErrorConflict'),
+        errorResourceDeleted: tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'autosaveErrorResourceDeleted'),
+    }), [tComponent]);
+    // Generate a default form layout template. Memoized on schema + config
+    // to ensure stable component identity (prevents form tree remount / state loss).
+    // The wrapper appends resource-level actions (submit + draft buttons) by
+    // reading from ResourceFormActionsContext, so the template identity stays
+    // stable while the reactive button content updates via context.
+    const layoutTemplate = useMemo(() => {
+        if (explicitEditTemplate) {
+            const ExplicitTemplate = explicitEditTemplate;
+            const ResourceFormTemplate = () => {
+                const actions = React.useContext(ResourceFormActionsContext);
+                return (_jsxs(_Fragment, { children: [_jsx(ExplicitTemplate, {}), actions?.draftSaveButton, actions?.submitButton] }));
+            };
+            ResourceFormTemplate.displayName = 'ResourceFormTemplate(explicit)';
+            return ResourceFormTemplate;
+        }
+        const BaseTemplate = generateDefaultFormTemplate(formSchema, {
+            inheritanceConfig,
+            includeSubmitButton: false,
+            includeErrorSummary: showErrorSummary,
+        });
+        const ResourceFormTemplate = () => {
+            const actions = React.useContext(ResourceFormActionsContext);
+            return (_jsxs(_Fragment, { children: [_jsx(BaseTemplate, {}), actions?.draftSaveButton, actions?.submitButton] }));
+        };
+        ResourceFormTemplate.displayName = 'ResourceFormTemplate';
+        return ResourceFormTemplate;
+    }, [explicitEditTemplate, formSchema, inheritanceConfig, showErrorSummary]);
+    // Form content that may or may not be wrapped with AutosaveProvider
+    const formContent = (_jsx(LoadingGate, { i18nKeys: i18nKeys, loadingScopes: loadingScopes, readiness: readiness, children: _jsxs("div", { className: className, children: [_jsx(AlertDialog, { open: !!pendingPublish, onOpenChange: (open) => !open && handleCancelPublish(), children: _jsxs(AlertDialogContent, { children: [_jsxs(AlertDialogHeader, { children: [_jsx(AlertDialogTitle, { children: confirmPublishTitle }), _jsx(AlertDialogDescription, { children: confirmPublishMessage })] }), _jsxs(AlertDialogFooter, { children: [_jsx(AlertDialogCancel, { onClick: handleCancelPublish, children: confirmPublishCancel }), _jsx(AlertDialogAction, { onClick: handleConfirmPublish, children: confirmPublishConfirm })] })] }) }), conflictBanner && conflictLabels && (_jsx(RemoteChangeNotification, { type: "conflict", discardedFields: conflictBanner.discardedFields, conflictDetails: conflictBanner.conflictDetails, labels: conflictLabels, onDismiss: handleAcknowledgeConflict })), remoteUpdateIndicator && remoteUpdateLabels && (_jsx(RemoteChangeNotification, { type: "remote-update", changedFields: remoteUpdateIndicator.changedFields, labels: remoteUpdateLabels, onDismiss: () => setRemoteUpdateIndicator(null) })), _jsx(ResourceFormActionsContext.Provider, { value: formActionsValue, children: _jsx(AutomatedForm, { schema: formSchema, defaultValues: effectiveDefaultValues, onSubmit: effectiveDraftConfig?.enabled && draftSchema ? handlePublish : handleSubmit, onError: handleError, validationMode: validationMode, disabled: disabled || isSubmitting, labels: labels, layoutRefs: layoutRefs, operationRef: operationIdentifier, operationType: operationType, operationLike: operationLike, fileUploadContext: fileUploadContext, contextFieldValues: contextFieldValues, hiddenFieldNames: hiddenFieldNames, generatedFieldOverrides: generatedFieldOverrides, inheritanceConfig: inheritanceConfig, onSectionSave: handleSectionSave, onFormReady: handleFormReady, validateFieldUrl: validateFieldUrl, resourceId: primaryResourceId, contextResourceIdentifiers: contextResourceIdentifiers, navigationZone: navigationZone, layoutTemplate: layoutTemplate }) })] }) }));
+    // Wrap with AutosaveProvider if autosave is enabled
+    if (autosaveProviderConfig.enabled) {
+        return (_jsxs(AutosaveProvider, { labels: autosaveLabels, validateField: validateAutosaveField, onSave: handleAutosave, rmm: rmm ?? undefined, config: autosaveProviderConfig, children: [_jsx(AutosaveCancelBridge, { cancelRef: cancelPendingAutosavesRef }), formContent] }));
+    }
+    return formContent;
+}
+/**
+ * P7: Bridge component to connect autosave cancel function to parent ref.
+ * This allows handleSubmit (defined outside AutosaveProvider) to cancel pending autosaves.
+ */
+function AutosaveCancelBridge({ cancelRef }) {
+    const autosaveContext = useOptionalAutosave();
+    React.useEffect(() => {
+        if (autosaveContext) {
+            cancelRef.current = autosaveContext.cancelAllPending;
+        }
+        return () => {
+            cancelRef.current = null;
+        };
+    }, [autosaveContext, cancelRef]);
+    return null;
+}
+function DraftSaveButton({ draftSchema, onSaveDraft, disabled, isSavingDraft, label, savingLabel, }) {
+    const formContext = useFormContext();
+    const formTemplateContext = useOptionalFormTemplateContext();
+    const handleClick = useCallback(async () => {
+        if (!formContext)
+            return;
+        const values = formContext.getValues();
+        // Validate against the raw RHF snapshot first so draft validation stays
+        // aligned with the normal submit path. Hidden framework-only fields are
+        // pruned only at the payload boundary afterward.
+        const result = draftSchema.safeParse(values);
+        if (result.success) {
+            const sanitizedValues = sanitizeAutomatedFormSubmissionData(result.data, {
+                hiddenFieldNames: formTemplateContext?.hiddenFieldNames,
+                contextFieldValues: formTemplateContext?.contextFieldValues,
+            });
+            // Clear any existing errors and save
+            formContext.clearErrors();
+            await onSaveDraft(sanitizedValues);
+        }
+        else {
+            const zodError = result.error;
+            zodError.issues.forEach((issue) => {
+                const fieldPath = issue.path.join('.');
+                if (fieldPath) {
+                    formContext.setError(fieldPath, {
+                        type: issue.code,
+                        message: issue.message,
+                    });
+                }
+            });
+        }
+    }, [formContext, formTemplateContext?.contextFieldValues, formTemplateContext?.hiddenFieldNames, draftSchema, onSaveDraft]);
+    return (_jsx(Button, { type: "button", variant: ButtonVariants_Variant.OUTLINE, disabled: disabled, onClick: handleClick, children: isSavingDraft ? savingLabel : label }));
+}
+//# sourceMappingURL=ResourceAutomatedForm.js.map