@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.0

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

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * ResourceAutomatedForm Component
  *
@@ -13,23 +13,30 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  */
 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 { CoreResourceOperation, CoreUserNotificationChannel, CoreUserNotificationTarget, RelationshipNature, ResourceRelationshipBulkAction, ResourcesConfig_OperationPathUtils, ResourceOperationVariantType, ErrorCustomMessageReference, ErrorType, UserNotificationLevel, ResourcesConfigOperationsUrlsBuilderUtils, Resources_SharedUtils, ResourceOperationRiskLevel, MAIN_API_BASE_PATH, } from '@wildo-ai/saas-models';
+import { OperationsConfirmCritical } from '../../../components/feedback/operations-confirm-critical.js';
 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 { ResourceFormActionsProvider, useOptionalResourceFormActions, } from './ResourceFormActionsContext.js';
+import { pickSubmissionDataPaths, sanitizeAutomatedFormSubmissionData, shouldOmitClearedFieldsForOperation } from './automated-form-submit.utils.js';
+import { resolveCreateFormInitialValues } from './create-form-default-values.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 { collectErroredFieldPaths, scrollAndFocusFirstErroredField } from '../../../components/form/validation-errors/scroll-to-first-error.utils.js';
+import { extractErrorInfo } from '../../../core/errors/errors.frontend.schemas.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 { pickPreferredOperationForCoreSemanticAddressability } from '../../../core/resources/resource-addressability.frontend.utils.js';
+import { useOperationEnabled } from '../../../core/resources/hooks/useOperationEnabled.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';
@@ -42,10 +49,12 @@ import { envLoader } from '../../../core/runtime/env-variable-loader.frontend.se
 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 { useExecutionDirtyBridge } from '../../../core/execution/useExecutionDirtyBridge.js';
+import { performCanonicalRMMRead, resolveCanonicalRMMReadOperation, 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 { normalizeContextResourceIdentifiersForOutcome, normalizeContextResourceIdentifiersForTransport, } from '../../../core/resources/context-resource-identifiers.frontend.utils.js';
 import { GeneratedAssociationRelationshipField } from './GeneratedAssociationRelationshipField.js';
 import { GeneratedReferenceRelationshipField } from './GeneratedReferenceRelationshipField.js';
 const logger = LoggerFrontendService.getLogger();
@@ -82,7 +91,6 @@ const validateFileId = (fileId) => {
     }
     return Resources_SharedUtils.isValidResourceId(fileId.trim());
 };
-const ResourceFormActionsContext = React.createContext(null);
 /**
  * Get the frontend notification configuration if configured for the current user.
  *
@@ -139,7 +147,32 @@ function shouldFetchExistingData(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, }) {
+/**
+ * Host-owned form actions footer. `ResourceAutomatedForm` appends its
+ * operation-aware submit row (+ optional draft-save button) after the layout
+ * template; this lays them out as a right-aligned footer row (`justify-end`)
+ * with a horizontal gap, so the submit action reads as a proper form footer
+ * instead of a bare button flushed to the inline-start edge. Wraps on narrow
+ * widths. Renders nothing when no host actions are present (standalone
+ * `FormLayout` usage owns its own `<SubmitButton>`).
+ *
+ * `mt-section` is owned HERE, deliberately: the footer's top gap used to be
+ * delegated to `AutomatedForm`'s `space-y-section` on the `<form>` element, but
+ * `Form` wraps ALL children in one `display: contents` fieldset (the disabled
+ * cascade carrier), so the form has exactly one direct child and every
+ * `space-y-*` on it is structurally inert (`> * + *` never reaches
+ * grandchildren). The footer therefore rendered flush against the template's
+ * last row on every resource form (2026-08-19). The footer is the seam's only
+ * consumer, so it carries the margin itself instead of reworking the Form
+ * layout contract.
+ */
+function HostFormActionsFooter() {
+    const actions = useOptionalResourceFormActions();
+    if (!actions)
+        return null;
+    return (_jsxs("div", { className: "mt-section flex flex-col gap-element", children: [actions.submissionNotice, _jsxs("div", { className: "flex flex-wrap items-center justify-end gap-element", children: [actions.cancelButton, actions.draftSaveButton, actions.submitButton] })] }));
+}
+export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, onCancel, 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();
@@ -175,6 +208,11 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
         ? String(operation.resourceOperationLike)
         : undefined;
     const effectiveFormOperationType = operationLike ?? operationType;
+    // ONE authority for "may a cleared field be dropped from this payload?", shared by every
+    // submission boundary this component owns. It previously called the sanitiser twice WITHOUT this
+    // decision while `AutomatedForm`'s own wrappers passed it, so the same surface either stripped or
+    // shipped a `null` depending on which wrapper happened to run.
+    const omitClearedFieldsForSubmission = shouldOmitClearedFieldsForOperation(effectiveCoreOperation, effectiveFormOperationType);
     // State
     const [hasLoadedOnce, setHasLoadedOnce] = useState(false);
     const [isSubmitting, setIsSubmitting] = useState(false);
@@ -186,6 +224,8 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
     const { initAutoClearing, injectServerErrors, clearServerErrors } = useServerErrorInjection(formMethodsRef);
     // State for pending publish data (waiting for confirmation dialog)
     const [pendingPublish, setPendingPublish] = useState(null);
+    // Holds the validated form data of a CRITICAL submit awaiting typed double-validation.
+    const [pendingCriticalSubmit, setPendingCriticalSubmit] = useState(null);
     // Track current draft status
     const [isDraft, setIsDraft] = useState(draftConfig?.isDraft ?? false);
     // Conflict banner (persists until user acknowledges)
@@ -214,6 +254,22 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
     const layoutRefs = resourceConfig?.frontendConfiguration?.layout?.refs;
     // Resolve explicit edit template from layout config
     const explicitEditTemplate = resourceConfig?.frontendConfiguration?.layout?.edit;
+    // Resolve the resource-declared default chrome mode for the EDIT context.
+    //
+    // `ResourceLayoutConfig.defaultChromeMode` documents a per-context cascade
+    // (`{primitive}UI.{context}.chromeMode ?? layout.defaultChromeMode.{context}
+    // ?? system-default`) with three slots: display, summary, edit. The display
+    // and summary legs are wired by `ResourceAutomaticDisplayer`
+    // (`defaultChromeMode.display`) and `ResourceSummaryDisplayer`
+    // (`defaultChromeMode.summary`) respectively. The edit leg was never threaded
+    // here, so an authored `defaultChromeMode: { edit: EditChromeMode.SETTINGS_ROW }`
+    // was silently dropped: edit fields fell straight through to the
+    // surface-policy / STACKED system default. We thread it into
+    // `AutomatedForm.chromeMode`, which seeds `FormChromeProvider` as the
+    // form-level slot of the cascade — section-level `<Section chromeMode>` and
+    // field-level `{primitive}UI.edit.chromeMode` still override it. Applies to
+    // both explicit `layout.edit` templates and the generated edit layout.
+    const defaultEditChromeMode = resourceConfig?.frontendConfiguration?.layout?.defaultChromeMode?.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)
@@ -379,22 +435,92 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
     const isUpdateLikeOperation = useMemo(() => {
         return isSingleResourceUpdateLikeOperation(operation);
     }, [operation]);
+    const resourceId = useMemo(() => {
+        const contextId = contextResourceIdentifiers[resourceType];
+        if (contextId) {
+            return typeof contextId === 'string' ? contextId : contextId.resourceId;
+        }
+        const loadedId = defaultValues && typeof defaultValues === 'object'
+            ? defaultValues._id
+            : undefined;
+        return typeof loadedId === 'string' && loadedId.length > 0 ? loadedId : null;
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [contextResourceIdentifiersKey, defaultValues, resourceType]);
+    const parentResourcesRequirementsKey = useMemo(() => {
+        return JSON.stringify(resourceContext.parentResourcesRequirements ?? []);
+    }, [resourceContext.parentResourcesRequirements]);
+    const contextResourceIdentifiersWithResourceId = useMemo(() => {
+        if (!resourceId || contextResourceIdentifiers[resourceType]) {
+            return contextResourceIdentifiers;
+        }
+        return {
+            ...contextResourceIdentifiers,
+            [resourceType]: resourceId,
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [contextResourceIdentifiersKey, resourceId, resourceType]);
+    const contextualParametersWithResourceId = useMemo(() => {
+        const resourceFieldIdentifier = resourceConfig?.resourceFieldIdentifier;
+        if (!resourceId || !resourceFieldIdentifier) {
+            return contextualParameters;
+        }
+        if (String(contextualParameters[resourceFieldIdentifier] ?? '') === resourceId) {
+            return contextualParameters;
+        }
+        return {
+            ...contextualParameters,
+            [resourceFieldIdentifier]: resourceId,
+        };
+    }, [contextualParameters, resourceConfig?.resourceFieldIdentifier, resourceId]);
+    const currentOperationPathKey = useMemo(() => {
+        if (!isUpdateLikeOperation
+            || effectiveCoreOperation !== CoreResourceOperation.UPDATE
+            || operation.operationIdentifier !== CoreResourceOperation.UPDATE
+            || !resourceConfig) {
+            return operationPathKey;
+        }
+        const addressableOperation = pickPreferredOperationForCoreSemanticAddressability({
+            resourceConfig,
+            operations: resourceOperations,
+            coreOperation: CoreResourceOperation.UPDATE,
+            registry,
+            hasResourceId: Boolean(resourceId),
+            contextResourceIdentifiers: contextResourceIdentifiersWithResourceId,
+            contextualParameters: contextualParametersWithResourceId,
+        });
+        return addressableOperation
+            ? ResourcesConfig_OperationPathUtils.createOperationPathKeyFromOperation(addressableOperation)
+            : operationPathKey;
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [
+        contextResourceIdentifiersKey,
+        contextResourceIdentifiersWithResourceId,
+        contextualParametersWithResourceId,
+        effectiveCoreOperation,
+        isUpdateLikeOperation,
+        operation.operationIdentifier,
+        operationPathKey,
+        registry,
+        resourceConfig,
+        resourceId,
+        resourceOperations,
+    ]);
     const currentOperationTransportOverride = useMemo(() => {
         const requiresAuthoritativeReadBack = isUpdateLikeOperation
             && effectiveCoreOperation === CoreResourceOperation.UPDATE
             && operationIdentifier !== CoreResourceOperation.UPDATE;
         return {
-            operationPathKey,
-            contextualParameters,
+            operationPathKey: currentOperationPathKey,
+            contextualParameters: contextualParametersWithResourceId,
             parentResourcesRequirements: resourceContext.parentResourcesRequirements,
             ...(requiresAuthoritativeReadBack ? { readBackOnSuccess: true } : {}),
         };
     }, [
-        contextualParameters,
+        contextualParametersWithResourceId,
+        currentOperationPathKey,
         effectiveCoreOperation,
         isUpdateLikeOperation,
         operationIdentifier,
-        operationPathKey,
         resourceContext.parentResourcesRequirements,
     ]);
     const mergeRequestDataWithBulkSelection = useCallback((requestData) => {
@@ -404,24 +530,37 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             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({
+    const { rmm, rmmSnapshot, canonicalReadOperationPathKey: rmmCanonicalReadOperationPathKey, } = useResourceRMM({
         resourceType,
         resourceId,
         doOperationRef,
-        contextualParameters,
+        contextualParameters: contextualParametersWithResourceId,
         parentResourcesRequirements: resourceContext.parentResourcesRequirements,
-        contextResourceIdentifiers,
+        contextResourceIdentifiers: contextResourceIdentifiersWithResourceId,
         resourceSchema: resourceConfig?.mainSchema,
         enabled: isUpdateLikeOperation && !!resourceId,
         conflictPolicy: { strategy: ConflictStrategy.ACCEPT_REMOTE },
     });
+    // Slice F — execution-shell dirty-state publisher.
+    //
+    // Bridge the RMM's `hasUnsavedChanges` signal into the execution-shell
+    // dirty-state aggregator whenever this form is mounted inside an
+    // `ExecutionRuntimeProvider`. The bridge is a no-op outside an execution
+    // shell, so the call is safe for every other mounting context (resource
+    // layouts, composite views, custom views, etc.).
+    //
+    // Marker id is content-derived (`rmm:${resourceType}:${resourceId || ''}`)
+    // so re-marks are idempotent across form re-mounts triggered by embed
+    // open/replace cycles. Scope is inferred from
+    // `ExecutionDirtyMarkerScopeContext` (set to `EMBEDDED_CONTENT` by the
+    // shell's embed slot; defaults to `CUSTOM` otherwise — informative,
+    // cleared on unmount). When `rmm` is null (CREATE flow, fallback mode,
+    // or no eligible UPDATE operation), `hasUnsavedChanges` stays `false`
+    // and the bridge does nothing.
+    useExecutionDirtyBridge({
+        markerId: `rmm:${resourceType}:${resourceId ?? ''}`,
+        isDirty: !!rmm && rmmSnapshot.hasUnsavedChanges,
+    });
     // 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:
@@ -660,28 +799,43 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             return null;
         }
         try {
-            const primaryResourceId = frontendResourceUtils.getPrimaryResourceIdentifier(resourceContext);
+            const primaryResourceId = isUpdateOperation
+                ? resourceId ?? frontendResourceUtils.getPrimaryResourceIdentifier(resourceContext)
+                : 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);
+            const contextualParameters = { ...contextualParametersWithResourceId };
             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;
+                : resourceConfig && isUpdateOperation
+                    ? pickPreferredOperationForCoreSemanticAddressability({
+                        resourceConfig,
+                        operations: resourceConfig.operations ?? [],
+                        coreOperation: CoreResourceOperation.UPDATE,
+                        registry,
+                        hasResourceId: Boolean(resourceId),
+                        contextResourceIdentifiers: contextResourceIdentifiersWithResourceId,
+                        contextualParameters: contextualParametersWithResourceId,
+                    })
+                    : resourceConfig
+                        ? pickPreferredOperationForCoreSemantic(resourceConfig.operations ?? [], 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;
+                    const routePath = frontendResourceUtils.selectMatchingRoutePath(routePaths, contextResourceIdentifiersWithResourceId, resourceConfig.resourceIdentifier, resourceFieldIdentifier, resourceContext.parentResourcesRequirements);
+                    // Frontend route paths omit `MAIN_API_BASE_PATH` (`/api/v1`); this `basePath`
+                    // is used to build BACKEND API endpoints (the `validate-field` route), so it
+                    // must carry the API prefix — same reason as the upload endpoint below.
+                    basePath = `${MAIN_API_BASE_PATH}${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', {
@@ -708,7 +862,17 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             logger.error('[ResourceAutomatedForm] Error computing resource API base:', error);
             return null;
         }
-    }, [effectiveCoreOperation, operation, resourceType, resourceConfig, contextResourceIdentifiers, registry, resourceContext]);
+    }, [
+        contextResourceIdentifiersWithResourceId,
+        contextualParametersWithResourceId,
+        effectiveCoreOperation,
+        operation,
+        registry,
+        resourceConfig,
+        resourceContext,
+        resourceId,
+        resourceType,
+    ]);
     // 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
@@ -722,7 +886,17 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             const uploadOperation = (operation.variantType === ResourceOperationVariantType.API_CALL
                 || operation.variantType === ResourceOperationVariantType.API_CALL_WITH_CALLBACK)
                 ? operation
-                : pickPreferredOperationForCoreSemantic(resourceConfig.operations ?? [], isUpdateOperation ? CoreResourceOperation.UPDATE : CoreResourceOperation.CREATE);
+                : isUpdateOperation
+                    ? pickPreferredOperationForCoreSemanticAddressability({
+                        resourceConfig,
+                        operations: resourceConfig.operations ?? [],
+                        coreOperation: CoreResourceOperation.UPDATE,
+                        registry,
+                        hasResourceId: Boolean(resourceId),
+                        contextResourceIdentifiers: contextResourceIdentifiersWithResourceId,
+                        contextualParameters: contextualParametersWithResourceId,
+                    })
+                    : pickPreferredOperationForCoreSemantic(resourceConfig.operations ?? [], CoreResourceOperation.CREATE);
             if (!uploadOperation) {
                 return context;
             }
@@ -730,9 +904,9 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             if (uploadRoutePaths.length === 0) {
                 return context;
             }
-            const routePath = frontendResourceUtils.selectMatchingRoutePath(uploadRoutePaths, contextResourceIdentifiers, resourceConfig.resourceIdentifier, resourceConfig.resourceFieldIdentifier, resourceContext.parentResourcesRequirements);
+            const routePath = frontendResourceUtils.selectMatchingRoutePath(uploadRoutePaths, contextResourceIdentifiersWithResourceId, resourceConfig.resourceIdentifier, resourceConfig.resourceFieldIdentifier, resourceContext.parentResourcesRequirements);
             const filesBasePath = `${apiBaseUrl}/api/v1/files`;
-            const fileFieldPaths = AutomatedLayoutFrontendUtils.collectFileFieldPaths(formSchema);
+            const fileFieldPaths = AutomatedLayoutFrontendUtils.collectUploadableFileFieldPaths(formSchema);
             for (const fieldName of fileFieldPaths) {
                 const uploadRoute = ResourcesConfigOperationsUrlsBuilderUtils.buildFileUploadRouteForOperation({
                     operationRouteUrl: routePath.url,
@@ -751,7 +925,15 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                     });
                     continue;
                 }
-                const uploadEndpoint = `${apiBaseUrl}${resolvedUploadPath}`;
+                // `resolvedUploadPath` comes from `buildOperationFrontendRoutePaths`, which
+                // builds React-Router APP paths and deliberately OMITS `MAIN_API_BASE_PATH`
+                // (`/api/v1`) — see the `!isFrontend ? [MAIN_API_BASE_PATH] : []` seam in the
+                // URL builder. The backend registers the upload route off the API route
+                // (`initiatorInfo.url`, WITH `/api/v1`), so the endpoint must carry the same
+                // prefix or every resource-integrated upload 404s (the segment naming already
+                // matches — both sides use the same parent-combination builder). This mirrors
+                // the metadata endpoint above, which hardcodes `/api/v1/files`.
+                const uploadEndpoint = `${apiBaseUrl}${MAIN_API_BASE_PATH}${resolvedUploadPath}`;
                 context[fieldName] = {
                     upload: uploadEndpoint,
                     override: isUpdateOperation ? uploadEndpoint : undefined,
@@ -765,7 +947,15 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             logger.error('[ResourceAutomatedForm] Error generating file upload context:', error);
         }
         return context;
-    }, [formSchema, operation, resourceApiBase, resourceConfig, resourceContext.parentResourcesRequirements, resourceType]);
+    }, [
+        contextResourceIdentifiersWithResourceId,
+        formSchema,
+        operation,
+        parentResourcesRequirementsKey,
+        resourceApiBase,
+        resourceConfig,
+        resourceType,
+    ]);
     // =============================================================================
     // SERVER-SIDE FIELD VALIDATION CONTEXT
     // =============================================================================
@@ -807,29 +997,118 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
      * validation shouldn't conflict with the resource's own values during UPDATE).
      */
     const primaryResourceId = useMemo(() => {
-        return frontendResourceUtils.getPrimaryResourceIdentifier(resourceContext) ?? undefined;
-    }, [resourceContext]);
+        return resourceId ?? frontendResourceUtils.getPrimaryResourceIdentifier(resourceContext) ?? undefined;
+    }, [resourceContext, resourceId]);
+    const canonicalReadOperation = useMemo(() => {
+        if (rmm) {
+            return undefined;
+        }
+        return resolveCanonicalRMMReadOperation(resourceType, registry, {
+            hasResourceId: Boolean(resourceId),
+            contextResourceIdentifiers: contextResourceIdentifiersWithResourceId,
+            contextualParameters: contextualParametersWithResourceId,
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [contextResourceIdentifiersKey, contextResourceIdentifiersWithResourceId, contextualParametersWithResourceId, registry, resourceId, resourceType, rmm]);
     const canonicalReadOperationPathKey = useMemo(() => {
-        return rmm?.readOperationPathKey ?? resolveCanonicalRMMReadOperationPathKey(resourceType, registry);
-    }, [registry, resourceType, rmm?.readOperationPathKey]);
+        if (rmm) {
+            return rmmCanonicalReadOperationPathKey;
+        }
+        return canonicalReadOperation
+            ? ResourcesConfig_OperationPathUtils.createOperationPathKeyFromOperation(canonicalReadOperation)
+            : resolveCanonicalRMMReadOperationPathKey(resourceType, registry, {
+                hasResourceId: Boolean(resourceId),
+                contextResourceIdentifiers: contextResourceIdentifiersWithResourceId,
+                contextualParameters: contextualParametersWithResourceId,
+            });
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- using stable key instead of object reference
+    }, [canonicalReadOperation, contextResourceIdentifiersKey, contextResourceIdentifiersWithResourceId, contextualParametersWithResourceId, registry, resourceId, resourceType, rmm, rmmCanonicalReadOperationPathKey]);
     // Determine if we need to fetch existing data
     const needsFetch = useMemo(() => shouldFetchExistingData(operation), [operation]);
+    const lastExistingDataFetchKeyRef = useRef(null);
+    // ── EA: post-load operation-availability guard ─────────────────────────────
+    // The action bar / display gate only guards navigations IT initiates; a
+    // deep-link, bookmark, or a tab left open while the record changed can still
+    // land directly on an operation's form. This host is the one place that loads
+    // the record (for UPDATE-like ops), so it is the correct layer to re-check
+    // `enabledCondition` against the REAL object and render an "unavailable" state
+    // instead of a form the backend would reject on submit. Armed only for
+    // operations that act on an existing resource (`needsFetch`) once the record
+    // has loaded; CREATE (no object) and the loading window are skipped, so the
+    // hook returns `isEnabled: true` and never trips the guard for them.
+    const operationAvailability = useOperationEnabled({
+        operation,
+        currentObject: needsFetch ? defaultValues : undefined,
+        resourceType,
+        enabled: needsFetch && hasLoadedOnce && !fetchError,
+    });
+    // CREATE-only synchronous default-value seed.
+    //
+    // Two jobs (see `resolveCreateFormInitialValues` for the full rationale):
+    // 1. For a `createSchemaFamily` resource the form validates against a
+    //    `z.discriminatedUnion`, which dispatches on the RAW discriminator value
+    //    BEFORE any variant `.default()` is applied. When the discriminator field
+    //    is not rendered by the layout (e.g. Wonder Todos `todos.recurringType`),
+    //    it would stay `undefined` and every create would fail with
+    //    `{ <discriminator>: "Invalid input" }` — the POST never fires.
+    // 2. Audit D3: every field with a declared schema `.default()` is seeded so
+    //    the create form DISPLAYS the values the backend will apply (a `status`
+    //    defaulting to `pending` no longer renders an empty "Select...").
+    // It MUST be synchronous: `Form`/`useForm` consume `defaultValues` only at
+    // initialization and never reset, so an effect-set seed would arrive after the
+    // first mount and never reach RHF.
+    // Computed only for CREATE; UPDATE-like operations take their defaults from the
+    // fetched record. Default-free non-discriminated resources resolve to `undefined`.
+    const createSeededDefaultValues = useMemo(() => {
+        if (needsFetch)
+            return undefined;
+        return resolveCreateFormInitialValues({
+            formFieldShape,
+            inheritanceConfig,
+            defaultValuesOverride: defaultValuesOverride,
+        });
+    }, [needsFetch, formFieldShape, inheritanceConfig, defaultValuesOverride]);
     // Fetch existing data for UPDATE-like operations
     // Use refs to avoid infinite loops from unstable function references
     useEffect(() => {
         if (!needsFetch) {
+            // CREATE path. The discriminated-union discriminator default is seeded
+            // SYNCHRONOUSLY via `createSeededDefaultValues` / `effectiveDefaultValues`
+            // (Form.tsx reads `defaultValues` only at useForm init and never resets, so
+            // an async/effect-set seed would arrive after mount and never reach RHF —
+            // the discriminator would stay undefined and the resolver would reject the
+            // submit with "Invalid input"). Here we keep the prior contract.
             setDefaultValues(defaultValuesOverride ?? undefined);
             setHasLoadedOnce(true);
             return;
         }
+        const existingDataFetchKey = JSON.stringify({
+            canonicalReadOperationPathKey,
+            contextResourceIdentifiersKey,
+            parentResourcesRequirementsKey,
+        });
+        if (hasLoadedOnce && lastExistingDataFetchKeyRef.current === existingDataFetchKey) {
+            if (rmm
+                && defaultValues
+                && typeof rmm.getSnapshot === 'function'
+                && rmm.getSnapshot().confirmedData === null
+                && typeof rmm.setInitialState === 'function') {
+                const dataRecord = defaultValues;
+                rmm.setInitialState(dataRecord, dataRecord._version ?? 0, dataRecord._field_meta);
+            }
+            return;
+        }
         let cancelled = false;
         const fetchData = async () => {
             setFetchError(null);
             try {
+                if (!canonicalReadOperationPathKey) {
+                    throw new Error('No addressable canonical READ operation is available for this resource form context.');
+                }
                 const data = await performCanonicalRMMRead({
                     doOperation: doOperationRef.current,
                     readOperationPathKey: canonicalReadOperationPathKey,
-                    contextualParameters,
+                    contextualParameters: contextualParametersWithResourceId,
                     parentResourcesRequirements: resourceContext.parentResourcesRequirements,
                 });
                 if (cancelled)
@@ -841,6 +1120,7 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                 setDefaultValues(defaultValuesOverride
                     ? { ...dataRecord, ...defaultValuesOverride }
                     : data);
+                lastExistingDataFetchKeyRef.current = existingDataFetchKey;
                 setHasLoadedOnce(true);
             }
             catch (error) {
@@ -848,8 +1128,10 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                     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;
+                // E-5: route through extractErrorInfo so structured WildoError_Backend
+                // payloads (with customMessageReference + context) are preferred over
+                // best-effort plain `error.code` / `error.context` access.
+                const errorInfo = extractErrorInfo(error);
                 const wildoError = errorBuilder.buildWildoError_Frontend(ErrorType.NOT_FOUND, {
                     customMessageReference: ErrorCustomMessageReference.FRONTEND_FORM_READ_OPERATION_NOT_AVAILABLE,
                     operationPathKey: canonicalReadOperationPathKey,
@@ -858,9 +1140,8 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                         operationIdentifier,
                         originalErrorMessage: originalError.message,
                         originalErrorStack: originalError.stack,
-                        // Include HTTP error details if available
-                        httpCode: errorData?.code,
-                        httpContext: errorData?.context,
+                        httpCode: errorInfo.code,
+                        httpContext: errorInfo.context,
                     },
                 });
                 setFetchError(wildoError);
@@ -872,7 +1153,7 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             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]);
+    }, [needsFetch, canonicalReadOperationPathKey, resourceType, contextResourceIdentifiersKey, contextualParametersWithResourceId, parentResourcesRequirementsKey, errorBuilder, operationIdentifier, defaultValuesOverride, rmm, hasLoadedOnce, defaultValues]);
     // 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
@@ -905,11 +1186,18 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             }
             else {
                 assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm submit');
-                result = await doOperationRef.current(operationPathKey, {
-                    contextualParameters,
+                result = await doOperationRef.current(currentOperationTransportOverride.operationPathKey, {
+                    contextualParameters: currentOperationTransportOverride.contextualParameters,
                     requestData: mergeRequestDataWithBulkSelection(data),
-                    parentResourcesRequirements: resourceContext.parentResourcesRequirements,
-                });
+                    parentResourcesRequirements: currentOperationTransportOverride.parentResourcesRequirements,
+                }, 
+                // `silent`: this form owns the user-facing failure UX (the catch below
+                // emits NOTIFY_RESOURCE_ERROR + injects inline field errors). Suppress the
+                // GLOBAL error toast so a failed create/direct-mutation shows ONE toast,
+                // matching the RMM update path (HttpTransportAdapter also passes silent).
+                // Side-effects (auth-logout on 401, redirect, dedup) still run — `silent`
+                // now suppresses only the global display, not the ERROR_OCCURED event.
+                { silent: true });
             }
             logDebug('handleSubmit: success', { operationPathKey });
             // Emit success notification event if configured
@@ -924,6 +1212,11 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                             : FrontendEvents.NOTIFY_RESOURCE_SUCCESS;
                 emitRef.current(eventType, {
                     ...resourceContext,
+                    contextResourceIdentifiers: normalizeContextResourceIdentifiersForOutcome({
+                        contextResourceIdentifiers: resourceContext.contextResourceIdentifiers,
+                        resourceType,
+                        result,
+                    }),
                     parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                     resultSummary: typeof result === 'object' && result !== null ? result : undefined,
                     additionalContext: {
@@ -974,10 +1267,16 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                 logDebug('handleSubmit: general error (not validation)', { message: err.message });
                 emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
                     ...resourceContext,
+                    contextResourceIdentifiers: normalizeContextResourceIdentifiersForTransport(resourceContext.contextResourceIdentifiers),
                     parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                     additionalContext: {
                         ...resourceContext.additionalContext,
                         error: err.message,
+                        // Carry the backend error reference + status so the notification layer
+                        // can resolve a localized human message (tErrorMessage) instead of
+                        // falling back to the operation title. See NotificationContext.resolveMessage.
+                        errorCustomMessageReference: error?.customMessageReference,
+                        errorHttpStatus: error?.httpStatus,
                     },
                 });
             }
@@ -1003,6 +1302,11 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             fields: Object.keys(errors),
         });
         logger.warn('[ResourceAutomatedForm] Form validation errors', errors);
+        // Audit D4: on a failed submit the errors render inline but the viewport
+        // stays at the submit button — scroll the first errored field (DOM order)
+        // into view and focus it. Server-side validation gets the same treatment
+        // inside `injectServerErrors` (the single injection seam).
+        scrollAndFocusFirstErroredField(collectErroredFieldPaths(errors));
     };
     // When defaultValuesOverride changes (e.g. after DISCOVER), reset form with merged values
     useEffect(() => {
@@ -1114,6 +1418,8 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
         const sanitizedData = sanitizeAutomatedFormSubmissionData(sectionScopedData, {
             hiddenFieldNames,
             contextFieldValues,
+            omitClearedFields: omitClearedFieldsForSubmission,
+            schema: formSchema,
         });
         // If a custom callback is provided, use it
         if (onSectionSaveRef.current) {
@@ -1151,11 +1457,19 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                     contextualParameters: currentOperationTransportOverride.contextualParameters,
                     requestData,
                     parentResourcesRequirements: currentOperationTransportOverride.parentResourcesRequirements,
-                });
+                }, 
+                // silent: form owns the failure UX (catch emits NOTIFY_RESOURCE_ERROR);
+                // suppress the duplicate global toast. See handleSubmit for rationale.
+                { silent: true });
             }
             // Emit success event for the section save
             emitRef.current(FrontendEvents.NOTIFY_RESOURCE_SUCCESS, {
                 ...resourceContext,
+                contextResourceIdentifiers: normalizeContextResourceIdentifiersForOutcome({
+                    contextResourceIdentifiers: resourceContext.contextResourceIdentifiers,
+                    resourceType,
+                    result,
+                }),
                 parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                 resultSummary: typeof result === 'object' && result !== null ? result : undefined,
                 additionalContext: {
@@ -1171,7 +1485,23 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
             onErrorRef.current?.(err);
-            throw error;
+            // Resource layer owns the failure UX: emit ONE resource error toast (the
+            // doOperation above is `silent`, so the global toast is suppressed). We do
+            // NOT re-throw: the sole consumer (`Section.tsx` save button) has no catch and
+            // no success/failure branching, so a throw would surface ONLY as an unhandled
+            // promise rejection → a generic global toast. This keeps section-save aligned
+            // with handleSubmit/draft/publish (single, resource-aware toast).
+            emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
+                ...resourceContext,
+                contextResourceIdentifiers: normalizeContextResourceIdentifiersForTransport(resourceContext.contextResourceIdentifiers),
+                parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
+                additionalContext: {
+                    ...resourceContext.additionalContext,
+                    sectionRef,
+                    error: err.message,
+                    errorCustomMessageReference: error?.customMessageReference,
+                },
+            });
         }
     }, [
         assertRMMAvailableForDefaultUpdateLikeMutation,
@@ -1251,17 +1581,24 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                 }
                 else {
                     assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm draft save');
-                    result = await doOperationRef.current(operationPathKey, {
-                        contextualParameters,
+                    result = await doOperationRef.current(currentOperationTransportOverride.operationPathKey, {
+                        contextualParameters: currentOperationTransportOverride.contextualParameters,
                         requestData: mergeRequestDataWithBulkSelection(draftData),
-                        parentResourcesRequirements: resourceContext.parentResourcesRequirements,
-                    });
+                        parentResourcesRequirements: currentOperationTransportOverride.parentResourcesRequirements,
+                    }, 
+                    // silent: form owns the failure UX (catch emits NOTIFY_RESOURCE_ERROR).
+                    { silent: true });
                 }
             }
             setIsDraft(true);
             if (shouldEmitFrameworkSuccess) {
                 emitRef.current(FrontendEvents.NOTIFY_RESOURCE_SUCCESS, {
                     ...resourceContext,
+                    contextResourceIdentifiers: normalizeContextResourceIdentifiersForOutcome({
+                        contextResourceIdentifiers: resourceContext.contextResourceIdentifiers,
+                        resourceType,
+                        result,
+                    }),
                     parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                     resultSummary: typeof result === 'object' && result !== null ? result : undefined,
                     additionalContext: {
@@ -1283,10 +1620,14 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             else {
                 emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
                     ...resourceContext,
+                    contextResourceIdentifiers: normalizeContextResourceIdentifiersForTransport(resourceContext.contextResourceIdentifiers),
                     parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                     additionalContext: {
                         ...resourceContext.additionalContext,
                         notificationIdentifier: 'draftSaveFailed',
+                        // Fallback if the 'draftSaveFailed' label is absent: resolveMessage then
+                        // degrades to the localized backend error rather than the generic default.
+                        errorCustomMessageReference: error?.customMessageReference,
                     },
                 });
             }
@@ -1300,9 +1641,8 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
         currentOperationTransportOverride,
         effectiveDraftConfig,
         mergeRequestDataWithBulkSelection,
-        operationPathKey,
-        contextualParameters,
         resourceContext,
+        resourceType,
         injectServerErrors,
         rmm,
     ]);
@@ -1344,11 +1684,13 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                 }
                 else {
                     assertRMMAvailableForDefaultUpdateLikeMutation('ResourceAutomatedForm publish');
-                    result = await doOperationRef.current(operationPathKey, {
-                        contextualParameters,
+                    result = await doOperationRef.current(currentOperationTransportOverride.operationPathKey, {
+                        contextualParameters: currentOperationTransportOverride.contextualParameters,
                         requestData: mergeRequestDataWithBulkSelection(publishData),
-                        parentResourcesRequirements: resourceContext.parentResourcesRequirements,
-                    });
+                        parentResourcesRequirements: currentOperationTransportOverride.parentResourcesRequirements,
+                    }, 
+                    // silent: form owns the failure UX (catch emits NOTIFY_RESOURCE_ERROR).
+                    { silent: true });
                 }
             }
             setIsDraft(false);
@@ -1357,6 +1699,11 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
                 if (frontendNotification) {
                     emitRef.current(FrontendEvents.NOTIFY_RESOURCE_SUCCESS, {
                         ...resourceContext,
+                        contextResourceIdentifiers: normalizeContextResourceIdentifiersForOutcome({
+                            contextResourceIdentifiers: resourceContext.contextResourceIdentifiers,
+                            resourceType,
+                            result,
+                        }),
                         parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                         resultSummary: typeof result === 'object' && result !== null ? result : undefined,
                         additionalContext: {
@@ -1379,10 +1726,14 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             else {
                 emitRef.current(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
                     ...resourceContext,
+                    contextResourceIdentifiers: normalizeContextResourceIdentifiersForTransport(resourceContext.contextResourceIdentifiers),
                     parentResourcesRequirements: resourceContext.parentResourcesRequirements || [],
                     additionalContext: {
                         ...resourceContext.additionalContext,
                         notificationIdentifier: 'publishFailed',
+                        // Fallback if the 'publishFailed' label is absent: resolveMessage then
+                        // degrades to the localized backend error rather than the generic default.
+                        errorCustomMessageReference: error?.customMessageReference,
                     },
                 });
             }
@@ -1396,9 +1747,8 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
         currentOperationTransportOverride,
         effectiveDraftConfig,
         mergeRequestDataWithBulkSelection,
-        operationPathKey,
-        contextualParameters,
         resourceContext,
+        resourceType,
         operation,
         injectServerErrors,
         rmm,
@@ -1428,6 +1778,35 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
     const handleCancelPublish = useCallback(() => {
         setPendingPublish(null);
     }, []);
+    // ── CRITICAL "double validation" on form submit ──────────────────────────
+    // A CRITICAL operation reached through a form (e.g. a reset-with-flags) must
+    // require the same typed double-validation the action bar applies to
+    // direct-execute CRITICAL ops: the submit is held until the user types the
+    // action label in the confirm dialog. This is the form-submit twin of the
+    // confirm-dialog gate in `useResourceOperationActions`.
+    const isCriticalOperation = operation.riskLevel === ResourceOperationRiskLevel.CRITICAL;
+    const criticalConfirmationPhrase = useMemo(() => {
+        // Humanise the operation identifier (e.g. `reset_to_defaults` → "Reset to
+        // defaults"), matching the action-bar phrase for custom operations.
+        const opId = String(operation.operationIdentifier);
+        return opId.charAt(0).toUpperCase() + opId.slice(1).replace(/_/g, ' ').toLowerCase();
+    }, [operation.operationIdentifier]);
+    const handleSubmitWithCriticalGuard = useCallback((data) => {
+        if (isCriticalOperation) {
+            setPendingCriticalSubmit(data);
+            return;
+        }
+        void handleSubmit(data);
+    }, [isCriticalOperation, handleSubmit]);
+    const handleConfirmCriticalSubmit = useCallback(() => {
+        const data = pendingCriticalSubmit;
+        setPendingCriticalSubmit(null);
+        if (data !== null)
+            void handleSubmit(data);
+    }, [pendingCriticalSubmit, handleSubmit]);
+    const handleCancelCriticalSubmit = useCallback(() => {
+        setPendingCriticalSubmit(null);
+    }, []);
     // Build default submit button if not provided
     // When draft mode is enabled, show "Save as Draft" and "Publish" buttons
     const resolvedSubmitButton = useMemo(() => {
@@ -1443,6 +1822,15 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
         }
         return (_jsx(Button, { type: "submit", disabled: isSubmitting || disabled, children: isSubmitting ? submittingLabel : label }));
     }, [effectiveCoreOperation, operationIdentifier, isSubmitting, isSavingDraft, disabled, tComponent, effectiveDraftConfig, draftSchema]);
+    // Secondary Cancel button (audit D5) — rendered only when the host supplies
+    // `onCancel` (overlay-hosted forms pass the same close path as the X button).
+    // `type="button"` so it can never trigger the surrounding form's submit.
+    const cancelButton = useMemo(() => {
+        if (!onCancel)
+            return null;
+        const cancelLabel = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'cancel');
+        return (_jsx(Button, { type: "button", variant: ButtonVariants_Variant.OUTLINE, disabled: isSubmitting || isSavingDraft, onClick: onCancel, children: cancelLabel }));
+    }, [onCancel, isSubmitting, isSavingDraft, tComponent]);
     const draftSaveButton = useMemo(() => {
         if (!effectiveDraftConfig?.enabled || !draftSchema)
             return null;
@@ -1450,7 +1838,7 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             ? 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 }));
+        return (_jsx(DraftSaveButton, { draftSchema: draftSchema, omitClearedFields: omitClearedFieldsForSubmission, submissionSchema: formSchema, 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)
@@ -1458,17 +1846,38 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
      * reactive state (isSubmitting, isSavingDraft) triggers re-renders without remounting
      * the template component tree.
      */
+    // i18n labels for conflict banner (reason-differentiated copy). Computed here,
+    // BEFORE the `if (!isReady) return null` gate below, so the `useMemo` hooks that
+    // depend on it never sit after an early return (stable hook order).
+    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;
+    // The version-conflict banner is a SUBMISSION outcome → rendered in the actions
+    // footer (above the submit row) via `submissionNotice`, not at the top of the form.
+    const conflictNotice = useMemo(() => {
+        if (!conflictBanner || !conflictLabels)
+            return null;
+        return (_jsx(RemoteChangeNotification, { type: "conflict", discardedFields: conflictBanner.discardedFields, conflictDetails: conflictBanner.conflictDetails, labels: conflictLabels, onDismiss: handleAcknowledgeConflict }));
+    }, [conflictBanner, conflictLabels, handleAcknowledgeConflict]);
     const formActionsValue = useMemo(() => ({
         submitButton: resolvedSubmitButton,
         draftSaveButton,
-    }), [resolvedSubmitButton, draftSaveButton]);
+        cancelButton,
+        submissionNotice: conflictNotice,
+    }), [resolvedSubmitButton, draftSaveButton, cancelButton, conflictNotice]);
     const loadingOperationIdentifier = useMemo(() => {
         if (!needsFetch) {
             return undefined;
         }
-        return String(FrontendResourceUtils.resolveSingleResourceReadOperation(resourceType, registry)?.operationIdentifier
+        return String(canonicalReadOperation?.operationIdentifier
+            ?? FrontendResourceUtils.resolveSingleResourceReadOperation(resourceType, registry)?.operationIdentifier
             ?? CoreResourceOperation.READ);
-    }, [needsFetch, resourceType, registry]);
+    }, [canonicalReadOperation, needsFetch, resourceType, registry]);
     // LoadingGate scopes for data fetch (UPDATE-like operations only)
     const loadingScopes = useMemo(() => {
         if (!needsFetch || !loadingOperationIdentifier)
@@ -1483,6 +1892,39 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             return [];
         return [{ id: 'form-data', isReady: hasLoadedOnce }];
     }, [needsFetch, hasLoadedOnce]);
+    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 (!formSchema) {
+            return null;
+        }
+        if (explicitEditTemplate) {
+            const ExplicitTemplate = explicitEditTemplate;
+            const ResourceFormTemplate = () => (_jsxs(_Fragment, { children: [_jsx(ExplicitTemplate, {}), _jsx(HostFormActionsFooter, {})] }));
+            ResourceFormTemplate.displayName = 'ResourceFormTemplate(explicit)';
+            return ResourceFormTemplate;
+        }
+        const BaseTemplate = generateDefaultFormTemplate(formSchema, {
+            inheritanceConfig,
+            includeSubmitButton: false,
+            includeErrorSummary: showErrorSummary,
+        });
+        const ResourceFormTemplate = () => (_jsxs(_Fragment, { children: [_jsx(BaseTemplate, {}), _jsx(HostFormActionsFooter, {})] }));
+        ResourceFormTemplate.displayName = 'ResourceFormTemplate';
+        return ResourceFormTemplate;
+    }, [explicitEditTemplate, formSchema, inheritanceConfig, showErrorSummary]);
+    if (!isReady)
+        return null;
     // Error state if fetch failed
     if (fetchError) {
         const errorTitle = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'failedToLoadData');
@@ -1494,10 +1936,25 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
             : 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 })] }) }));
     }
+    // EA: the operation is no longer available for THIS record (its
+    // `enabledCondition` is unmet now that the real object is loaded — e.g. a
+    // deep-link to `change_status` on an already-completed todo). Render a neutral
+    // unavailable notice instead of a form the backend would reject. Only fires
+    // for existing-resource ops after load and after async evaluation settles.
+    if (needsFetch && hasLoadedOnce && !operationAvailability.isLoading && !operationAvailability.isEnabled) {
+        const unavailableTitle = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'operationUnavailableTitle');
+        const unavailableMessage = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'operationUnavailableMessage');
+        return (_jsx("div", { className: className, children: _jsxs("div", { className: "p-card bg-muted/50 border border-border rounded-lg", role: "status", children: [_jsx("p", { className: "font-medium text-foreground", children: unavailableTitle }), _jsx("p", { className: "text-sm text-muted-foreground mt-item-xs", children: unavailableMessage })] }) }));
+    }
     // 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;
+    // UPDATE-like: defaults come from the fetched record (LoadingGate gates the
+    // mount until ready). CREATE: use the synchronous discriminator seed so RHF
+    // initializes with it on the very first render (see createSeededDefaultValues).
+    const effectiveDefaultValues = needsFetch
+        ? (defaultValues ?? defaultValuesOverride)
+        : (createSeededDefaultValues ?? defaultValuesOverride);
     // Guard against missing schema
     if (!formSchema) {
         const configErrorTitle = tComponent(FrontendComponentType.RESOURCES_LAYOUTS_CREATE, 'configurationError');
@@ -1512,56 +1969,14 @@ export function ResourceAutomatedForm({ resourceContext, onSuccess, onError, dis
     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 }) })] }) }));
+    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 })] })] }) }), pendingCriticalSubmit !== null && (_jsx(OperationsConfirmCritical, { open: true, onOpenChange: (open) => { if (!open)
+                        handleCancelCriticalSubmit(); }, cancelCallback: handleCancelCriticalSubmit, validationCallback: handleConfirmCriticalSubmit, requireTypedConfirmation: true, confirmationPhrase: criticalConfirmationPhrase })), remoteUpdateIndicator && remoteUpdateLabels && (_jsx(RemoteChangeNotification, { type: "remote-update", changedFields: remoteUpdateIndicator.changedFields, labels: remoteUpdateLabels, onDismiss: () => setRemoteUpdateIndicator(null) })), _jsx(ResourceFormActionsProvider, { value: formActionsValue, children: _jsx(AutomatedForm, { schema: formSchema, defaultValues: effectiveDefaultValues, onSubmit: effectiveDraftConfig?.enabled && draftSchema ? handlePublish : handleSubmitWithCriticalGuard, onError: handleError, validationMode: validationMode, disabled: disabled || isSubmitting, labels: labels, layoutRefs: layoutRefs, operationRef: operationIdentifier, operationType: operationType, operationLike: operationLike, coreOperation: effectiveCoreOperation, fileUploadContext: fileUploadContext, contextFieldValues: contextFieldValues, hiddenFieldNames: hiddenFieldNames, generatedFieldOverrides: generatedFieldOverrides, inheritanceConfig: inheritanceConfig, onSectionSave: handleSectionSave, onFormReady: handleFormReady, validateFieldUrl: validateFieldUrl, resourceId: primaryResourceId, contextResourceIdentifiers: contextResourceIdentifiersWithResourceId, parentResourcesRequirements: resourceContext.parentResourcesRequirements, navigationZone: navigationZone, chromeMode: defaultEditChromeMode, 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] }));
@@ -1584,7 +1999,7 @@ function AutosaveCancelBridge({ cancelRef }) {
     }, [autosaveContext, cancelRef]);
     return null;
 }
-function DraftSaveButton({ draftSchema, onSaveDraft, disabled, isSavingDraft, label, savingLabel, }) {
+function DraftSaveButton({ draftSchema, onSaveDraft, disabled, isSavingDraft, label, savingLabel, omitClearedFields, submissionSchema, }) {
     const formContext = useFormContext();
     const formTemplateContext = useOptionalFormTemplateContext();
     const handleClick = useCallback(async () => {
@@ -1599,6 +2014,8 @@ function DraftSaveButton({ draftSchema, onSaveDraft, disabled, isSavingDraft, la
             const sanitizedValues = sanitizeAutomatedFormSubmissionData(result.data, {
                 hiddenFieldNames: formTemplateContext?.hiddenFieldNames,
                 contextFieldValues: formTemplateContext?.contextFieldValues,
+                omitClearedFields,
+                schema: submissionSchema,
             });
             // Clear any existing errors and save
             formContext.clearErrors();
@@ -1606,6 +2023,7 @@ function DraftSaveButton({ draftSchema, onSaveDraft, disabled, isSavingDraft, la
         }
         else {
             const zodError = result.error;
+            const erroredPaths = [];
             zodError.issues.forEach((issue) => {
                 const fieldPath = issue.path.join('.');
                 if (fieldPath) {
@@ -1613,10 +2031,15 @@ function DraftSaveButton({ draftSchema, onSaveDraft, disabled, isSavingDraft, la
                         type: issue.code,
                         message: issue.message,
                     });
+                    erroredPaths.push(fieldPath);
                 }
             });
+            // Audit D4 — same treatment as every other submit-like failure: this
+            // draft-validation path sets field errors DIRECTLY (not through
+            // `injectServerErrors`), so it carries its own scroll-to-first-error.
+            scrollAndFocusFirstErroredField(erroredPaths);
         }
     }, [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
+//# sourceMappingURL=ResourceAutomatedForm.js.map