@nocobase/plugin-flow-engine 2.1.0-alpha.17 → 2.1.0-alpha.19

package/dist/server/flow-surfaces/service.js

@@ -54,6 +54,7 @@ var import_executor = require("./executor");
 var import_reference_guards = require("./reference-guards");
 var import_key_registry = require("./planning/key-registry");
 var import_blueprint = require("./blueprint");
+var import_compile_blocks = require("./blueprint/compile-blocks");
 var import_private_utils = require("./blueprint/private-utils");
 var import_runtime = require("./planning/runtime");
 var import_created_keys = require("./planning/created-keys");
@@ -74,6 +75,7 @@ var import_context = require("./context");
 var import_configure_options = require("./configure-options");
 var import_service_helpers = require("./service-helpers");
 var import_errors2 = require("./reaction/errors");
+var import_approval = require("./approval");
 var import_field_value = require("./reaction/field-value");
 var import_fingerprint = require("./reaction/fingerprint");
 var import_linkage = require("./reaction/linkage");
@@ -84,9 +86,14 @@ var import_default_action_popup = require("./default-action-popup");
 var import_service_utils = require("./service-utils");
 var import_template_compatibility = require("./template-compatibility");
 var import_template_service_utils = require("./template-service-utils");
-const FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel"]);
-const DETAILS_BLOCK_USES = /* @__PURE__ */ new Set(["DetailsBlockModel"]);
-const SIMPLE_FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel"]);
+const FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel", ...import_approval.APPROVAL_FORM_BLOCK_USES]);
+const DETAILS_BLOCK_USES = /* @__PURE__ */ new Set(["DetailsBlockModel", ...import_approval.APPROVAL_DETAILS_BLOCK_USES]);
+const SIMPLE_FORM_BLOCK_USES = /* @__PURE__ */ new Set([
+  "FormBlockModel",
+  "CreateFormModel",
+  "EditFormModel",
+  ...import_approval.APPROVAL_FORM_BLOCK_USES
+]);
 const LIST_BLOCK_USES = /* @__PURE__ */ new Set(["ListBlockModel"]);
 const GRID_CARD_BLOCK_USES = /* @__PURE__ */ new Set(["GridCardBlockModel"]);
 const LIST_LIKE_COMPOSE_BLOCK_TYPES = /* @__PURE__ */ new Set(["list", "gridCard"]);
@@ -106,35 +113,60 @@ const FILTER_TARGET_BLOCK_USES = /* @__PURE__ */ new Set([
   "MapBlockModel",
   "CommentsBlockModel"
 ]);
-const EDITABLE_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set(["FormItemModel", "FilterFormItemModel"]);
-const DISPLAY_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set(["DetailsItemModel", "TableColumnModel"]);
+const EDITABLE_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set(["FormItemModel", "FilterFormItemModel", "PatternFormItemModel"]);
+const DISPLAY_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set([
+  "DetailsItemModel",
+  "TableColumnModel",
+  "ApprovalDetailsItemModel",
+  "ApplyTaskCardDetailsItemModel",
+  "ApprovalTaskCardDetailsItemModel"
+]);
 const DISPLAY_COMPONENT_FIELD_WRAPPER_USES = /* @__PURE__ */ new Set([
   "DetailsItemModel",
   "FormAssociationItemModel",
-  "TableColumnModel"
+  "TableColumnModel",
+  "ApprovalDetailsItemModel",
+  "ApplyTaskCardDetailsItemModel",
+  "ApprovalTaskCardDetailsItemModel"
 ]);
 const TITLE_FIELD_SUPPORTED_WRAPPER_USES = /* @__PURE__ */ new Set([
   "FormItemModel",
   "FormAssociationItemModel",
   "DetailsItemModel",
-  "TableColumnModel"
+  "TableColumnModel",
+  "PatternFormItemModel",
+  "ApprovalDetailsItemModel",
+  "ApplyTaskCardDetailsItemModel",
+  "ApprovalTaskCardDetailsItemModel"
 ]);
 const AUTO_TITLE_FIELD_BINDING_WRAPPER_USES = /* @__PURE__ */ new Set([
   "FormItemModel",
   "FormAssociationItemModel",
   "DetailsItemModel",
   "TableColumnModel",
-  "FilterFormItemModel"
+  "FilterFormItemModel",
+  "PatternFormItemModel",
+  "ApprovalDetailsItemModel",
+  "ApplyTaskCardDetailsItemModel",
+  "ApprovalTaskCardDetailsItemModel"
 ]);
 const UI_FIELD_MENU_TABLE_OWNER_USES = /* @__PURE__ */ new Set(["TableBlockModel"]);
-const UI_FIELD_MENU_DETAILS_OWNER_USES = /* @__PURE__ */ new Set(["DetailsBlockModel", "GridCardBlockModel", "GridCardItemModel"]);
+const UI_FIELD_MENU_DETAILS_OWNER_USES = /* @__PURE__ */ new Set([
+  "DetailsBlockModel",
+  "GridCardBlockModel",
+  "GridCardItemModel",
+  ...import_approval.APPROVAL_DETAILS_BLOCK_USES,
+  ...import_approval.APPROVAL_DETAILS_GRID_USES
+]);
 const UI_FIELD_MENU_FORM_OWNER_USES = /* @__PURE__ */ new Set([
   "FormBlockModel",
   "CreateFormModel",
   "EditFormModel",
   "AssignFormModel",
   "FormGridModel",
-  "AssignFormGridModel"
+  "AssignFormGridModel",
+  ...import_approval.APPROVAL_FORM_BLOCK_USES,
+  ...import_approval.APPROVAL_FORM_GRID_USES
 ]);
 const JS_ACTION_USES = /* @__PURE__ */ new Set([
   "JSCollectionActionModel",
@@ -169,7 +201,12 @@ const ITEM_CONTEXT_OWNER_USES = /* @__PURE__ */ new Set([
   "PopupSubTableFieldModel",
   "RecordPickerFieldModel"
 ]);
-const RECORD_CONTEXT_OWNER_USES = /* @__PURE__ */ new Set(["DetailsBlockModel", "QuickEditFormModel", "AssignFormModel"]);
+const RECORD_CONTEXT_OWNER_USES = /* @__PURE__ */ new Set([
+  "DetailsBlockModel",
+  "QuickEditFormModel",
+  "AssignFormModel",
+  ...import_approval.APPROVAL_DETAILS_BLOCK_USES
+]);
 const POPUP_RECORD_ACTION_CONTAINER_USES = /* @__PURE__ */ new Set([
   "TableActionsColumnModel",
   "DetailsBlockModel",
@@ -181,6 +218,9 @@ const POPUP_COLLECTION_BLOCK_SCENES = {
   CreateFormModel: ["new"],
   EditFormModel: ["one", "many"],
   DetailsBlockModel: ["one", "many"],
+  ApplyFormModel: ["new"],
+  ProcessFormModel: ["one"],
+  ApprovalDetailsModel: ["one"],
   CommentsBlockModel: ["one", "many"],
   TableBlockModel: ["many"],
   ListBlockModel: ["many"],
@@ -260,13 +300,22 @@ const UPDATE_SETTINGS_STEP_PARAM_MIRRORS_BY_USE = {
   JSColumnModel: TABLE_COLUMN_STEP_PARAM_MIRRORS,
   TableColumnModel: TABLE_FIELD_WRAPPER_STEP_PARAM_MIRRORS,
   FormItemModel: FORM_ITEM_STEP_PARAM_MIRRORS,
+  PatternFormItemModel: FORM_ITEM_STEP_PARAM_MIRRORS,
   DetailsItemModel: DETAIL_ITEM_STEP_PARAM_MIRRORS,
+  ApprovalDetailsItemModel: DETAIL_ITEM_STEP_PARAM_MIRRORS,
+  ApplyTaskCardDetailsItemModel: DETAIL_ITEM_STEP_PARAM_MIRRORS,
+  ApprovalTaskCardDetailsItemModel: DETAIL_ITEM_STEP_PARAM_MIRRORS,
   FormAssociationItemModel: DETAIL_ITEM_STEP_PARAM_MIRRORS,
   FilterFormItemModel: FILTER_FORM_ITEM_STEP_PARAM_MIRRORS,
   FormBlockModel: FORM_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
   CreateFormModel: FORM_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
   EditFormModel: FORM_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
+  ApplyFormModel: FORM_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
+  ProcessFormModel: FORM_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
   DetailsBlockModel: DETAILS_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
+  ApprovalDetailsModel: DETAILS_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
+  ApplyTaskCardDetailsModel: DETAILS_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
+  ApprovalTaskCardDetailsModel: DETAILS_BLOCK_LAYOUT_STEP_PARAM_MIRRORS,
   FilterFormBlockModel: FILTER_FORM_BLOCK_LAYOUT_STEP_PARAM_MIRRORS
 };
 const FLOW_SURFACE_MENU_BINDABLE_OPTION_KEY = "flowSurfaceMenuBindable";
@@ -288,7 +337,11 @@ class FlowSurfacesService {
   }
   getFlowTemplateRepository(actionName) {
     try {
-      return this.db.getRepository("flowModelTemplates");
+      const repo = this.db.getRepository("flowModelTemplates");
+      if (!repo) {
+        throw new Error("flowModelTemplates repository unavailable");
+      }
+      return repo;
     } catch (error) {
       (0, import_errors.throwBadRequest)(
         `flowSurfaces ${actionName} requires '@nocobase/plugin-ui-templates' to be enabled`,
@@ -334,6 +387,56 @@ class FlowSurfacesService {
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey, collectionName)
     });
   }
+  get approvalRuntimeConfigService() {
+    return new import_approval.FlowSurfaceApprovalRuntimeConfigService({
+      db: this.db,
+      locator: this.locator,
+      repository: this.repository
+    });
+  }
+  get approvalBlueprintService() {
+    return new import_approval.FlowSurfaceApprovalBlueprintService({
+      contractGuard: this.contractGuard,
+      db: this.db,
+      hasDataSource: (dataSourceKey) => {
+        var _a, _b;
+        return !!((_b = (_a = this.plugin.app.dataSourceManager) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, dataSourceKey));
+      },
+      repository: this.repository,
+      setNodeAsyncFlag: (uid2, asyncFlag, transaction) => this.setFlowModelNodeAsyncFlag(uid2, asyncFlag, transaction),
+      removeNodeTreeWithBindings: (uid2, transaction) => this.removeNodeTreeWithBindings(uid2, transaction),
+      surfaceContext: this.surfaceContext,
+      compose: (values, options) => this.compose(values, options),
+      addField: (values, options) => this.addField(values, options),
+      setLayout: (values, options) => this.setLayout(values, options),
+      get: (values, options) => this.get(values, options),
+      buildComposeLayoutPayload: (input) => this.buildComposeLayoutPayload(input),
+      syncApprovalRuntimeConfigForSurfaceRoot: (root, transaction) => this.approvalRuntimeConfigService.syncApprovalRuntimeConfigForSurfaceRoot(root, transaction)
+    });
+  }
+  async setFlowModelNodeAsyncFlag(uid2, asyncFlag, transaction) {
+    var _a, _b;
+    const sequelize = (_a = this.db) == null ? void 0 : _a.sequelize;
+    const queryInterface = (_b = sequelize == null ? void 0 : sequelize.getQueryInterface) == null ? void 0 : _b.call(sequelize);
+    const quoteIdentifier = typeof (queryInterface == null ? void 0 : queryInterface.quoteIdentifier) === "function" ? (value) => queryInterface.quoteIdentifier(value) : (value) => `"${value}"`;
+    if (!(sequelize == null ? void 0 : sequelize.query)) {
+      (0, import_errors.throwInternalError)("flowSurfaces cannot update flow model async flag because sequelize is unavailable");
+    }
+    await sequelize.query(
+      `UPDATE ${this.repository.flowModelTreePathTableName}
+       SET ${quoteIdentifier("async")} = :async
+       WHERE ${quoteIdentifier("ancestor")} = :uid
+         AND ${quoteIdentifier("descendant")} = :uid
+         AND ${quoteIdentifier("depth")} = 0`,
+      {
+        replacements: {
+          uid: uid2,
+          async: asyncFlag
+        },
+        transaction
+      }
+    );
+  }
   async loadEnabledPluginPackages(transaction) {
     if (!this.db.getCollection("applicationPlugins")) {
       return /* @__PURE__ */ new Set();
@@ -629,6 +732,19 @@ class FlowSurfacesService {
       return !!((_a2 = item.grid) == null ? void 0 : _a2.uid);
     });
   }
+  filterCatalogActionsForExistingApprovalSingletons(node, availableActions) {
+    var _a;
+    if (!(node == null ? void 0 : node.uid) || !availableActions.length) {
+      return availableActions;
+    }
+    const existingActionUses = new Set(
+      (0, import_service_utils.getNodeSubModelList)((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a.actions).map((item) => String((item == null ? void 0 : item.use) || "").trim()).filter((use) => import_approval.APPROVAL_SINGLETON_ACTION_USES.has(use))
+    );
+    if (!existingActionUses.size) {
+      return availableActions;
+    }
+    return availableActions.filter((item) => !existingActionUses.has(String((item == null ? void 0 : item.use) || "").trim()));
+  }
   async catalog(input, options = {}) {
     if (import_lodash.default.isUndefined(input == null ? void 0 : input.target) && (0, import_service_utils.hasLegacyLocatorFields)(input || {}, {
       allowRootUid: true
@@ -680,7 +796,9 @@ class FlowSurfacesService {
       ) : (0, import_catalog.getAvailableActionCatalogItems)(void 0, void 0, enabledPackages).filter(
         (item) => item.scope !== "record"
       );
-      response.actions = availableActions.map((item) => this.projectCatalogItem(item, expandFlags));
+      response.actions = this.filterCatalogActionsForExistingApprovalSingletons(node, availableActions).map(
+        (item) => this.projectCatalogItem(item, expandFlags)
+      );
     }
     if (catalogAnalysis.selectedSections.includes("recordActions")) {
       const availableRecordActions = node ? catalogAnalysis.recordActionContainerUse ? (0, import_catalog.getAvailableActionCatalogItems)(catalogAnalysis.recordActionContainerUse, "record", enabledPackages) : [] : (0, import_catalog.getAvailableActionCatalogItems)(void 0, "record", enabledPackages);
@@ -688,7 +806,7 @@ class FlowSurfacesService {
       response.recordActions = filteredRecordActions.map((item) => this.projectCatalogItem(item, expandFlags));
     }
     if (catalogAnalysis.selectedSections.includes("node")) {
-      response.node = this.projectCatalogNode(node, resolved, expandFlags);
+      response.node = this.projectCatalogNode(node, resolved, expandFlags, enabledPackages);
     }
     return response;
   }
@@ -730,13 +848,45 @@ class FlowSurfacesService {
       recordActionContainerUse
     };
   }
-  projectCatalogNode(node, resolved, expand) {
-    return (0, import_catalog_smart.projectCatalogNode)(node, resolved, expand, {
+  projectCatalogNode(node, resolved, expand, enabledPackages) {
+    const projected = (0, import_catalog_smart.projectCatalogNode)(node, resolved, expand, {
       getEditableDomains: this.getEditableDomains.bind(this),
       getConfigureOptionsForResolvedNode: import_configure_options.getConfigureOptionsForResolvedNode,
       getSettingsSchema: import_catalog.getSettingsSchemaForUse,
       getNodeContract: import_catalog.getNodeContract
     });
+    return this.patchResolvedNodeConfigureOptions(node, projected, enabledPackages);
+  }
+  patchResolvedNodeConfigureOptions(node, projected, enabledPackages) {
+    var _a, _b, _c;
+    if (!((_a = projected == null ? void 0 : projected.configureOptions) == null ? void 0 : _a.fieldComponent) || !(node == null ? void 0 : node.use)) {
+      return projected;
+    }
+    try {
+      const fieldSource = this.resolveFieldComponentFieldSource(node);
+      const supportedFieldUses = (0, import_catalog.getSupportedFieldComponentUseSet)({
+        containerUse: node.use,
+        field: fieldSource.field,
+        enabledPackages,
+        dataSourceKey: (_b = fieldSource.fieldSettingsInit) == null ? void 0 : _b.dataSourceKey,
+        getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey, collectionName)
+      });
+      if (!(supportedFieldUses == null ? void 0 : supportedFieldUses.size)) {
+        return projected;
+      }
+      const configureOptions = import_lodash.default.cloneDeep(projected.configureOptions || {});
+      configureOptions.fieldComponent = {
+        type: ((_c = configureOptions.fieldComponent) == null ? void 0 : _c.type) || "string",
+        ...configureOptions.fieldComponent || {},
+        enum: Array.from(supportedFieldUses)
+      };
+      return {
+        ...projected,
+        configureOptions
+      };
+    } catch {
+      return projected;
+    }
   }
   projectCatalogItem(item, expand) {
     return (0, import_catalog_smart.projectCatalogItem)(item, expand, {
@@ -1079,7 +1229,7 @@ class FlowSurfacesService {
       resolved || { uid: uid2, target: { uid: uid2 }, kind: "node" },
       transaction
     );
-    const childPageIndex = ancestors.findIndex((item) => (item == null ? void 0 : item.use) === "ChildPageModel");
+    const childPageIndex = ancestors.findIndex((item) => (0, import_approval.normalizeApprovalSemanticUse)(item == null ? void 0 : item.use) === "ChildPageModel");
     if (childPageIndex >= 0) {
       return ancestors[childPageIndex + 1] || null;
     }
@@ -1954,7 +2104,7 @@ class FlowSurfacesService {
       );
     }
   }
-  buildPlanningRuntimeDeps() {
+  buildPlanningRuntimeDeps(options = {}) {
     return {
       normalizeGetTarget: (value) => this.normalizeGetTarget(value),
       resolveLocator: (target, resolveOptions) => this.locator.resolve(target, resolveOptions),
@@ -1966,39 +2116,45 @@ class FlowSurfacesService {
       buildReadTargetSummary: (target, resolved) => this.buildReadTargetSummary(target, resolved),
       buildSurfaceContextFingerprint: (context) => this.buildSurfaceContextFingerprint(context),
       buildSurfaceReadPayload: (target, resolved, node, readOptions) => this.buildSurfaceReadPayload(target, resolved, node, readOptions),
-      dispatchPlanOnlyAction: (action, payload, transaction) => this.dispatchPlanOnlyAction(action, payload, transaction),
+      dispatchPlanOnlyAction: (action, payload, transaction) => this.dispatchPlanOnlyAction(action, payload, transaction, options),
       dispatchOp: (op, resolvedValues, currentCtx) => this.dispatchOp(op, resolvedValues, currentCtx)
     };
   }
   async describeSurface(values, options = {}) {
     return (0, import_runtime.describeSurface)(values, this.buildPlanningRuntimeDeps(), options);
   }
-  async dispatchPlanOnlyAction(action, payload, transaction) {
-    const options = { transaction };
+  async dispatchPlanOnlyAction(action, payload, transaction, options = {}) {
+    const actionOptions = {
+      transaction,
+      popupTemplateAliasSession: options.popupTemplateAliasSession
+    };
     switch (action) {
       case "compose":
-        return this.compose(payload, options);
+        return this.compose(payload, actionOptions);
       case "configure":
-        return this.configure(payload, options);
+        return this.configure(payload, actionOptions);
       case "setFieldValueRules":
-        return this.setFieldValueRules(payload, options);
+        return this.setFieldValueRules(
+          payload,
+          actionOptions
+        );
       case "setBlockLinkageRules":
         return this.setBlockLinkageRules(
           payload,
-          options
+          actionOptions
         );
       case "setFieldLinkageRules":
         return this.setFieldLinkageRules(
           payload,
-          options
+          actionOptions
         );
       case "setActionLinkageRules":
         return this.setActionLinkageRules(
           payload,
-          options
+          actionOptions
         );
       case "convertTemplateToCopy":
-        return this.convertTemplateToCopy(payload, options);
+        return this.convertTemplateToCopy(payload, actionOptions);
     }
     const unsupportedAction = action;
     (0, import_errors.throwInternalError)(`flowSurfaces plan-only action '${unsupportedAction}' is not supported`);
@@ -2105,6 +2261,8 @@ class FlowSurfacesService {
   async applyBlueprint(values, options = {}) {
     var _a;
     const prepared = await this.prepareApplyBlueprintRequest(values, options.transaction);
+    const popupTemplateAliasSession = this.createPopupTemplateAliasSession();
+    this.validateApplyBlueprintPopupTemplateAliases(prepared.document, popupTemplateAliasSession);
     const result = await (0, import_runtime.executeInternalPlan)(
       {
         surface: prepared.surface,
@@ -2112,7 +2270,9 @@ class FlowSurfacesService {
           steps: prepared.steps
         }
       },
-      this.buildPlanningRuntimeDeps(),
+      this.buildPlanningRuntimeDeps({
+        popupTemplateAliasSession
+      }),
       options
     );
     const pageLocator = (0, import_blueprint.resolveApplyBlueprintPageLocator)(prepared, result);
@@ -2127,6 +2287,21 @@ class FlowSurfacesService {
       surface
     };
   }
+  async findApprovalSurfaceRootForNode(uid2, transaction) {
+    return this.approvalRuntimeConfigService.findApprovalSurfaceRootForNode(uid2, transaction);
+  }
+  async syncApprovalRuntimeConfigForSurfaceRoot(root, transaction) {
+    return this.approvalRuntimeConfigService.syncApprovalRuntimeConfigForSurfaceRoot(root, transaction);
+  }
+  async syncApprovalRuntimeConfigForNode(uid2, transaction) {
+    return this.approvalRuntimeConfigService.syncApprovalRuntimeConfigForNode(uid2, transaction);
+  }
+  async assertApprovalActionSingleton(parentUid, actionUse, transaction) {
+    return this.approvalRuntimeConfigService.assertApprovalActionSingleton(parentUid, actionUse, transaction);
+  }
+  async applyApprovalBlueprint(values, options = {}) {
+    return this.approvalBlueprintService.applyApprovalBlueprint(values, options);
+  }
   resolveTemplateResourceInfo(input) {
     return (0, import_template_compatibility.resolveTemplateResourceInfo)(input, {
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey, collectionName)
@@ -2386,7 +2561,8 @@ class FlowSurfacesService {
       if (resourceReason2) {
         return resourceReason2;
       }
-      if (String(template.filterByTk || "").trim() && !popupProfile.hasCurrentRecord) {
+      const hasCurrentRecord2 = (popupActionContext == null ? void 0 : popupActionContext.hasCurrentRecord) ?? popupProfile.hasCurrentRecord;
+      if (String(template.filterByTk || "").trim() && !hasCurrentRecord2) {
         return (0, import_template_compatibility.buildTemplateMissingContextReason)("filterByTk");
       }
       return void 0;
@@ -2548,7 +2724,7 @@ class FlowSurfacesService {
     const pageSize = (0, import_service_helpers.normalizeTemplatePageSize)(values == null ? void 0 : values.pageSize);
     const [rows, count] = await repo.findAndCount({
       filter,
-      sort: values == null ? void 0 : values.sort,
+      sort: this.getDefaultFlowTemplateSort(values == null ? void 0 : values.sort),
       limit: pageSize,
       offset: (page - 1) * pageSize,
       transaction: options.transaction
@@ -3352,12 +3528,15 @@ class FlowSurfacesService {
   }
   async compose(values, options = {}) {
     var _a, _b, _c;
+    const popupTemplateAliasSession = options.popupTemplateAliasSession || this.createPopupTemplateAliasSession();
     const target = this.normalizeWriteTarget("compose", values == null ? void 0 : values.target, values);
     const mode = this.assertComposeMode(values == null ? void 0 : values.mode);
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     const normalizedBlocks = this.normalizeComposeBlocks(values == null ? void 0 : values.blocks, enabledPackages);
+    this.validateComposePopupTemplateAliases(normalizedBlocks, popupTemplateAliasSession);
     const blockParent = await this.surfaceContext.resolveBlockParent(target, options.transaction);
     const gridUid = blockParent.parentUid;
+    const approvalRoot = await this.findApprovalSurfaceRootForNode(gridUid, options.transaction);
     const initialGrid = await this.repository.findModelById(gridUid, {
       transaction: options.transaction,
       includeAsyncNode: true
@@ -3381,7 +3560,7 @@ class FlowSurfacesService {
       existingItemUids: existingItems.map((item) => item.uid),
       layout: values.layout
     });
-    return (0, import_compose_runtime.executeComposeRuntime)(plan, {
+    const result = await (0, import_compose_runtime.executeComposeRuntime)(plan, {
       removeExistingItem: async (uid2) => this.removeNodeTreeWithBindings(uid2, options.transaction),
       createBlock: async (payload) => this.addBlock(payload, {
         ...options,
@@ -3394,19 +3573,27 @@ class FlowSurfacesService {
         }
         await this.applyInlineNodeSettings(actionName, targetUid, settings, options);
       },
-      createField: async (payload) => this.addField(payload, options),
+      createField: async (payload) => this.addField(payload, {
+        ...options,
+        popupTemplateAliasSession
+      }),
       applyFieldSettings: async (actionName, fieldResult, settings) => this.applyInlineFieldSettings(actionName, fieldResult, settings, options),
       createAction: async (payload) => this.addAction(payload, {
         ...options,
         enabledPackages,
-        autoCompleteDefaultPopup: false
+        autoCompleteDefaultPopup: false,
+        popupTemplateAliasSession
       }),
       createRecordAction: async (payload) => this.addRecordAction(payload, {
         ...options,
         enabledPackages,
-        autoCompleteDefaultPopup: false
+        autoCompleteDefaultPopup: false,
+        popupTemplateAliasSession
+      }),
+      applyActionPopup: async (actionName, actionUid, popup) => this.applyInlineActionPopup(actionName, actionUid, popup, {
+        ...options,
+        popupTemplateAliasSession
       }),
-      applyActionPopup: async (actionName, actionUid, popup) => this.applyInlineActionPopup(actionName, actionUid, popup, options),
       collectActionKeys: async (actionUid) => this.collectComposeActionKeys(actionUid, options.transaction),
       buildExplicitLayoutPayload: async (input) => {
         var _a2;
@@ -3434,6 +3621,10 @@ class FlowSurfacesService {
       },
       setLayout: async (payload) => this.setLayout(payload, options)
     });
+    if (approvalRoot) {
+      await this.syncApprovalRuntimeConfigForSurfaceRoot(approvalRoot, options.transaction);
+    }
+    return result;
   }
   async configure(values, options = {}) {
     const target = this.normalizeWriteTarget("configure", values == null ? void 0 : values.target, values);
@@ -3455,7 +3646,7 @@ class FlowSurfacesService {
     if (SIMPLE_FORM_BLOCK_USES.has((current == null ? void 0 : current.use) || "")) {
       return this.configureFormBlock(target, current.use, values.changes, options);
     }
-    if ((current == null ? void 0 : current.use) === "DetailsBlockModel") {
+    if (DETAILS_BLOCK_USES.has((current == null ? void 0 : current.use) || "")) {
       return this.configureDetailsBlock(target, values.changes, options);
     }
     if ((current == null ? void 0 : current.use) === "FilterFormBlockModel") {
@@ -4223,7 +4414,8 @@ class FlowSurfacesService {
         {
           context: "addBlock",
           enabledPackages: options.enabledPackages,
-          requireCreateSupported: true
+          requireCreateSupported: true,
+          skipContainerValidation: true
         }
       );
       if (expectedBlock.use !== template.useModel) {
@@ -4386,17 +4578,6 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)("flowSurfaces addBlock does not allow resource and resourceInit at the same time");
     }
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
-    const catalogItem = (0, import_catalog.resolveSupportedBlockCatalogItem)(
-      {
-        type: values.type,
-        use: values.use
-      },
-      {
-        context: "addBlock",
-        enabledPackages,
-        requireCreateSupported: true
-      }
-    );
     let resolvedTarget = await this.locator.resolve(target, options);
     let targetNode = await this.loadResolvedNode(resolvedTarget, options.transaction);
     const targetOpenView = this.resolvePopupHostOpenView(targetNode);
@@ -4411,6 +4592,26 @@ class FlowSurfacesService {
       targetNode,
       options.transaction
     );
+    const { parentUid, subKey, subType, popupSurface } = await this.surfaceContext.resolveBlockParent(
+      target,
+      options.transaction
+    );
+    const parentNode = await this.repository.findModelById(parentUid, {
+      transaction: options.transaction,
+      includeAsyncNode: true
+    });
+    const catalogItem = (0, import_catalog.resolveSupportedBlockCatalogItem)(
+      {
+        type: values.type,
+        use: values.use,
+        containerUse: parentNode == null ? void 0 : parentNode.use
+      },
+      {
+        context: "addBlock",
+        enabledPackages,
+        requireCreateSupported: true
+      }
+    );
     const resolvedResourceInit = await this.resolvePopupCollectionBlockResourceInit({
       actionName: "addBlock",
       blockUse: catalogItem.use,
@@ -4424,16 +4625,13 @@ class FlowSurfacesService {
       resourceInit: resolvedResourceInit,
       resourceField: rawResourceInit ? "resourceInit" : (semanticResource == null ? void 0 : semanticResource.kind) === "raw" ? "resource" : void 0
     });
-    const { parentUid, subKey, subType, popupSurface } = await this.surfaceContext.resolveBlockParent(
-      target,
-      options.transaction
-    );
     const initialGrid = options.deferAutoLayout ? null : await this.repository.findModelById(parentUid, {
       transaction: options.transaction,
       includeAsyncNode: true
     });
     const tree = (0, import_builder.buildBlockTree)({
       use: catalogItem.use,
+      containerUse: parentNode == null ? void 0 : parentNode.use,
       resourceInit: resolvedResourceInit,
       props: values.props,
       decoratorProps: values.decoratorProps,
@@ -4516,11 +4714,13 @@ class FlowSurfacesService {
       "flowRegistry"
     ]);
     const inlineSettings = this.normalizeInlineSettings("addField", values.settings);
-    const inlinePopup = this.normalizeInlinePopup("addField", values.popup);
+    let inlinePopup = this.normalizeInlinePopup("addField", values.popup);
+    this.assertInlinePopupTemplateAliasesSupported("addField", inlinePopup, options.popupTemplateAliasSession);
     const resolvedTarget = await this.locator.resolve(target, options);
     const container = await this.surfaceContext.resolveFieldContainer(resolvedTarget.uid, options.transaction);
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     const isFilterFormItem = container.wrapperUse === "FilterFormItemModel";
+    const isApprovalFormTarget = (0, import_approval.isApprovalFormContainerUse)(container.ownerUse);
     const requestedStandaloneType = typeof values.type === "string" && values.type.trim().length ? values.type.trim() : void 0;
     const fieldCapability = (0, import_catalog.resolveSupportedFieldCapability)({
       containerUse: container.ownerUse,
@@ -4537,6 +4737,9 @@ class FlowSurfacesService {
       if (isFilterFormItem) {
         (0, import_errors.throwBadRequest)(`flowSurfaces addField type '${values.type}' is not allowed under filter-form`);
       }
+      if (isApprovalFormTarget && requestedStandaloneType === "jsItem") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces addField type 'jsItem' is not allowed under approval form`);
+      }
       const node = (0, import_builder.buildStandaloneFieldNode)({
         use: fieldCapability.standaloneUse,
         props: values.props || values.wrapperProps,
@@ -4686,6 +4889,12 @@ class FlowSurfacesService {
     if (inlinePopup && !this.isPopupFieldHostUse(boundFieldCapability.fieldUse)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces addField field '${boundFieldCapability.fieldUse}' does not support popup`);
     }
+    if (values.__autoPopupForRelationField === true && !inlinePopup && this.isPopupFieldHostUse(boundFieldCapability.fieldUse) && ((0, import_service_helpers.isAssociationField)(resolvedField.field) || !!normalizedFieldBinding.associationPathName) && !this.peekInlineFieldSettingsOpenView(inlineSettings, boundFieldCapability.wrapperUse)) {
+      inlinePopup = this.normalizeInlinePopup("addField", {
+        tryTemplate: true,
+        defaultType: "view"
+      });
+    }
     if (inlinePopup && this.isExternalPopupOpenView(
       this.peekInlineFieldSettingsOpenView(inlineSettings, boundFieldCapability.wrapperUse)
     )) {
@@ -4767,6 +4976,7 @@ class FlowSurfacesService {
     (0, import_service_utils.ensureNoRawDirectAddKeys)("addAction", values, ["props", "decoratorProps", "stepParams", "flowRegistry"]);
     const inlineSettings = this.normalizeInlineSettings("addAction", values.settings);
     const inlinePopup = this.normalizeInlinePopup("addAction", values.popup);
+    this.assertInlinePopupTemplateAliasesSupported("addAction", inlinePopup, options.popupTemplateAliasSession);
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     const container = await this.surfaceContext.resolveActionContainer(target, options.transaction);
     if ((0, import_action_scope.getActionContainerScope)(container.ownerUse) === "record") {
@@ -4792,6 +5002,7 @@ class FlowSurfacesService {
     if (inlinePopup && !POPUP_ACTION_USES.has(actionCatalogItem.use)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces addAction type '${actionCatalogItem.key}' does not support popup`);
     }
+    await this.assertApprovalActionSingleton(container.parentUid, actionCatalogItem.use, options.transaction);
     (0, import_action_scope.assertRequestedActionScope)({
       requestedScope: void 0,
       resolvedScope,
@@ -4819,8 +5030,14 @@ class FlowSurfacesService {
       { transaction: options.transaction }
     );
     await this.applyInlineNodeSettings("addAction", created, inlineSettings, options);
-    await this.applyInlineActionPopup("addAction", created, inlinePopup, options);
+    await this.applyInlineActionPopup("addAction", created, inlinePopup, {
+      ...options,
+      popupActionContext: {
+        hasCurrentRecord: false
+      }
+    });
     await this.syncFlowTemplateUsagesForNodeTree(created, options.transaction);
+    await this.syncApprovalRuntimeConfigForNode(created, options.transaction);
     const result = {
       uid: created,
       parentUid: container.parentUid,
@@ -4837,6 +5054,7 @@ class FlowSurfacesService {
     (0, import_service_utils.ensureNoRawDirectAddKeys)("addRecordAction", values, ["props", "decoratorProps", "stepParams", "flowRegistry"]);
     const inlineSettings = this.normalizeInlineSettings("addRecordAction", values.settings);
     const inlinePopup = this.normalizeInlinePopup("addRecordAction", values.popup);
+    this.assertInlinePopupTemplateAliasesSupported("addRecordAction", inlinePopup, options.popupTemplateAliasSession);
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     const container = await this.inspectRecordActionContainer(target, options.transaction);
     const actionCatalogItem = this.resolveAddRecordActionCatalogItem(
@@ -4883,7 +5101,12 @@ class FlowSurfacesService {
       { transaction: options.transaction }
     );
     await this.applyInlineNodeSettings("addRecordAction", created, inlineSettings, options);
-    await this.applyInlineActionPopup("addRecordAction", created, inlinePopup, options);
+    await this.applyInlineActionPopup("addRecordAction", created, inlinePopup, {
+      ...options,
+      popupActionContext: {
+        hasCurrentRecord: true
+      }
+    });
     await this.syncFlowTemplateUsagesForNodeTree(created, options.transaction);
     const result = {
       uid: created,
@@ -4949,6 +5172,218 @@ class FlowSurfacesService {
       invoke: (itemValues, options) => this.addRecordAction(itemValues, options)
     });
   }
+  createPopupTemplateAliasSession() {
+    return /* @__PURE__ */ new Map();
+  }
+  normalizePopupTemplateAliasName(value, fieldName) {
+    if (import_lodash.default.isUndefined(value)) {
+      return void 0;
+    }
+    if (typeof value !== "string" || !value.trim()) {
+      (0, import_errors.throwBadRequest)(`${fieldName} must be a non-empty string`);
+    }
+    return value.trim();
+  }
+  readInlinePopupTemplateLocalAlias(popup, fieldName = "popup.template.local") {
+    if (!import_lodash.default.isPlainObject(popup == null ? void 0 : popup.template)) {
+      return void 0;
+    }
+    return this.normalizePopupTemplateAliasName(popup.template.local, fieldName);
+  }
+  readInlinePopupSaveAsTemplateLocalAlias(popup, fieldName = "popup.saveAsTemplate.local") {
+    if (!import_lodash.default.isPlainObject(popup == null ? void 0 : popup.saveAsTemplate)) {
+      return void 0;
+    }
+    return this.normalizePopupTemplateAliasName(popup.saveAsTemplate.local, fieldName);
+  }
+  assertInlinePopupTemplateAliasesSupported(actionName, popup, popupTemplateAliasSession, popupPath = "popup") {
+    if (!import_lodash.default.isPlainObject(popup) || popupTemplateAliasSession) {
+      return;
+    }
+    if (this.readInlinePopupTemplateLocalAlias(popup, `${popupPath}.template.local`)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${popupPath}.template.local is only supported in compose and applyBlueprint`
+      );
+    }
+    if (this.readInlinePopupSaveAsTemplateLocalAlias(popup, `${popupPath}.saveAsTemplate.local`)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${popupPath}.saveAsTemplate.local is only supported in compose and applyBlueprint`
+      );
+    }
+    if (!(0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup)) {
+      return;
+    }
+    this.assertInlinePopupTemplateAliasesSupportedInBlocks(
+      actionName,
+      import_lodash.default.castArray(popup.blocks || []),
+      popupTemplateAliasSession,
+      `${popupPath}.blocks`
+    );
+  }
+  assertInlinePopupTemplateAliasesSupportedInBlocks(actionName, blocks, popupTemplateAliasSession, blocksPath = "popup.blocks") {
+    if (!(blocks == null ? void 0 : blocks.length) || popupTemplateAliasSession) {
+      return;
+    }
+    const normalizedBlocks = import_lodash.default.castArray(blocks || []);
+    ["fields", "actions", "recordActions"].forEach((phase) => {
+      normalizedBlocks.forEach((block, blockIndex) => {
+        import_lodash.default.castArray((block == null ? void 0 : block[phase]) || []).forEach((item, itemIndex) => {
+          this.assertInlinePopupTemplateAliasesSupported(
+            actionName,
+            import_lodash.default.isPlainObject(item == null ? void 0 : item.popup) ? item.popup : void 0,
+            popupTemplateAliasSession,
+            `${blocksPath}[${blockIndex}].${phase}[${itemIndex}].popup`
+          );
+        });
+      });
+    });
+  }
+  prepareInlinePopupTemplateAliases(actionName, popup, popupTemplateAliasSession) {
+    if (!import_lodash.default.isPlainObject(popup)) {
+      return popup;
+    }
+    const template = import_lodash.default.isPlainObject(popup.template) ? popup.template : void 0;
+    const templateLocal = this.readInlinePopupTemplateLocalAlias(popup);
+    if (templateLocal) {
+      if (String((template == null ? void 0 : template.uid) || "").trim()) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup.template cannot combine popup.template.uid and local`);
+      }
+      if (popup.tryTemplate === true) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup.template.local cannot be combined with popup.tryTemplate`);
+      }
+      if (!popupTemplateAliasSession) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} popup.template.local is only supported in compose and applyBlueprint`
+        );
+      }
+      const matchedTemplateUid = popupTemplateAliasSession.get(templateLocal);
+      if (!matchedTemplateUid) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} popup.template.local '${templateLocal}' must reference an earlier popup.saveAsTemplate.local in the same request`
+        );
+      }
+      const nextPopup = import_lodash.default.cloneDeep(popup);
+      nextPopup.template = (0, import_service_utils.buildDefinedPayload)({
+        ...import_lodash.default.omit(template, ["local"]),
+        uid: matchedTemplateUid
+      });
+      return nextPopup;
+    }
+    const saveAsTemplateLocal = this.readInlinePopupSaveAsTemplateLocalAlias(popup);
+    if (!saveAsTemplateLocal) {
+      return popup;
+    }
+    if (!popupTemplateAliasSession) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} popup.saveAsTemplate.local is only supported in compose and applyBlueprint`
+      );
+    }
+    if (popupTemplateAliasSession.has(saveAsTemplateLocal)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} popup.saveAsTemplate.local '${saveAsTemplateLocal}' is duplicated in the same request`
+      );
+    }
+    return popup;
+  }
+  registerInlinePopupTemplateAlias(actionName, popup, savedTemplate, popupTemplateAliasSession) {
+    const local = this.readInlinePopupSaveAsTemplateLocalAlias(popup);
+    if (!local) {
+      return;
+    }
+    if (!popupTemplateAliasSession) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} popup.saveAsTemplate.local is only supported in compose and applyBlueprint`
+      );
+    }
+    if (popupTemplateAliasSession.has(local)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} popup.saveAsTemplate.local '${local}' is duplicated in the same request`
+      );
+    }
+    const templateUid = String((savedTemplate == null ? void 0 : savedTemplate.uid) || "").trim();
+    if (!templateUid) {
+      (0, import_errors.throwConflict)(
+        `flowSurfaces ${actionName} popup.saveAsTemplate.local '${local}' did not produce a saved template uid`,
+        "FLOW_SURFACE_TEMPLATE_COPY_FAILED"
+      );
+    }
+    popupTemplateAliasSession.set(local, templateUid);
+  }
+  validatePopupTemplateAliasesInBlocks(blocks, availableAliases, blocksPath) {
+    const normalizedBlocks = import_lodash.default.castArray(blocks || []);
+    ["fields", "actions", "recordActions"].forEach((phase) => {
+      normalizedBlocks.forEach((block, blockIndex) => {
+        import_lodash.default.castArray((block == null ? void 0 : block[phase]) || []).forEach((item, itemIndex) => {
+          this.validatePopupTemplateAliasesForItemPopup(
+            import_lodash.default.isPlainObject(item == null ? void 0 : item.popup) ? item.popup : void 0,
+            availableAliases,
+            `${blocksPath}[${blockIndex}].${phase}[${itemIndex}]`
+          );
+        });
+      });
+    });
+  }
+  validatePopupTemplateAliasesForItemPopup(popup, availableAliases, itemPath) {
+    if (!import_lodash.default.isPlainObject(popup)) {
+      return;
+    }
+    const template = import_lodash.default.isPlainObject(popup.template) ? popup.template : void 0;
+    const templateUid = String((template == null ? void 0 : template.uid) || "").trim();
+    const templateLocal = this.readInlinePopupTemplateLocalAlias(popup, `${itemPath}.popup.template.local`);
+    if (templateLocal && templateUid) {
+      (0, import_errors.throwBadRequest)(`${itemPath}.popup.template cannot combine uid and local`);
+    }
+    if (templateLocal && popup.tryTemplate === true) {
+      (0, import_errors.throwBadRequest)(`${itemPath}.popup.template.local cannot be combined with ${itemPath}.popup.tryTemplate`);
+    }
+    if (templateLocal && !availableAliases.has(templateLocal)) {
+      (0, import_errors.throwBadRequest)(
+        `${itemPath}.popup.template.local '${templateLocal}' must reference an earlier popup.saveAsTemplate.local in the same request`
+      );
+    }
+    const hasExplicitTemplate = !!(templateUid || templateLocal);
+    if (!hasExplicitTemplate && (0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup)) {
+      this.validatePopupTemplateAliasesInBlocks(
+        import_lodash.default.castArray(popup.blocks || []),
+        availableAliases,
+        `${itemPath}.popup.blocks`
+      );
+    }
+    const saveAsTemplateLocal = this.readInlinePopupSaveAsTemplateLocalAlias(
+      popup,
+      `${itemPath}.popup.saveAsTemplate.local`
+    );
+    if (!saveAsTemplateLocal) {
+      return;
+    }
+    if (availableAliases.has(saveAsTemplateLocal)) {
+      (0, import_errors.throwBadRequest)(
+        `${itemPath}.popup.saveAsTemplate.local '${saveAsTemplateLocal}' is duplicated in the same request`
+      );
+    }
+    availableAliases.add(saveAsTemplateLocal);
+  }
+  validateComposePopupTemplateAliases(blocks, popupTemplateAliasSession) {
+    const availableAliases = new Set(popupTemplateAliasSession ? popupTemplateAliasSession.keys() : []);
+    this.validatePopupTemplateAliasesInBlocks(
+      blocks,
+      availableAliases,
+      "flowSurfaces compose.blocks"
+    );
+  }
+  validateApplyBlueprintPopupTemplateAliases(document, popupTemplateAliasSession) {
+    const availableAliases = new Set(popupTemplateAliasSession ? popupTemplateAliasSession.keys() : []);
+    document.tabs.forEach((tab, tabIndex) => {
+      const composeValues = (0, import_compile_blocks.compileTabComposeValues)(tab, document, tabIndex, {
+        mode: document.mode === "replace" ? "replace" : "append"
+      });
+      this.validatePopupTemplateAliasesInBlocks(
+        import_lodash.default.castArray(composeValues.blocks || []),
+        availableAliases,
+        `flowSurfaces applyBlueprint tabs[${tabIndex}].blocks`
+      );
+    });
+  }
   normalizeInlineSettings(actionName, settings) {
     if (import_lodash.default.isUndefined(settings)) {
       return void 0;
@@ -4965,7 +5400,79 @@ class FlowSurfacesService {
     if (!import_lodash.default.isPlainObject(popup)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup must be an object`);
     }
-    return popup;
+    const normalizedPopup = import_lodash.default.cloneDeep(popup);
+    const tryTemplate = this.normalizeOptionalPopupTryTemplate(actionName, normalizedPopup.tryTemplate);
+    const defaultType = this.normalizePopupDefaultType(actionName, normalizedPopup.defaultType);
+    const saveAsTemplate = this.normalizePopupSaveAsTemplate(actionName, normalizedPopup.saveAsTemplate);
+    if (saveAsTemplate && !import_lodash.default.isUndefined(normalizedPopup.template)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup.saveAsTemplate cannot be combined with popup.template`);
+    }
+    if (saveAsTemplate && !import_lodash.default.isUndefined(tryTemplate)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup.saveAsTemplate cannot be combined with popup.tryTemplate`);
+    }
+    if (import_lodash.default.isUndefined(tryTemplate)) {
+      delete normalizedPopup.tryTemplate;
+    } else {
+      normalizedPopup.tryTemplate = tryTemplate;
+    }
+    if (import_lodash.default.isUndefined(defaultType)) {
+      delete normalizedPopup.defaultType;
+    } else {
+      normalizedPopup.defaultType = defaultType;
+    }
+    if (import_lodash.default.isUndefined(saveAsTemplate)) {
+      delete normalizedPopup.saveAsTemplate;
+    } else {
+      normalizedPopup.saveAsTemplate = saveAsTemplate;
+    }
+    return normalizedPopup;
+  }
+  normalizePopupSaveAsTemplate(actionName, value, fieldName = "popup.saveAsTemplate") {
+    if (import_lodash.default.isUndefined(value)) {
+      return void 0;
+    }
+    if (!import_lodash.default.isPlainObject(value)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} must be an object`);
+    }
+    return {
+      name: (0, import_template_service_utils.normalizeRequiredTemplateString)(actionName, value.name, `${fieldName}.name`),
+      description: (0, import_template_service_utils.normalizeRequiredTemplateString)(actionName, value.description, `${fieldName}.description`),
+      local: this.normalizePopupTemplateAliasName(value.local, `${fieldName}.local`)
+    };
+  }
+  hasInlinePopupSaveAsTemplateSource(popup) {
+    return (0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup);
+  }
+  assertInlinePopupSaveAsTemplateSource(actionName, popup) {
+    if (!(popup == null ? void 0 : popup.saveAsTemplate)) {
+      return;
+    }
+    if (!this.hasInlinePopupSaveAsTemplateSource(popup)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup.saveAsTemplate requires explicit local popup.blocks`);
+    }
+  }
+  clearPopupSurfaceKeys(result) {
+    delete result.popupPageUid;
+    delete result.popupTabUid;
+    delete result.popupGridUid;
+  }
+  async savePopupAsTemplate(hostUid, popup, options) {
+    const normalizedHostUid = String(hostUid || "").trim();
+    const saveAsTemplate = popup == null ? void 0 : popup.saveAsTemplate;
+    if (!normalizedHostUid || !saveAsTemplate) {
+      return;
+    }
+    return this.saveTemplate(
+      {
+        target: {
+          uid: normalizedHostUid
+        },
+        name: saveAsTemplate.name,
+        description: saveAsTemplate.description,
+        saveMode: "convert"
+      },
+      options
+    );
   }
   buildInlinePopupTemplateOpenView(popup) {
     const normalizedTitle = import_lodash.default.isUndefined(popup == null ? void 0 : popup.title) || import_lodash.default.isNull(popup == null ? void 0 : popup.title) ? void 0 : String(popup.title).trim() || void 0;
@@ -5041,6 +5548,121 @@ class FlowSurfacesService {
       ...options.expectedType ? { expectedType: options.expectedType } : {}
     };
   }
+  normalizeOptionalPopupTryTemplate(actionName, value, fieldName = "popup.tryTemplate") {
+    if (import_lodash.default.isUndefined(value)) {
+      return void 0;
+    }
+    if (typeof value !== "boolean") {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} must be a boolean`);
+    }
+    return value;
+  }
+  normalizePopupDefaultType(actionName, value, fieldName = "popup.defaultType") {
+    if (import_lodash.default.isUndefined(value)) {
+      return void 0;
+    }
+    const normalized = String(value || "").trim();
+    if (!(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupType)(normalized) || normalized === "addNew") {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} only supports 'view' or 'edit'`);
+    }
+    return normalized;
+  }
+  getDefaultFlowTemplateSort(sort) {
+    const normalizedSort = import_lodash.default.castArray(sort).map((item) => String(item || "").trim()).filter(Boolean);
+    if (normalizedSort.length > 0) {
+      return normalizedSort;
+    }
+    return ["-updatedAt", "-createdAt", "uid"];
+  }
+  getPopupTryTemplateExpectedAssociationName(targetContext) {
+    var _a, _b, _c;
+    if ((_a = targetContext == null ? void 0 : targetContext.popupProfile) == null ? void 0 : _a.isPopupSurface) {
+      return String(targetContext.popupProfile.associationName || "").trim() || void 0;
+    }
+    return String(((_c = (_b = targetContext == null ? void 0 : targetContext.resourceContext) == null ? void 0 : _b.resourceInit) == null ? void 0 : _c.associationName) || "").trim() || void 0;
+  }
+  getPopupTryTemplatePriority(template, expectedAssociationName) {
+    const templateAssociationName = String(template.associationName || "").trim() || void 0;
+    if (!expectedAssociationName) {
+      return templateAssociationName ? null : 0;
+    }
+    if (templateAssociationName === expectedAssociationName) {
+      return 0;
+    }
+    if (!templateAssociationName) {
+      return 1;
+    }
+    return null;
+  }
+  getRequestedPopupDefaultType(popup) {
+    const normalized = String((popup == null ? void 0 : popup.defaultType) || "").trim();
+    if (normalized === "view" || normalized === "edit") {
+      return normalized;
+    }
+    return void 0;
+  }
+  inferPopupDefaultTypeFromTemplateTree(node) {
+    var _a, _b, _c, _d;
+    const popupPage = (0, import_service_utils.getSingleNodeSubModel)((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a.page);
+    const popupTab = import_lodash.default.castArray(((_b = popupPage == null ? void 0 : popupPage.subModels) == null ? void 0 : _b.tabs) || [])[0];
+    const popupGrid = (0, import_service_utils.getSingleNodeSubModel)((_c = popupTab == null ? void 0 : popupTab.subModels) == null ? void 0 : _c.grid);
+    const popupBlock = (0, import_service_utils.getNodeSubModelList)((_d = popupGrid == null ? void 0 : popupGrid.subModels) == null ? void 0 : _d.items)[0];
+    if ((popupBlock == null ? void 0 : popupBlock.use) === "DetailsBlockModel") {
+      return "view";
+    }
+    if ((popupBlock == null ? void 0 : popupBlock.use) === "EditFormModel") {
+      return "edit";
+    }
+    return void 0;
+  }
+  async popupTemplateMatchesDefaultType(template, popup, options = {}) {
+    const requestedDefaultType = this.getRequestedPopupDefaultType(popup);
+    if (!requestedDefaultType) {
+      return true;
+    }
+    const templateTargetUid = String((template == null ? void 0 : template.targetUid) || "").trim();
+    if (!templateTargetUid) {
+      return false;
+    }
+    const templateTree = await this.repository.findModelById(templateTargetUid, {
+      transaction: options.transaction,
+      includeAsyncNode: true
+    });
+    return this.inferPopupDefaultTypeFromTemplateTree(templateTree) === requestedDefaultType;
+  }
+  async tryResolvePopupTemplateForHost(actionName, popup, hostUid, options = {}) {
+    const normalizedHostUid = String(hostUid || "").trim();
+    if (!normalizedHostUid || !import_lodash.default.isPlainObject(popup) || !popup.tryTemplate || !import_lodash.default.isUndefined(popup.template)) {
+      return null;
+    }
+    const repo = this.getFlowTemplateRepository(actionName);
+    const targetContext = await this.loadTemplateListTargetContext({ uid: normalizedHostUid }, options.transaction);
+    const templates = await repo.find({
+      filter: (0, import_template_service_utils.buildTemplateListFilter)(void 0, void 0, "popup"),
+      sort: this.getDefaultFlowTemplateSort(),
+      transaction: options.transaction
+    });
+    const annotatedTemplates = await this.withTemplateAvailability(
+      await this.withFlowTemplateUsageCounts(templates, actionName, options),
+      {
+        requestedType: "popup",
+        targetContext,
+        popupActionContext: options.popupActionContext
+      }
+    );
+    const expectedAssociationName = this.getPopupTryTemplateExpectedAssociationName(targetContext);
+    for (const priority of [0, 1]) {
+      for (const template of annotatedTemplates) {
+        if (template.available !== true || this.getPopupTryTemplatePriority(template, expectedAssociationName) !== priority) {
+          continue;
+        }
+        if (await this.popupTemplateMatchesDefaultType(template, popup, options)) {
+          return template;
+        }
+      }
+    }
+    return null;
+  }
   async getFlowTemplateOrThrow(actionName, templateUid, options = {}) {
     const repo = this.getFlowTemplateRepository(actionName);
     const templateRecord = await repo.findOne({
@@ -5163,6 +5785,26 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} openView must be an object`);
     }
     const normalizedOpenView = import_lodash.default.cloneDeep(openView);
+    const tryTemplate = this.normalizeOptionalPopupTryTemplate(
+      actionName,
+      normalizedOpenView.tryTemplate,
+      "openView.tryTemplate"
+    );
+    delete normalizedOpenView.tryTemplate;
+    if (tryTemplate && import_lodash.default.isUndefined(normalizedOpenView.template)) {
+      const matchedTemplate = await this.tryResolvePopupTemplateForHost(
+        actionName,
+        { tryTemplate: true },
+        options.popupTemplateHostUid,
+        options
+      );
+      if (matchedTemplate == null ? void 0 : matchedTemplate.uid) {
+        normalizedOpenView.template = {
+          uid: matchedTemplate.uid,
+          mode: "reference"
+        };
+      }
+    }
     if (!import_lodash.default.isUndefined(normalizedOpenView.template)) {
       const templateRef = this.normalizeFlowTemplateReference(actionName, normalizedOpenView.template, {
         expectedType: "popup"
@@ -5218,6 +5860,36 @@ class FlowSurfacesService {
     }
     return normalizedOpenView;
   }
+  isTryTemplateOnlyOpenViewRequest(openView) {
+    if (!import_lodash.default.isPlainObject(openView) || openView.tryTemplate !== true || !import_lodash.default.isUndefined(openView.template)) {
+      return false;
+    }
+    return Object.keys(openView).every((key) => key === "tryTemplate");
+  }
+  async resolveRecordContextPopupActionContextForHost(current, transaction) {
+    const currentUse = String((current == null ? void 0 : current.use) || "").trim();
+    if (!currentUse || !POPUP_ACTION_USES.has(currentUse) || !POPUP_HOST_DEFAULT_RECORD_CONTEXT_ACTION_USES.has(currentUse)) {
+      return void 0;
+    }
+    const hostContext = await this.resolvePopupHostProfileContext(current, transaction).catch(() => null);
+    if (!(hostContext == null ? void 0 : hostContext.recordActionContainerUse)) {
+      return void 0;
+    }
+    return {
+      hasCurrentRecord: true
+    };
+  }
+  unsetPayloadPathAndPruneEmptyParents(payload, path) {
+    import_lodash.default.unset(payload, path);
+    for (let index = path.length - 1; index > 0; index -= 1) {
+      const parentPath = path.slice(0, index);
+      const parentValue = import_lodash.default.get(payload, parentPath);
+      if (!import_lodash.default.isPlainObject(parentValue) || Object.keys(parentValue).length > 0) {
+        break;
+      }
+      import_lodash.default.unset(payload, parentPath);
+    }
+  }
   isExternalPopupOpenView(openView, hostUid) {
     if (!import_lodash.default.isPlainObject(openView)) {
       return false;
@@ -5364,6 +6036,7 @@ class FlowSurfacesService {
     }
   }
   async applyInlineFieldPopup(actionName, result, popup, options) {
+    popup = this.prepareInlinePopupTemplateAliases(actionName, popup, options.popupTemplateAliasSession);
     const fieldHostUid = result.fieldUid || result.uid;
     if (!import_lodash.default.isUndefined(popup == null ? void 0 : popup.template)) {
       Object.assign(
@@ -5383,23 +6056,78 @@ class FlowSurfacesService {
       );
       return;
     }
+    const matchedTemplate = await this.tryResolvePopupTemplateForHost(actionName, popup, fieldHostUid, options);
+    if (matchedTemplate == null ? void 0 : matchedTemplate.uid) {
+      Object.assign(
+        result,
+        await this.configureFieldNode(
+          {
+            uid: fieldHostUid
+          },
+          {
+            openView: this.buildInlinePopupTemplateOpenView({
+              ...popup,
+              template: {
+                uid: matchedTemplate.uid,
+                mode: "reference"
+              }
+            })
+          },
+          {
+            ...options,
+            openViewActionName: actionName
+          }
+        )
+      );
+      return;
+    }
     try {
-      Object.assign(result, await this.ensureLocalFieldPopupSurface(actionName, fieldHostUid, options, { popup }));
       if (!popup || !fieldHostUid) {
         return;
       }
-      await this.compose(
-        {
-          target: {
-            uid: fieldHostUid
+      const { fieldNode, wrapperNode } = await this.loadFieldHostNodes(fieldHostUid, options.transaction);
+      this.assertInlinePopupSaveAsTemplateSource(actionName, popup);
+      const hasLocalPopupContent = (0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup) || !import_lodash.default.isUndefined(popup.layout);
+      if (popup.tryTemplate && !hasLocalPopupContent && !this.shouldAutoCompleteDefaultFieldPopup(fieldNode, popup)) {
+        return;
+      }
+      const shouldAutoCompleteDefaultPopup = this.shouldAutoCompleteDefaultFieldPopup(fieldNode, popup);
+      Object.assign(result, await this.ensureLocalFieldPopupSurface(actionName, fieldHostUid, options, { popup }));
+      if (shouldAutoCompleteDefaultPopup) {
+        const popupContext = this.resolveFieldOpenViewContext(fieldNode, wrapperNode);
+        const defaultType = this.getRequestedPopupDefaultType(popup) || "view";
+        await this.compose(
+          {
+            target: {
+              uid: fieldHostUid
+            },
+            mode: popup.mode || "replace",
+            blocks: this.buildDefaultFieldPopupBlocks(fieldNode, popupContext, defaultType),
+            layout: popup.layout
           },
-          mode: popup.mode || "replace",
-          blocks: popup.blocks || [],
-          layout: popup.layout
-        },
-        options
-      );
-      Object.assign(result, await this.collectPopupSurfaceKeys(fieldHostUid, options.transaction));
+          options
+        );
+        await this.autoSaveDefaultFieldPopupAsTemplate(result, popup, options);
+      } else {
+        await this.compose(
+          {
+            target: {
+              uid: fieldHostUid
+            },
+            mode: popup.mode || "replace",
+            blocks: popup.blocks || [],
+            layout: popup.layout
+          },
+          options
+        );
+        Object.assign(result, await this.collectPopupSurfaceKeys(fieldHostUid, options.transaction));
+      }
+      if (popup.saveAsTemplate) {
+        const savedTemplate = await this.savePopupAsTemplate(fieldHostUid, popup, options);
+        this.registerInlinePopupTemplateAlias(actionName, popup, savedTemplate, options.popupTemplateAliasSession);
+        this.clearPopupSurfaceKeys(result);
+        Object.assign(result, await this.collectPopupSurfaceKeys(fieldHostUid, options.transaction));
+      }
     } catch (error) {
       (0, import_service_utils.rethrowInlineConfigurationError)(error, `flowSurfaces ${actionName} popup invalid`);
     }
@@ -5419,25 +6147,31 @@ class FlowSurfacesService {
       });
       const { wrapperChanges, fieldChanges } = (0, import_service_utils.splitComposeFieldChanges)(settings, wrapperNode == null ? void 0 : wrapperNode.use);
       if (Object.keys(wrapperChanges).length) {
-        await this.configure(
-          {
-            target: {
-              uid: result.wrapperUid
+        Object.assign(
+          result,
+          await this.configure(
+            {
+              target: {
+                uid: result.wrapperUid
+              },
+              changes: wrapperChanges
             },
-            changes: wrapperChanges
-          },
-          options
+            options
+          )
         );
       }
       if (Object.keys(fieldChanges).length) {
-        await this.configure(
-          {
-            target: {
-              uid: result.fieldUid
+        Object.assign(
+          result,
+          await this.configure(
+            {
+              target: {
+                uid: result.fieldUid
+              },
+              changes: fieldChanges
             },
-            changes: fieldChanges
-          },
-          options
+            options
+          )
         );
       }
     } catch (error) {
@@ -5462,6 +6196,105 @@ class FlowSurfacesService {
     }
     return !(0, import_default_action_popup.hasFlowSurfaceInlinePopupTemplate)(popup) && !(0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup);
   }
+  shouldAutoCompleteDefaultFieldPopup(fieldNode, popup) {
+    if (!import_lodash.default.isPlainObject(popup)) {
+      return false;
+    }
+    if (!this.isPopupFieldHostUse(fieldNode == null ? void 0 : fieldNode.use)) {
+      return false;
+    }
+    if ((0, import_default_action_popup.hasFlowSurfaceInlinePopupTemplate)(popup) || (0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup) || !import_lodash.default.isUndefined(popup.layout)) {
+      return false;
+    }
+    const fieldContext = this.resolveFieldOpenViewContext(fieldNode, null);
+    if (!String(fieldContext.associationName || "").trim()) {
+      return false;
+    }
+    return popup.tryTemplate === true || !import_lodash.default.isUndefined(popup.defaultType) || Object.keys(popup).length === 0;
+  }
+  buildDefaultFieldPopupFieldPaths(input) {
+    const collectionName = String(input.popupContext.collectionName || "").trim();
+    if (!collectionName) {
+      return [];
+    }
+    const mode = input.defaultType === "edit" ? "form" : "details";
+    const ownerUse = input.defaultType === "edit" ? "EditFormModel" : "DetailsBlockModel";
+    const directCandidates = this.buildFieldMenuDirectCandidates({
+      mode,
+      ownerUse,
+      resourceInit: {
+        dataSourceKey: input.popupContext.dataSourceKey || "main",
+        collectionName
+      }
+    });
+    return (0, import_default_action_popup.pickFlowSurfaceDefaultActionPopupFieldPaths)(directCandidates, {
+      excludeAuditTimestampFields: input.defaultType === "edit",
+      excludeAssociationFields: true
+    });
+  }
+  buildDefaultFieldPopupBlocks(fieldNode, popupContext, defaultType) {
+    var _a;
+    const actionUse = defaultType === "edit" ? "EditActionModel" : "ViewActionModel";
+    const namespace = (0, import_service_utils.normalizeFlowSurfaceComposeKey)(
+      `defaultFieldPopup_${(fieldNode == null ? void 0 : fieldNode.uid) || (0, import_utils.uid)()}`,
+      `flowSurfaces default popup for field '${(fieldNode == null ? void 0 : fieldNode.uid) || "unknown"}'`
+    );
+    const keyMap = /* @__PURE__ */ new Map();
+    const actionConfig = (0, import_default_action_popup.getFlowSurfaceDefaultActionPopupConfigByUse)(actionUse);
+    if (actionConfig == null ? void 0 : actionConfig.blockKey) {
+      keyMap.set(actionConfig.blockKey, `${namespace}.${actionConfig.blockKey}`);
+    }
+    if ((_a = actionConfig == null ? void 0 : actionConfig.submitAction) == null ? void 0 : _a.key) {
+      keyMap.set(actionConfig.submitAction.key, `${namespace}.${actionConfig.submitAction.key}`);
+    }
+    const fieldPaths = this.buildDefaultFieldPopupFieldPaths({
+      defaultType,
+      fieldNode,
+      popupContext
+    });
+    return this.remapDefaultActionPopupBlocks(
+      (0, import_default_action_popup.buildFlowSurfaceDefaultActionPopupBlocks)(actionUse, fieldPaths),
+      keyMap,
+      namespace
+    );
+  }
+  async autoSaveDefaultFieldPopupAsTemplate(result, popup, options) {
+    const fieldHostUid = result.fieldUid || result.uid;
+    if (!fieldHostUid) {
+      return;
+    }
+    const openView = this.resolvePopupHostOpenView(
+      await this.repository.findModelById(fieldHostUid, {
+        transaction: options.transaction,
+        includeAsyncNode: true
+      })
+    );
+    if (String((openView == null ? void 0 : openView.popupTemplateUid) || "").trim()) {
+      this.clearPopupSurfaceKeys(result);
+      return;
+    }
+    const uniqueKeySource = JSON.stringify(
+      (0, import_service_utils.buildDefinedPayload)({
+        dataSourceKey: openView == null ? void 0 : openView.dataSourceKey,
+        collectionName: openView == null ? void 0 : openView.collectionName,
+        associationName: openView == null ? void 0 : openView.associationName,
+        defaultType: this.getRequestedPopupDefaultType(popup) || "view"
+      })
+    );
+    const identity = (0, import_crypto.createHash)("sha1").update(uniqueKeySource).digest("hex").slice(0, 12);
+    await this.saveTemplate(
+      {
+        target: {
+          uid: fieldHostUid
+        },
+        name: `Auto popup ${identity}`,
+        description: `Auto-generated popup template ${identity}`,
+        saveMode: "convert"
+      },
+      options
+    );
+    this.clearPopupSurfaceKeys(result);
+  }
   shouldAutoCompleteDefaultActionPopup(actionNode, popup, options = {}) {
     if (options.autoCompleteDefaultPopup === false) {
       return false;
@@ -5718,11 +6551,17 @@ class FlowSurfacesService {
     }
     const openView = this.resolvePopupHostOpenView(actionNode);
     if (this.isExternalPopupOpenView(openView, actionNode == null ? void 0 : actionNode.uid)) {
+      if (popup == null ? void 0 : popup.saveAsTemplate) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} popup.saveAsTemplate cannot be combined with external openView.uid`
+        );
+      }
       if (import_lodash.default.isUndefined(popup) || this.isSemanticallyEmptyInlinePopup(popup)) {
         return;
       }
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} popup cannot be combined with external openView.uid`);
     }
+    popup = this.prepareInlinePopupTemplateAliases(actionName, popup, options.popupTemplateAliasSession);
     if (popup && (0, import_default_action_popup.hasFlowSurfaceInlinePopupTemplate)(popup)) {
       await this.configureActionNode(
         {
@@ -5739,10 +6578,38 @@ class FlowSurfacesService {
       );
       return;
     }
+    const matchedTemplate = await this.tryResolvePopupTemplateForHost(actionName, popup, actionUid, options);
+    if (matchedTemplate == null ? void 0 : matchedTemplate.uid) {
+      await this.configureActionNode(
+        {
+          uid: actionUid
+        },
+        actionNode.use,
+        {
+          openView: this.buildInlinePopupTemplateOpenView({
+            ...popup,
+            template: {
+              uid: matchedTemplate.uid,
+              mode: "reference"
+            }
+          })
+        },
+        {
+          ...options,
+          openViewActionName: actionName
+        }
+      );
+      return;
+    }
     const shouldAutoCompleteDefaultPopup = this.shouldAutoCompleteDefaultActionPopup(actionNode, popup, options);
+    this.assertInlinePopupSaveAsTemplateSource(actionName, popup);
+    const hasLocalPopupContent = (0, import_default_action_popup.hasFlowSurfaceInlinePopupBlocks)(popup) || !import_lodash.default.isUndefined(popup == null ? void 0 : popup.layout);
     if (import_lodash.default.isUndefined(popup) && !shouldAutoCompleteDefaultPopup) {
       return;
     }
+    if ((popup == null ? void 0 : popup.tryTemplate) && !hasLocalPopupContent && !shouldAutoCompleteDefaultPopup) {
+      return;
+    }
     try {
       if (shouldAutoCompleteDefaultPopup) {
         await this.applyDefaultActionPopupContent(actionNode, popup, options);
@@ -5759,6 +6626,10 @@ class FlowSurfacesService {
           options
         );
       }
+      if (popup == null ? void 0 : popup.saveAsTemplate) {
+        const savedTemplate = await this.savePopupAsTemplate(actionUid, popup, options);
+        this.registerInlinePopupTemplateAlias(actionName, popup, savedTemplate, options.popupTemplateAliasSession);
+      }
     } catch (error) {
       (0, import_service_utils.rethrowInlineConfigurationError)(error, `flowSurfaces ${actionName} popup invalid`);
     }
@@ -5791,13 +6662,15 @@ class FlowSurfacesService {
       );
     });
     this.syncMirroredStepParamsForUpdateSettings(current, nextPayload);
+    const popupActionContext = options.popupActionContext || await this.resolveRecordContextPopupActionContextForHost(current, options.transaction);
     await this.normalizeOpenViewForUpdateSettings(
       options.openViewActionName || "updateSettings",
       current,
       nextPayload,
       {
         transaction: options.transaction,
-        popupTemplateHostUid: options.popupTemplateHostUid
+        popupTemplateHostUid: options.popupTemplateHostUid,
+        popupActionContext
       }
     );
     this.syncChartConfigureForUpdateSettings(current, nextPayload);
@@ -5845,6 +6718,9 @@ class FlowSurfacesService {
       await this.syncChartDataBindingsForNode(effectiveNode, options.transaction);
     }
     await this.syncFlowTemplateUsagesForNodeTree(current.uid, options.transaction);
+    if (import_approval.APPROVAL_SINGLETON_ACTION_USES.has(current.use || "")) {
+      await this.syncApprovalRuntimeConfigForNode(current.uid, options.transaction);
+    }
     return {
       uid: current.uid,
       updated: Object.keys(import_lodash.default.omit(nextPayload, ["uid"]))
@@ -5882,25 +6758,31 @@ class FlowSurfacesService {
     ];
     const popupTemplateHostUid = String(options.popupTemplateHostUid || (current == null ? void 0 : current.uid) || "").trim() || void 0;
     for (const [flowKey, stepKey] of openViewPaths) {
-      if (!import_lodash.default.has(nextPayload, ["stepParams", flowKey, stepKey])) {
+      const openViewPath = ["stepParams", flowKey, stepKey];
+      if (!import_lodash.default.has(nextPayload, openViewPath)) {
         continue;
       }
-      const currentOpenView = import_lodash.default.get(current, ["stepParams", flowKey, stepKey]);
-      const nextOpenView = await this.normalizeOpenView(
-        actionName,
-        import_lodash.default.get(nextPayload, ["stepParams", flowKey, stepKey]),
-        {
-          transaction: options.transaction,
-          popupTemplateHostUid
+      const requestedOpenView = import_lodash.default.get(nextPayload, openViewPath);
+      const currentOpenView = import_lodash.default.get(current, openViewPath);
+      const nextOpenView = await this.normalizeOpenView(actionName, requestedOpenView, {
+        transaction: options.transaction,
+        popupTemplateHostUid,
+        popupActionContext: options.popupActionContext
+      });
+      if (this.isTryTemplateOnlyOpenViewRequest(requestedOpenView) && import_lodash.default.isPlainObject(nextOpenView) && !Object.keys(nextOpenView).length) {
+        this.unsetPayloadPathAndPruneEmptyParents(nextPayload, openViewPath);
+        if (import_lodash.default.isEqual(nextPayload.stepParams, current.stepParams)) {
+          delete nextPayload.stepParams;
         }
-      );
+        continue;
+      }
       await this.reconcilePopupOpenViewTransition(
         popupTemplateHostUid,
         currentOpenView,
         nextOpenView,
         options.transaction
       );
-      import_lodash.default.set(nextPayload, ["stepParams", flowKey, stepKey], nextOpenView);
+      import_lodash.default.set(nextPayload, openViewPath, nextOpenView);
     }
   }
   syncChartConfigureForUpdateSettings(current, nextPayload) {
@@ -6256,7 +7138,11 @@ class FlowSurfacesService {
     if (FILTER_TARGET_BLOCK_USES.has((node == null ? void 0 : node.use) || "")) {
       await this.removeFilterFormTargetBindings(resolved.uid, options.transaction);
     }
+    const approvalRoot = await this.findApprovalSurfaceRootForNode(resolved.uid, options.transaction);
     await this.removeNodeTreeWithBindings(resolved.uid, options.transaction);
+    if ((approvalRoot == null ? void 0 : approvalRoot.uid) && approvalRoot.uid !== resolved.uid) {
+      await this.syncApprovalRuntimeConfigForSurfaceRoot(approvalRoot, options.transaction);
+    }
     return { uid: resolved.uid };
   }
   async mutate(values, options = {}) {
@@ -6473,7 +7359,7 @@ class FlowSurfacesService {
     });
     const routeSchemaUid = ((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "schemaUid")) || (route == null ? void 0 : route.schemaUid);
     const routeType = ((_b = route == null ? void 0 : route.get) == null ? void 0 : _b.call(route, "type")) || (route == null ? void 0 : route.type);
-    if (routeType !== "tabs" || !routeSchemaUid || String(routeSchemaUid) !== uid2 || (exactNode == null ? void 0 : exactNode.use) === "ChildPageTabModel") {
+    if (routeType !== "tabs" || !routeSchemaUid || String(routeSchemaUid) !== uid2 || (0, import_approval.normalizeApprovalSemanticUse)(exactNode == null ? void 0 : exactNode.use) === "ChildPageTabModel") {
       const recommendedAction = actionName === "updateTab" ? "updatePopupTab" : actionName === "moveTab" ? "movePopupTab" : "removePopupTab";
       (0, import_errors.throwBadRequest)(
         `flowSurfaces ${actionName} only accepts a route-backed tab uid; popup child tabs use ${recommendedAction}`
@@ -6497,7 +7383,7 @@ class FlowSurfacesService {
       transaction,
       includeAsyncNode: true
     });
-    if ((popupPage == null ? void 0 : popupPage.use) !== "ChildPageModel") {
+    if ((0, import_approval.normalizeApprovalSemanticUse)(popupPage == null ? void 0 : popupPage.use) !== "ChildPageModel") {
       (0, import_errors.throwBadRequest)(
         `flowSurfaces ${actionName} only accepts target.uid for popupPageUid; use get(hostUid) and read tree.subModels.page.uid first`
       );
@@ -6514,7 +7400,7 @@ class FlowSurfacesService {
       transaction,
       includeAsyncNode: true
     }) : null;
-    if ((popupTab == null ? void 0 : popupTab.use) !== "ChildPageTabModel" || (popupPage == null ? void 0 : popupPage.use) !== "ChildPageModel") {
+    if ((0, import_approval.normalizeApprovalSemanticUse)(popupTab == null ? void 0 : popupTab.use) !== "ChildPageTabModel" || (0, import_approval.normalizeApprovalSemanticUse)(popupPage == null ? void 0 : popupPage.use) !== "ChildPageModel") {
       (0, import_errors.throwBadRequest)(
         `flowSurfaces ${actionName} only accepts popup tab uid; use get(hostUid) and read tree.subModels.page.subModels.tabs[].uid first`
       );
@@ -6548,10 +7434,10 @@ class FlowSurfacesService {
     return { uid: uid2 };
   }
   assertRemoveNodeResolvedTarget(resolved, node) {
-    if (resolved.kind === "page" || ["RootPageModel", "ChildPageModel"].includes((node == null ? void 0 : node.use) || "")) {
+    if (resolved.kind === "page" || ["RootPageModel", "ChildPageModel"].includes((0, import_approval.normalizeApprovalSemanticUse)(node == null ? void 0 : node.use) || "")) {
       (0, import_errors.throwBadRequest)(`flowSurfaces removeNode does not support page surfaces; use destroyPage`);
     }
-    if (resolved.kind === "tab" || ["RootPageTabModel", "ChildPageTabModel"].includes((node == null ? void 0 : node.use) || "")) {
+    if (resolved.kind === "tab" || ["RootPageTabModel", "ChildPageTabModel"].includes((0, import_approval.normalizeApprovalSemanticUse)(node == null ? void 0 : node.use) || "")) {
       (0, import_errors.throwBadRequest)(`flowSurfaces removeNode does not support tab surfaces; use removeTab`);
     }
     if ((node == null ? void 0 : node.use) === "RouteModel" || resolved.route && !resolved.node) {
@@ -7033,7 +7919,8 @@ class FlowSurfacesService {
       {
         context: "compose",
         enabledPackages,
-        requireCreateSupported: true
+        requireCreateSupported: true,
+        skipContainerValidation: true
       }
     ) : null;
     const actions = import_lodash.default.castArray(input.actions || []).map(
@@ -8029,6 +8916,7 @@ class FlowSurfacesService {
         innerField,
         targetFieldUse: changes.fieldComponent,
         normalizedBinding,
+        enabledPackages,
         transaction: options.transaction
       });
       await this.syncFieldComponentStepParams(current, normalizedFieldComponentUse, options.transaction);
@@ -8252,6 +9140,22 @@ class FlowSurfacesService {
         ...(0, import_service_utils.hasOwnDefined)(changes, "linkageRules") ? { linkageRules: changes.linkageRules } : {}
       };
     }
+    if ((0, import_service_utils.hasOwnDefined)(changes, "approvalReturn")) {
+      if (use !== "ProcessFormReturnModel") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces configure action '${use}' does not support approvalReturn`);
+      }
+      import_lodash.default.set(
+        stepParams,
+        ["clickSettings", "saveResource", "approvalReturnNodeSettings"],
+        import_lodash.default.cloneDeep(changes.approvalReturn || {})
+      );
+    }
+    if ((0, import_service_utils.hasOwnDefined)(changes, "assigneesScope")) {
+      if (!["ProcessFormDelegateModel", "ProcessFormAddAssigneeModel"].includes(use)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces configure action '${use}' does not support assigneesScope`);
+      }
+      import_lodash.default.set(stepParams, ["clickSettings", "saveResource", "assigneesScope"], import_lodash.default.cloneDeep(changes.assigneesScope || {}));
+    }
     if (!import_lodash.default.isUndefined(changes.openView)) {
       if (use === "UploadActionModel") {
         stepParams.selectExitRecordSettings = {
@@ -8667,6 +9571,7 @@ class FlowSurfacesService {
   }
   buildFieldCatalogEntriesForResource(input) {
     const containerKind = (0, import_field_semantics.normalizeFieldContainerKind)(input.ownerUse);
+    const supportsStandaloneJsItem = containerKind === "form" && !(0, import_approval.isApprovalFormContainerUse)(input.ownerUse);
     const targetPrefix = input.multiTarget && input.targetLabel ? `${input.targetLabel} / ` : "";
     const fieldMenuEntries = this.buildFieldMenuCandidates({
       ownerUse: input.ownerUse,
@@ -8741,7 +9646,7 @@ class FlowSurfacesService {
           ...this.buildCatalogItemOptionalFields("JSColumnModel", input)
         });
       }
-      if (containerKind === "form") {
+      if (supportsStandaloneJsItem) {
         semanticEntries.push({
           key: "jsItem",
           label: "JS / jsItem",
@@ -8786,6 +9691,7 @@ class FlowSurfacesService {
       }));
     });
     const containerKind = (0, import_field_semantics.normalizeFieldContainerKind)(input.ownerUse);
+    const supportsStandaloneJsItem = containerKind === "form" && !(0, import_approval.isApprovalFormContainerUse)(input.ownerUse);
     const targetPrefix = input.multiTarget && input.targetLabel ? `${input.targetLabel} / ` : "";
     const baseEntries = [
       ...directFields.map((field) => ({
@@ -8852,7 +9758,7 @@ class FlowSurfacesService {
         ...this.buildCatalogItemOptionalFields("JSColumnModel", input)
       });
     }
-    if (containerKind === "form") {
+    if (supportsStandaloneJsItem) {
       semanticEntries.push({
         key: "jsItem",
         label: "JS / jsItem",
@@ -9154,7 +10060,7 @@ class FlowSurfacesService {
     const rawPopupLevels = [];
     for (let index = 0; index < ancestors.length; index += 1) {
       const node = ancestors[index];
-      if ((node == null ? void 0 : node.use) !== "ChildPageModel") {
+      if ((0, import_approval.normalizeApprovalSemanticUse)(node == null ? void 0 : node.use) !== "ChildPageModel") {
         continue;
       }
       const hostNode = ancestors[index + 1];
@@ -9775,11 +10681,15 @@ class FlowSurfacesService {
         };
       case "DetailsItemModel":
       case "FormAssociationItemModel":
+      case "ApprovalDetailsItemModel":
+      case "ApplyTaskCardDetailsItemModel":
+      case "ApprovalTaskCardDetailsItemModel":
         return {
           flowKey: "detailItemSettings",
           stepKey: "model"
         };
       case "FormItemModel":
+      case "PatternFormItemModel":
         return {
           flowKey: "editItemSettings",
           stepKey: "model"
@@ -9827,7 +10737,9 @@ class FlowSurfacesService {
       })
     };
   }
-  assertSupportedFieldComponentUse(wrapperUse, targetFieldUse) {
+  assertSupportedFieldComponentUse(input) {
+    const { wrapperUse, field, dataSourceKey, enabledPackages } = input;
+    const targetFieldUse = input.targetFieldUse;
     const normalizedTargetUse = String(targetFieldUse || "").trim();
     if (!normalizedTargetUse) {
       (0, import_errors.throwBadRequest)("flowSurfaces configure fieldComponent cannot be empty");
@@ -9835,6 +10747,21 @@ class FlowSurfacesService {
     const normalizedWrapperUse = String(wrapperUse || "").trim();
     const containerUse = normalizedWrapperUse === "FormAssociationItemModel" ? "DetailsItemModel" : normalizedWrapperUse;
     if (DISPLAY_COMPONENT_FIELD_WRAPPER_USES.has(normalizedWrapperUse)) {
+      if (field) {
+        const supportedFieldUses = (0, import_catalog.getSupportedFieldComponentUseSet)({
+          containerUse,
+          field,
+          enabledPackages,
+          dataSourceKey,
+          getCollection: (resolvedDataSourceKey, collectionName) => this.getCollection(resolvedDataSourceKey, collectionName)
+        });
+        if (!(supportedFieldUses == null ? void 0 : supportedFieldUses.has(normalizedTargetUse))) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent '${normalizedTargetUse}'`
+          );
+        }
+        return normalizedTargetUse;
+      }
       const contract = (0, import_catalog.resolveSupportedFieldCapability)({
         containerUse,
         requestedFieldUse: normalizedTargetUse
@@ -9847,6 +10774,21 @@ class FlowSurfacesService {
       return contract.fieldUse;
     }
     if (EDITABLE_FIELD_WRAPPER_USES.has(normalizedWrapperUse)) {
+      if (field) {
+        const supportedFieldUses = (0, import_catalog.getSupportedFieldComponentUseSet)({
+          containerUse,
+          field,
+          enabledPackages,
+          dataSourceKey,
+          getCollection: (resolvedDataSourceKey, collectionName) => this.getCollection(resolvedDataSourceKey, collectionName)
+        });
+        if (!(supportedFieldUses == null ? void 0 : supportedFieldUses.has(normalizedTargetUse))) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces configure field wrapper '${normalizedWrapperUse}' does not support fieldComponent '${normalizedTargetUse}'`
+          );
+        }
+        return normalizedTargetUse;
+      }
       const contract = (0, import_catalog.resolveSupportedFieldCapability)({
         containerUse,
         requestedFieldUse: normalizedTargetUse
@@ -9881,7 +10823,7 @@ class FlowSurfacesService {
     );
   }
   async rebuildFieldSubModelOnServer(input) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const innerField = input.innerField;
     if (!(innerField == null ? void 0 : innerField.uid)) {
       (0, import_errors.throwConflict)(
@@ -9889,12 +10831,19 @@ class FlowSurfacesService {
         "FLOW_SURFACE_INNER_FIELD_MISSING"
       );
     }
-    const normalizedTargetUse = this.assertSupportedFieldComponentUse((_b = input.wrapperNode) == null ? void 0 : _b.use, input.targetFieldUse);
     const fieldSource = this.resolveFieldComponentFieldSource(input.wrapperNode, input.normalizedBinding);
-    const defaultProps = (0, import_service_utils.getFieldBindingDefaultProps)((_c = input.wrapperNode) == null ? void 0 : _c.use, normalizedTargetUse, fieldSource.field);
+    const normalizedTargetUse = this.assertSupportedFieldComponentUse({
+      wrapperUse: (_b = input.wrapperNode) == null ? void 0 : _b.use,
+      targetFieldUse: input.targetFieldUse,
+      field: fieldSource.field,
+      dataSourceKey: (_c = fieldSource.fieldSettingsInit) == null ? void 0 : _c.dataSourceKey,
+      enabledPackages: input.enabledPackages
+    });
+    const defaultProps = (0, import_service_utils.getFieldBindingDefaultProps)((_d = input.wrapperNode) == null ? void 0 : _d.use, normalizedTargetUse, fieldSource.field);
+    const shouldPreservePatternFormField = ((_e = input.wrapperNode) == null ? void 0 : _e.use) === "PatternFormItemModel";
     const nextFieldNode = {
       uid: innerField.uid,
-      use: normalizedTargetUse,
+      use: shouldPreservePatternFormField ? "PatternFormFieldModel" : normalizedTargetUse,
       props: import_lodash.default.pickBy(
         {
           ...innerField.props || {},
@@ -9974,7 +10923,7 @@ class FlowSurfacesService {
       if (!current || typeof current !== "object") {
         return;
       }
-      if (current.use === "ChildPageModel") {
+      if ((0, import_approval.normalizeApprovalSemanticUse)(current.use) === "ChildPageModel") {
         current.subModels = {
           ...current.subModels || {},
           tabs: import_lodash.default.castArray(((_a = current.subModels) == null ? void 0 : _a.tabs) || [])