@nocobase/plugin-flow-engine 2.2.0-alpha.1 → 2.2.0-alpha.10

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

@@ -56,6 +56,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_export_document = require("./blueprint/export-document");
 var import_compile_blocks = require("./blueprint/compile-blocks");
 var import_default_block_actions = require("./default-block-actions");
 var import_template_reference = require("./template-reference");
@@ -65,6 +66,7 @@ var import_runtime = require("./planning/runtime");
 var import_created_keys = require("./planning/created-keys");
 var import_key_persistence = require("./planning/key-persistence");
 var import_payload_shape = require("./payload-shape");
+var import_navigation_targets = require("./navigation-targets");
 var import_field_semantics = require("./field-semantics");
 var import_field_grid_layout = require("./field-grid-layout");
 var import_authoring_validation = require("./authoring-validation");
@@ -96,6 +98,7 @@ var import_meta = require("./reaction/meta");
 var import_resolver = require("./reaction/resolver");
 var import_association_title_field = require("./association-title-field");
 var import_default_action_popup = require("./default-action-popup");
+var import_relation_backing_foreign_key = require("./relation-backing-foreign-key");
 var import_defaults = require("./blueprint/defaults");
 var import_service_utils = require("./service-utils");
 var import_field_type_resolver = require("./field-type-resolver");
@@ -229,9 +232,11 @@ function isFlowSurfaceChartRepairError(error) {
   var _a, _b;
   return error instanceof import_errors.FlowSurfaceBadRequestError && ((_b = (_a = error.options) == null ? void 0 : _a.details) == null ? void 0 : _b.repairHint) === FLOW_SURFACE_CHART_REPAIR_HINT;
 }
+const FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE = "exportBlueprint v1 only supports root page export";
 const FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel", ...import_approval.APPROVAL_FORM_BLOCK_USES]);
 const AUTO_SUBMIT_FORM_BLOCK_USES = /* @__PURE__ */ new Set(["CreateFormModel", "EditFormModel"]);
 const FLOW_SURFACE_DEFAULT_ACTION_SETTINGS_KEYS = /* @__PURE__ */ new Set(["filter"]);
+const ACTION_BUTTON_GENERAL_SETTING_KEYS = ["title", "tooltip", "icon", "iconOnly", "type", "danger", "color"];
 const DETAILS_BLOCK_USES = /* @__PURE__ */ new Set(["DetailsBlockModel", ...import_approval.APPROVAL_DETAILS_BLOCK_USES]);
 const SIMPLE_FORM_BLOCK_USES = /* @__PURE__ */ new Set([
   "FormBlockModel",
@@ -685,6 +690,7 @@ function assertNoFlowSurfaceIdTitleFieldSettings(value, options = {}) {
   };
   visit(value, options.basePath || []);
 }
+const MOBILE_UI_LAYOUT_TYPE = "mobile";
 class FlowSurfacesService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -705,6 +711,9 @@ class FlowSurfacesService {
       (values, options) => this.patchFlowSurfaceModelOptions(values, options)
     );
   }
+  get navigationTargets() {
+    return new import_navigation_targets.FlowSurfaceNavigationTargetsService(this.db);
+  }
   getFlowTemplateRepository(actionName) {
     try {
       const repo = this.db.getRepository("flowModelTemplates");
@@ -918,12 +927,12 @@ class FlowSurfacesService {
       transaction
     });
   }
-  async findMenuGroupRoutesByTitle(title, transaction) {
+  async findMenuGroupRoutesByTitle(title, transaction, layoutUid, portalUid) {
     const normalizedTitle = String(title || "").trim();
     if (!normalizedTitle) {
       return [];
     }
-    return import_lodash.default.castArray(
+    const routes = import_lodash.default.castArray(
       await this.db.getRepository("desktopRoutes").find({
         filter: {
           type: "group",
@@ -932,6 +941,32 @@ class FlowSurfacesService {
         transaction
       })
     );
+    const normalizedPortalUid = this.navigationTargets.normalizePortalUid(portalUid);
+    if (normalizedPortalUid) {
+      const matchedRoutes2 = [];
+      for (const route of routes) {
+        const routePortalUids = await this.navigationTargets.readRoutePortalUids(
+          this.readRouteField(route, "id"),
+          transaction
+        );
+        if (routePortalUids.includes(normalizedPortalUid)) {
+          matchedRoutes2.push(route);
+        }
+      }
+      return matchedRoutes2;
+    }
+    const layoutUidFilter = await this.resolveDesktopRouteLayoutUidFilter(layoutUid, transaction);
+    if (!layoutUidFilter.length || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return routes;
+    }
+    const matchedRoutes = [];
+    for (const route of routes) {
+      const routeLayoutUids = await this.readDesktopRouteUiLayoutUids(this.readRouteField(route, "id"), transaction);
+      if (import_lodash.default.intersection(routeLayoutUids, layoutUidFilter).length) {
+        matchedRoutes.push(route);
+      }
+    }
+    return matchedRoutes;
   }
   routeParentIdMatches(routeParentId, parentId) {
     if (import_lodash.default.isNil(routeParentId) && import_lodash.default.isNil(parentId)) {
@@ -939,28 +974,58 @@ class FlowSurfacesService {
     }
     return String(routeParentId ?? "") === String(parentId ?? "");
   }
-  async findMenuGroupRoutesByParentIdAndTitle(parentId, title, transaction) {
-    const routes = await this.findMenuGroupRoutesByTitle(title, transaction);
+  async findMenuGroupRoutesByParentIdAndTitle(parentId, title, transaction, layoutUid, portalUid) {
+    const routes = await this.findMenuGroupRoutesByTitle(title, transaction, layoutUid, portalUid);
     return routes.filter(
       (route) => this.routeParentIdMatches(this.readRouteField(route, "parentId") ?? null, parentId)
     );
   }
-  async findFlowPageRoutesByParentIdAndTitle(parentId, title, transaction) {
+  async findFlowPageRoutesByParentIdAndTitle(parentId, title, transaction, layoutUid, portalUid) {
     const normalizedTitle = String(title || "").trim();
-    const normalizedParentId = String(parentId ?? "").trim();
-    if (!normalizedTitle || !normalizedParentId) {
+    if (!normalizedTitle) {
       return [];
     }
-    return import_lodash.default.castArray(
+    const routes = import_lodash.default.castArray(
       await this.db.getRepository("desktopRoutes").find({
-        filter: {
+        filter: (0, import_service_utils.buildDefinedPayload)({
           type: "flowPage",
           title: normalizedTitle,
-          parentId: normalizedParentId
-        },
+          parentId: import_lodash.default.isNil(parentId) ? void 0 : String(parentId)
+        }),
         transaction
       })
     );
+    const normalizedPortalUid = this.navigationTargets.normalizePortalUid(portalUid);
+    if (normalizedPortalUid) {
+      const portalMatchedRoutes = [];
+      for (const route of routes) {
+        const routePortalUids = await this.navigationTargets.readRoutePortalUids(
+          this.readRouteField(route, "id"),
+          transaction
+        );
+        if (routePortalUids.includes(normalizedPortalUid)) {
+          portalMatchedRoutes.push(route);
+        }
+      }
+      return portalMatchedRoutes.filter(
+        (route) => this.routeParentIdMatches(this.readRouteField(route, "parentId") ?? null, parentId)
+      );
+    }
+    const layoutUidFilter = await this.resolveDesktopRouteLayoutUidFilter(layoutUid, transaction);
+    const layoutMatchedRoutes = [];
+    if (!layoutUidFilter.length || !this.hasDesktopRouteUiLayoutsRelation()) {
+      layoutMatchedRoutes.push(...routes);
+    } else {
+      for (const route of routes) {
+        const routeLayoutUids = await this.readDesktopRouteUiLayoutUids(this.readRouteField(route, "id"), transaction);
+        if (import_lodash.default.intersection(routeLayoutUids, layoutUidFilter).length) {
+          layoutMatchedRoutes.push(route);
+        }
+      }
+    }
+    return layoutMatchedRoutes.filter(
+      (route) => this.routeParentIdMatches(this.readRouteField(route, "parentId") ?? null, parentId)
+    );
   }
   async assertMenuParentIsGroup(parentMenuRouteId, transaction) {
     if (import_lodash.default.isNil(parentMenuRouteId)) {
@@ -1026,6 +1091,380 @@ class FlowSurfacesService {
       ...extras
     };
   }
+  hasDesktopRouteUiLayoutsRelation() {
+    var _a, _b;
+    try {
+      return !!this.db.getCollection("uiLayouts") && !!((_b = (_a = this.db.getCollection("desktopRoutes")) == null ? void 0 : _a.getField) == null ? void 0 : _b.call(_a, "uiLayouts"));
+    } catch (error) {
+      return false;
+    }
+  }
+  normalizeDesktopRouteRelationId(routeId) {
+    return import_lodash.default.isNil(routeId) ? void 0 : routeId;
+  }
+  async readDesktopRouteUiLayoutUids(routeId, transaction) {
+    const relationRouteId = this.normalizeDesktopRouteRelationId(routeId);
+    if (import_lodash.default.isUndefined(relationRouteId) || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return [];
+    }
+    const uiLayouts = await this.db.getRepository("desktopRoutes.uiLayouts", relationRouteId).find({
+      fields: ["uid"],
+      transaction
+    });
+    return import_lodash.default.uniq(
+      uiLayouts.map((uiLayout) => {
+        var _a;
+        return String(((_a = uiLayout == null ? void 0 : uiLayout.get) == null ? void 0 : _a.call(uiLayout, "uid")) || (uiLayout == null ? void 0 : uiLayout.uid) || "").trim();
+      }).filter(Boolean)
+    );
+  }
+  async resolveDefaultDesktopRouteUiLayoutUids(transaction) {
+    if (!this.hasDesktopRouteUiLayoutsRelation()) {
+      return [];
+    }
+    const defaultLayout = await this.db.getRepository("uiLayouts").findOne({
+      filter: {
+        uid: import_navigation_targets.DEFAULT_ADMIN_UI_LAYOUT_UID,
+        enabled: true
+      },
+      transaction
+    });
+    return defaultLayout ? [import_navigation_targets.DEFAULT_ADMIN_UI_LAYOUT_UID] : [];
+  }
+  async findDesktopRouteUiLayoutByUid(layoutUid, transaction) {
+    const normalizedLayoutUid = this.normalizeExplicitDesktopRouteLayoutUid(layoutUid);
+    if (!normalizedLayoutUid || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return null;
+    }
+    return this.db.getRepository("uiLayouts").findOne({
+      filter: {
+        uid: normalizedLayoutUid
+      },
+      transaction
+    });
+  }
+  async getDesktopRouteUiLayoutTypeByUid(layoutUid, transaction) {
+    var _a;
+    const uiLayout = await this.findDesktopRouteUiLayoutByUid(layoutUid, transaction);
+    return String(((_a = uiLayout == null ? void 0 : uiLayout.get) == null ? void 0 : _a.call(uiLayout, "layoutType")) || (uiLayout == null ? void 0 : uiLayout.layoutType) || "").trim() || void 0;
+  }
+  async isMobileDesktopRouteUiLayoutUid(layoutUid, transaction) {
+    if (!layoutUid) {
+      return false;
+    }
+    return await this.getDesktopRouteUiLayoutTypeByUid(layoutUid, transaction) === MOBILE_UI_LAYOUT_TYPE;
+  }
+  async resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction) {
+    const parentRouteId = this.readRouteField(parentRoute, "id");
+    if (!import_lodash.default.isNil(parentRouteId)) {
+      const parentLayoutUids = await this.readDesktopRouteUiLayoutUids(parentRouteId, transaction);
+      if (parentLayoutUids.length) {
+        return parentLayoutUids;
+      }
+    }
+    return this.resolveDefaultDesktopRouteUiLayoutUids(transaction);
+  }
+  normalizeExplicitDesktopRouteLayoutUid(value) {
+    const normalized = String(value || "").trim();
+    return normalized || void 0;
+  }
+  normalizeDesktopRouteLayoutUidFilter(value) {
+    return import_lodash.default.uniq(
+      import_lodash.default.castArray(value).map((item) => this.normalizeExplicitDesktopRouteLayoutUid(item)).filter(Boolean)
+    );
+  }
+  async resolveDesktopRouteLayoutUidFilter(value, transaction) {
+    const explicitLayoutUids = this.normalizeDesktopRouteLayoutUidFilter(value);
+    if (explicitLayoutUids.length) {
+      return explicitLayoutUids;
+    }
+    return this.resolveDefaultDesktopRouteUiLayoutUids(transaction);
+  }
+  assertNavigationTargetIsExclusive(actionName, layoutUid, portalUid, paths) {
+    const normalizedLayoutUid = this.normalizeExplicitDesktopRouteLayoutUid(layoutUid);
+    const normalizedPortalUid = this.navigationTargets.normalizePortalUid(portalUid);
+    if (!normalizedLayoutUid || !normalizedPortalUid) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} cannot use layoutUid and portalUid together`, {
+      ruleId: "navigation-target-mutually-exclusive",
+      path: paths.portal,
+      details: {
+        layoutUid: normalizedLayoutUid,
+        portalUid: normalizedPortalUid,
+        layoutPath: paths.layout,
+        portalPath: paths.portal
+      }
+    });
+  }
+  async readDesktopRouteScope(route, transaction) {
+    const routeId = this.readRouteField(route, "id");
+    return {
+      portalUids: await this.navigationTargets.readRoutePortalUids(routeId, transaction),
+      layoutUids: await this.readDesktopRouteUiLayoutUids(routeId, transaction)
+    };
+  }
+  async resolveRequestedDesktopRouteScope(values, parentRoute, actionName, options = {}) {
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid(values.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid(values.portalUid);
+    this.assertNavigationTargetIsExclusive(actionName, layoutUid, portalUid, {
+      layout: "values.layoutUid",
+      portal: "values.portalUid"
+    });
+    if (portalUid) {
+      const portal = await this.navigationTargets.resolvePortal(portalUid, {
+        actionName,
+        path: "values.portalUid",
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      if (parentRoute) {
+        await this.navigationTargets.assertRouteBelongsToPortal(
+          actionName,
+          this.readRouteField(parentRoute, "id"),
+          portal.uid,
+          "values.parentMenuRouteId",
+          options.transaction
+        );
+      }
+      return {
+        portalUids: [portal.uid],
+        layoutUids: [],
+        selectedPortal: portal,
+        layoutType: portal.layoutType
+      };
+    }
+    if (layoutUid) {
+      await this.assertEnabledDesktopRouteUiLayoutUid(layoutUid, actionName, "values.layoutUid", options.transaction);
+      if (parentRoute) {
+        await this.assertDesktopRouteBelongsToUiLayout(
+          actionName,
+          parentRoute,
+          layoutUid,
+          "values.parentMenuRouteId",
+          options.transaction
+        );
+      }
+      return {
+        portalUids: [],
+        layoutUids: [layoutUid],
+        layoutType: await this.getDesktopRouteUiLayoutTypeByUid(layoutUid, options.transaction)
+      };
+    }
+    if (parentRoute) {
+      const inheritedScope = await this.readDesktopRouteScope(parentRoute, options.transaction);
+      if (inheritedScope.portalUids.length > 1) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${actionName} parent route belongs to multiple portals; pass values.portalUid explicitly`,
+          {
+            ruleId: "navigation-route-scope-ambiguous",
+            path: "values.parentMenuRouteId",
+            details: {
+              routeId: this.readRouteField(parentRoute, "id"),
+              portalUids: inheritedScope.portalUids
+            }
+          }
+        );
+      }
+      if (inheritedScope.portalUids.length === 1) {
+        const portal = await this.navigationTargets.resolvePortal(inheritedScope.portalUids[0], {
+          actionName,
+          path: "values.parentMenuRouteId",
+          currentRoles: options.currentRoles,
+          transaction: options.transaction
+        });
+        return {
+          ...inheritedScope,
+          selectedPortal: portal,
+          layoutType: portal.layoutType
+        };
+      }
+    }
+    const layoutUids = await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, options.transaction);
+    return {
+      portalUids: [],
+      layoutUids,
+      layoutType: layoutUids.length === 1 ? await this.getDesktopRouteUiLayoutTypeByUid(layoutUids[0], options.transaction) : void 0
+    };
+  }
+  async resolveExistingDesktopRouteScope(values, route, actionName, options = {}) {
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid(values.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid(values.portalUid);
+    this.assertNavigationTargetIsExclusive(actionName, layoutUid, portalUid, {
+      layout: "values.layoutUid",
+      portal: "values.portalUid"
+    });
+    const routeScope = await this.readDesktopRouteScope(route, options.transaction);
+    if (portalUid) {
+      const portal = await this.navigationTargets.resolvePortal(portalUid, {
+        actionName,
+        path: "values.portalUid",
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      await this.navigationTargets.assertRouteBelongsToPortal(
+        actionName,
+        this.readRouteField(route, "id"),
+        portal.uid,
+        "values.menuRouteId",
+        options.transaction
+      );
+      return {
+        ...routeScope,
+        selectedPortal: portal,
+        layoutType: portal.layoutType
+      };
+    }
+    if (layoutUid) {
+      await this.assertEnabledDesktopRouteUiLayoutUid(layoutUid, actionName, "values.layoutUid", options.transaction);
+      await this.assertDesktopRouteBelongsToUiLayout(
+        actionName,
+        route,
+        layoutUid,
+        "values.menuRouteId",
+        options.transaction
+      );
+      return {
+        ...routeScope,
+        layoutType: await this.getDesktopRouteUiLayoutTypeByUid(layoutUid, options.transaction)
+      };
+    }
+    if (routeScope.portalUids.length > 1) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} menu route belongs to multiple portals; pass values.portalUid explicitly`,
+        {
+          ruleId: "navigation-route-scope-ambiguous",
+          path: "values.menuRouteId",
+          details: {
+            routeId: this.readRouteField(route, "id"),
+            portalUids: routeScope.portalUids
+          }
+        }
+      );
+    }
+    if (routeScope.portalUids.length === 1) {
+      const portal = await this.navigationTargets.resolvePortal(routeScope.portalUids[0], {
+        actionName,
+        path: "values.menuRouteId",
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      return {
+        ...routeScope,
+        selectedPortal: portal,
+        layoutType: portal.layoutType
+      };
+    }
+    const layoutUids = routeScope.layoutUids.length ? routeScope.layoutUids : await this.ensureDesktopRouteUiLayouts(route, options.transaction);
+    return {
+      portalUids: [],
+      layoutUids,
+      layoutType: layoutUids.length === 1 ? await this.getDesktopRouteUiLayoutTypeByUid(layoutUids[0], options.transaction) : void 0
+    };
+  }
+  async attachDesktopRouteScopeToRouteAndChildren(routeId, scope, transaction) {
+    if (scope.layoutUids.length) {
+      await this.attachDesktopRouteUiLayoutsToRouteAndChildren(routeId, scope.layoutUids, transaction);
+    }
+    if (scope.portalUids.length) {
+      await this.navigationTargets.attachRouteTreeToPortals(routeId, scope.portalUids, {
+        portalOnly: scope.layoutUids.length === 0,
+        transaction
+      });
+    }
+  }
+  async assertEnabledDesktopRouteUiLayoutUid(layoutUid, actionName, path, transaction) {
+    if (!this.hasDesktopRouteUiLayoutsRelation()) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} requires plugin-ui-layout desktop route relation support`, {
+        ruleId: "navigation-layout-unsupported",
+        path,
+        details: {
+          layoutUid
+        }
+      });
+    }
+    const uiLayout = await this.db.getRepository("uiLayouts").findOne({
+      filter: {
+        uid: layoutUid,
+        enabled: true
+      },
+      transaction
+    });
+    if (!uiLayout) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} must reference an enabled ui layout`, {
+        ruleId: "navigation-layout-not-found",
+        path,
+        details: {
+          layoutUid
+        }
+      });
+    }
+  }
+  async assertDesktopRouteBelongsToUiLayout(actionName, route, layoutUid, path, transaction) {
+    const normalizedLayoutUid = this.normalizeExplicitDesktopRouteLayoutUid(layoutUid);
+    if (!normalizedLayoutUid || !route) {
+      return;
+    }
+    const routeId = this.readRouteField(route, "id");
+    const routeLayoutUids = await this.readDesktopRouteUiLayoutUids(routeId, transaction);
+    if (routeLayoutUids.includes(normalizedLayoutUid)) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} does not belong to ui layout '${normalizedLayoutUid}'`, {
+      ruleId: "navigation-route-layout-mismatch",
+      path,
+      details: {
+        routeId,
+        layoutUid: normalizedLayoutUid,
+        routeLayoutUids
+      }
+    });
+  }
+  async setDesktopRouteUiLayouts(routeId, uiLayoutUids, transaction) {
+    const relationRouteId = this.normalizeDesktopRouteRelationId(routeId);
+    if (import_lodash.default.isUndefined(relationRouteId) || !uiLayoutUids.length || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return;
+    }
+    await this.db.getRepository("desktopRoutes.uiLayouts", relationRouteId).set({
+      tk: uiLayoutUids,
+      transaction
+    });
+  }
+  async attachDesktopRouteUiLayoutsToRouteAndChildren(routeId, uiLayoutUids, transaction) {
+    if (import_lodash.default.isNil(routeId) || !uiLayoutUids.length || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return;
+    }
+    await this.setDesktopRouteUiLayouts(routeId, uiLayoutUids, transaction);
+    const children = await this.db.getRepository("desktopRoutes").find({
+      fields: ["id"],
+      filter: {
+        parentId: routeId
+      },
+      transaction
+    });
+    for (const child of children) {
+      await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+        this.readRouteField(child, "id"),
+        uiLayoutUids,
+        transaction
+      );
+    }
+  }
+  async ensureDesktopRouteUiLayouts(route, transaction) {
+    const routeId = this.readRouteField(route, "id");
+    if (import_lodash.default.isNil(routeId) || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return [];
+    }
+    const existingLayoutUids = await this.readDesktopRouteUiLayoutUids(routeId, transaction);
+    if (existingLayoutUids.length) {
+      return existingLayoutUids;
+    }
+    const parentRouteId = this.readRouteField(route, "parentId");
+    const parentRoute = import_lodash.default.isNil(parentRouteId) ? null : await this.findMenuRouteById(parentRouteId, transaction);
+    const inheritedLayoutUids = await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction);
+    await this.setDesktopRouteUiLayouts(routeId, inheritedLayoutUids, transaction);
+    return inheritedLayoutUids;
+  }
   isValidMenuIconName(value) {
     const normalized = String(value || "").trim();
     return !!normalized && ANT_DESIGN_ICON_NAMES.has(normalized);
@@ -1078,11 +1517,19 @@ class FlowSurfacesService {
       });
     }
   }
-  async createFlowMenuGroup(values, transaction) {
-    const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, transaction);
+  async createFlowMenuGroup(values, options = {}) {
+    var _a;
+    const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
     const parentId = this.readRouteField(parentRoute, "id") ?? null;
+    const routeScope = await this.resolveRequestedDesktopRouteScope(values, parentRoute, "createMenu", options);
     const title = String(values.title || "").trim();
-    const existingGroups = await this.findMenuGroupRoutesByParentIdAndTitle(parentId, title, transaction);
+    const existingGroups = await this.findMenuGroupRoutesByParentIdAndTitle(
+      parentId,
+      title,
+      options.transaction,
+      routeScope.layoutUids,
+      (_a = routeScope.selectedPortal) == null ? void 0 : _a.uid
+    );
     if (existingGroups.length === 1) {
       return this.buildMenuResult(existingGroups[0]);
     }
@@ -1107,7 +1554,7 @@ class FlowSurfacesService {
     this.assertVisibleNavigationIcon("createMenu", "values", values);
     const schemaUid = values.schemaUid || (0, import_utils.uid)();
     const desktopRoutes = this.db.getRepository("desktopRoutes");
-    await desktopRoutes.create({
+    const route = await desktopRoutes.create({
       values: {
         type: "group",
         sort: this.allocateRouteSortValue(),
@@ -1118,17 +1565,19 @@ class FlowSurfacesService {
         hideInMenu: !!values.hideInMenu,
         parentId
       },
-      transaction
-    });
-    const route = await desktopRoutes.findOne({
-      filter: { schemaUid },
-      transaction
+      transaction: options.transaction
     });
+    await this.attachDesktopRouteScopeToRouteAndChildren(
+      this.readRouteField(route, "id"),
+      routeScope,
+      options.transaction
+    );
     return this.buildMenuResult(route);
   }
-  async createFlowMenuItem(values, transaction) {
+  async createFlowMenuItem(values, options = {}) {
     var _a;
-    const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, transaction);
+    const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
+    const routeScope = await this.resolveRequestedDesktopRouteScope(values, parentRoute, "createMenu", options);
     this.assertVisibleNavigationIcon("createMenu", "values", values);
     const pageSchemaUid = values.pageSchemaUid || (0, import_utils.uid)();
     const menuSchemaUid = (0, import_utils.uid)();
@@ -1138,7 +1587,7 @@ class FlowSurfacesService {
     const title = values.title || pageSchemaUid;
     const tabTitle = values.tabTitle || "Untitled";
     const desktopRoutes = this.db.getRepository("desktopRoutes");
-    await desktopRoutes.create({
+    const createdRoute = await desktopRoutes.create({
       values: {
         type: "flowPage",
         sort: this.allocateRouteSortValue(),
@@ -1171,15 +1620,20 @@ class FlowSurfacesService {
           }
         ]
       },
-      transaction
+      transaction: options.transaction
     });
+    await this.attachDesktopRouteScopeToRouteAndChildren(
+      this.readRouteField(createdRoute, "id"),
+      routeScope,
+      options.transaction
+    );
     const route = await desktopRoutes.findOne({
       filter: { schemaUid: pageSchemaUid },
       appends: ["children"],
-      transaction
+      transaction: options.transaction
     });
     const tabRoute = import_lodash.default.sortBy(import_lodash.default.castArray(((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "children")) || []), "sort")[0];
-    await this.ensureFlowRoutePageSchemaShell(pageSchemaUid, transaction);
+    await this.ensureFlowRoutePageSchemaShell(pageSchemaUid, options.transaction);
     const pageTree = (0, import_builder.buildPersistedRootPageModel)({
       pageUid,
       pageTitle: title,
@@ -1195,7 +1649,7 @@ class FlowSurfacesService {
         subType: "object",
         ...pageTree
       },
-      { transaction }
+      { transaction: options.transaction }
     );
     return this.buildMenuResult(route, {
       pageSchemaUid,
@@ -1207,7 +1661,16 @@ class FlowSurfacesService {
     });
   }
   sanitizePublicCreateMenuValues(values) {
-    return import_lodash.default.pick(values, ["title", "type", "icon", "tooltip", "hideInMenu", "parentMenuRouteId"]);
+    return import_lodash.default.pick(values, [
+      "title",
+      "type",
+      "layoutUid",
+      "portalUid",
+      "icon",
+      "tooltip",
+      "hideInMenu",
+      "parentMenuRouteId"
+    ]);
   }
   async loadRouteBackedPageStructure(route, transaction) {
     const routeId = this.readRouteField(route, "id");
@@ -1581,7 +2044,7 @@ class FlowSurfacesService {
     return !blockScenes.some((scene) => this.isPopupCollectionBlockSceneUnsupported(scene));
   }
   resolveFieldAssociationContextFromBinding(input) {
-    var _a;
+    var _a, _b;
     const parsed = this.parseFieldPath(
       input.collection,
       input.fieldPath,
@@ -1598,13 +2061,14 @@ class FlowSurfacesService {
     );
     const targetCollection = (associationField ? resolveTargetCollection(associationField) || (associationField == null ? void 0 : associationField.targetCollection) : null) || resolveTargetCollection(leafField) || (leafField == null ? void 0 : leafField.targetCollection) || null;
     const targetCollectionName = (0, import_service_helpers.getCollectionName)(targetCollection) || (associationField ? (0, import_service_helpers.getFieldTarget)(associationField) : void 0) || parsed.collectionName || input.collectionName;
-    const associationName = parsed.associationPathName ? `${parsed.collectionName}.${parsed.associationPathName}` : associationField ? (0, import_service_helpers.resolveAssociationNameFromField)(associationField, input.collection) : void 0;
+    const fallbackAssociationName = parsed.associationPathName ? `${parsed.collectionName}.${parsed.associationPathName}` : void 0;
+    const associationName = associationField ? ((_a = parsed.associationPathName) == null ? void 0 : _a.includes(".")) ? fallbackAssociationName : (0, import_service_helpers.resolveAssociationNameFromField)(associationField, input.collection) : void 0;
     return {
       associationField,
       targetCollection,
-      dataSourceKey: (targetCollection == null ? void 0 : targetCollection.dataSourceKey) || ((_a = targetCollection == null ? void 0 : targetCollection.options) == null ? void 0 : _a.dataSourceKey) || parsed.dataSourceKey || input.dataSourceKey,
+      dataSourceKey: (targetCollection == null ? void 0 : targetCollection.dataSourceKey) || ((_b = targetCollection == null ? void 0 : targetCollection.options) == null ? void 0 : _b.dataSourceKey) || parsed.dataSourceKey || input.dataSourceKey,
       collectionName: targetCollectionName,
-      associationName
+      associationName: associationName || fallbackAssociationName
     };
   }
   async resolvePopupHostFieldAssociationContext(hostNode, transaction) {
@@ -1945,6 +2409,9 @@ class FlowSurfacesService {
     if (!(popupProfile == null ? void 0 : popupProfile.currentCollection)) {
       return popupProfile == null ? void 0 : popupProfile.filterByTk;
     }
+    if (popupProfile.popupKind === "recordPopup" && popupProfile.popupHostUse && POPUP_HOST_DEFAULT_RECORD_CONTEXT_ACTION_USES.has(popupProfile.popupHostUse)) {
+      return "{{ctx.view.inputArgs.filterByTk}}";
+    }
     if (popupProfile.popupKind !== "associationPopup") {
       return popupProfile.filterByTk;
     }
@@ -2300,10 +2767,18 @@ class FlowSurfacesService {
       if (!sameCurrentCollection || !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.filterByTk)) {
         return false;
       }
+      const expectedFilterByTk = this.resolvePopupCurrentRecordResourceFilterByTk(input.popupProfile, {
+        usePopupInputArgsWhenSourceIdInferred: true
+      });
+      const matchesCurrentRecordFilterByTk = this.isPopupCurrentRecordFilterByTkMatch(
+        input.popupProfile,
+        normalized.filterByTk,
+        expectedFilterByTk
+      );
       if (input.popupProfile.hasAssociationContext) {
-        return this.isSameConfiguredFlowContextValue(normalized.filterByTk, input.popupProfile.filterByTk) && normalized.associationName === input.popupProfile.associationName && this.isSameConfiguredFlowContextValue(normalized.sourceId, input.popupProfile.sourceId);
+        return matchesCurrentRecordFilterByTk && normalized.associationName === input.popupProfile.associationName && this.isSameConfiguredFlowContextValue(normalized.sourceId, input.popupProfile.sourceId);
       }
-      return this.isSameConfiguredFlowContextValue(normalized.filterByTk, input.popupProfile.filterByTk) && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.associationName) && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.sourceId);
+      return matchesCurrentRecordFilterByTk && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.associationName) && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.sourceId);
     }
     if (input.binding === "associatedRecords") {
       if (!(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.collectionName) || !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.associationName) || !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.sourceId) || (0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.filterByTk)) {
@@ -2346,6 +2821,12 @@ class FlowSurfacesService {
     }
     return import_lodash.default.isEqual(this.normalizeFlowContextTemplateValue(left), this.normalizeFlowContextTemplateValue(right));
   }
+  isPopupCurrentRecordFilterByTkMatch(popupProfile, filterByTk, expectedFilterByTk) {
+    if (this.isSameConfiguredFlowContextValue(filterByTk, expectedFilterByTk)) {
+      return true;
+    }
+    return popupProfile.popupKind === "associationPopup" && this.isSameConfiguredFlowContextValue(filterByTk, popupProfile.filterByTk);
+  }
   isPopupAssociatedRecordsSourceIdMatch(popupProfile, associationField, sourceId) {
     var _a, _b;
     if (!(0, import_service_helpers.hasConfiguredFlowContextValue)(sourceId)) {
@@ -2621,6 +3102,28 @@ class FlowSurfacesService {
     }
     return capability;
   }
+  async getLiveFieldValueCapability(writeTarget, resolvedTarget, node, options = {}) {
+    const context = await this.context(
+      {
+        target: writeTarget
+      },
+      options
+    );
+    const { capabilities } = (0, import_meta.buildReactionMetaCapabilities)({
+      resolvedTarget: {
+        ...resolvedTarget,
+        node
+      },
+      context
+    });
+    const capability = capabilities.find((item) => item.kind === "fieldValue");
+    if (!capability) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces reaction target '${resolvedTarget.use || resolvedTarget.target.uid}' does not support fieldValue`
+      );
+    }
+    return capability;
+  }
   async getReactionMeta(values, options = {}) {
     (0, import_payload_shape.validateFlowSurfacePayloadShape)("getReactionMeta", values, "values");
     const { writeTarget, node, resolvedTarget } = await this.resolveReactionRequest("getReactionMeta", values == null ? void 0 : values.target, {
@@ -2666,6 +3169,8 @@ class FlowSurfacesService {
       },
       rules: Array.isArray(values == null ? void 0 : values.rules) ? values.rules : []
     });
+    const liveCapability = await this.getLiveFieldValueCapability(writeTarget, resolvedTarget, node, options);
+    (0, import_field_value.validateFieldValueRulesAgainstCapability)(result.normalizedRules, liveCapability);
     await this.persistReactionSlot(storageNode, capability.resolvedSlot, result.canonicalRules, options);
     return result;
   }
@@ -2873,6 +3378,41 @@ class FlowSurfacesService {
     const publicNode = this.stripInternalSurfaceMetaFromNodeTree(import_lodash.default.cloneDeep(rawNode));
     return this.buildSurfaceReadPayload(target, resolved, publicNode, options);
   }
+  async exportBlueprint(input, options = {}) {
+    const request = this.normalizeExportBlueprintRequest(input);
+    const resolved = await this.locator.resolve(request.target, options);
+    if (resolved.kind !== "page" || !resolved.pageRoute) {
+      (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+    }
+    const pageSchemaUid = this.resolveExportBlueprintPageSchemaUid(request.target, resolved);
+    await this.assertExportBlueprintRootTarget(request.target, resolved, pageSchemaUid, options.transaction);
+    const rawNode = await this.decorateTemplateReadbackTree(
+      this.normalizePopupTreeShape(
+        await this.loadResolvedNode(resolved, options.transaction, {
+          persistCalendarPopupHosts: false
+        })
+      ),
+      options.transaction
+    );
+    if (!(rawNode == null ? void 0 : rawNode.uid)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint target '${pageSchemaUid}' could not resolve a readable page tree`);
+    }
+    const pageRoute = resolved.pageRoute ? await this.routeSync.hydrateRoute(resolved.pageRoute, options.transaction) : void 0;
+    const result = (0, import_export_document.exportFlowSurfaceBlueprintDocument)({
+      page: rawNode,
+      pageRoute,
+      target: {
+        pageSchemaUid
+      },
+      unsupportedPolicy: request.unsupportedPolicy
+    });
+    return {
+      ...result,
+      document: (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(
+        result.document
+      )
+    };
+  }
   getDeclaredKeyPersistenceDeps() {
     return {
       findModelById: (uid2, findOptions) => this.repository.findModelById(uid2, findOptions),
@@ -3041,7 +3581,15 @@ class FlowSurfacesService {
     if (!groupTitle) {
       return document;
     }
-    const matchedRoutes = await this.findMenuGroupRoutesByParentIdAndTitle(null, groupTitle, transaction);
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid(document.navigation.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid(document.navigation.portalUid);
+    const matchedRoutes = await this.findMenuGroupRoutesByParentIdAndTitle(
+      null,
+      groupTitle,
+      transaction,
+      layoutUid || await this.resolveDefaultDesktopRouteUiLayoutUids(transaction),
+      portalUid
+    );
     if (!matchedRoutes.length) {
       return document;
     }
@@ -3066,29 +3614,148 @@ class FlowSurfacesService {
       }
     };
   }
+  async normalizeApplyBlueprintCreateMobileNavigation(document, options = {}) {
+    var _a, _b;
+    if (document.mode !== "create") {
+      return document;
+    }
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid((_a = document.navigation) == null ? void 0 : _a.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid((_b = document.navigation) == null ? void 0 : _b.portalUid);
+    const layoutType = portalUid ? (await this.navigationTargets.resolvePortal(portalUid, {
+      actionName: "applyBlueprint",
+      path: "values.navigation.portalUid",
+      currentRoles: options.currentRoles,
+      transaction: options.transaction
+    })).layoutType : await this.getDesktopRouteUiLayoutTypeByUid(layoutUid || "", options.transaction);
+    if (layoutType !== MOBILE_UI_LAYOUT_TYPE) {
+      return document;
+    }
+    return {
+      ...document,
+      navigation: (0, import_service_utils.buildDefinedPayload)({
+        ...document.navigation,
+        layoutUid,
+        portalUid,
+        group: void 0
+      })
+    };
+  }
+  async assertApplyBlueprintCreateNavigationTarget(document, options = {}) {
+    var _a, _b, _c, _d, _e, _f;
+    if (document.mode !== "create") {
+      return;
+    }
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid((_a = document.navigation) == null ? void 0 : _a.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid((_b = document.navigation) == null ? void 0 : _b.portalUid);
+    this.assertNavigationTargetIsExclusive("applyBlueprint", layoutUid, portalUid, {
+      layout: "values.navigation.layoutUid",
+      portal: "values.navigation.portalUid"
+    });
+    if (!layoutUid && !portalUid) {
+      return;
+    }
+    if (portalUid) {
+      const portal = await this.navigationTargets.resolvePortal(portalUid, {
+        actionName: "applyBlueprint",
+        path: "values.navigation.portalUid",
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      if (portal.layoutType === MOBILE_UI_LAYOUT_TYPE) {
+        return;
+      }
+      const groupRouteId2 = (_d = (_c = document.navigation) == null ? void 0 : _c.group) == null ? void 0 : _d.routeId;
+      if (import_lodash.default.isNil(groupRouteId2) || groupRouteId2 === "") {
+        return;
+      }
+      const groupRoute2 = await this.assertMenuParentIsGroup(groupRouteId2, options.transaction);
+      await this.navigationTargets.assertRouteBelongsToPortal(
+        "applyBlueprint",
+        this.readRouteField(groupRoute2, "id"),
+        portal.uid,
+        "values.navigation.group.routeId",
+        options.transaction
+      );
+      return;
+    }
+    await this.assertEnabledDesktopRouteUiLayoutUid(
+      layoutUid,
+      "applyBlueprint",
+      "values.navigation.layoutUid",
+      options.transaction
+    );
+    if (await this.isMobileDesktopRouteUiLayoutUid(layoutUid, options.transaction)) {
+      return;
+    }
+    const groupRouteId = (_f = (_e = document.navigation) == null ? void 0 : _e.group) == null ? void 0 : _f.routeId;
+    if (import_lodash.default.isNil(groupRouteId) || groupRouteId === "") {
+      return;
+    }
+    const groupRoute = await this.assertMenuParentIsGroup(groupRouteId, options.transaction);
+    await this.assertDesktopRouteBelongsToUiLayout(
+      "applyBlueprint",
+      groupRoute,
+      layoutUid,
+      "values.navigation.group.routeId",
+      options.transaction
+    );
+  }
   async resolveApplyBlueprintCreatePageIdentity(document, transaction) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     if (document.mode !== "create") {
       return document;
     }
     const groupRouteId = (_b = (_a = document.navigation) == null ? void 0 : _a.group) == null ? void 0 : _b.routeId;
-    const pageTitle = String(((_c = document.page) == null ? void 0 : _c.title) || ((_e = (_d = document.navigation) == null ? void 0 : _d.item) == null ? void 0 : _e.title) || "").trim();
-    if (import_lodash.default.isNil(groupRouteId) || groupRouteId === "" || !pageTitle) {
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid((_c = document.navigation) == null ? void 0 : _c.layoutUid);
+    let portalUid = this.navigationTargets.normalizePortalUid((_d = document.navigation) == null ? void 0 : _d.portalUid);
+    const pageTitle = String(((_e = document.page) == null ? void 0 : _e.title) || ((_g = (_f = document.navigation) == null ? void 0 : _f.item) == null ? void 0 : _g.title) || "").trim();
+    const hasGroupRouteId = !import_lodash.default.isNil(groupRouteId) && groupRouteId !== "";
+    if (!pageTitle || !hasGroupRouteId && !layoutUid && !portalUid) {
       return document;
     }
-    const matchedPages = await this.findFlowPageRoutesByParentIdAndTitle(groupRouteId, pageTitle, transaction);
+    const groupRoute = hasGroupRouteId ? await this.findMenuRouteById(groupRouteId, transaction) : null;
+    if (!portalUid && groupRoute) {
+      const groupPortalUids = await this.navigationTargets.readRoutePortalUids(
+        this.readRouteField(groupRoute, "id"),
+        transaction
+      );
+      if (groupPortalUids.length > 1) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces applyBlueprint navigation.group.routeId '${groupRouteId}' belongs to multiple portals; pass navigation.portalUid explicitly`,
+          {
+            ruleId: "navigation-route-scope-ambiguous",
+            path: "values.navigation.group.routeId",
+            details: {
+              routeId: groupRouteId,
+              portalUids: groupPortalUids
+            }
+          }
+        );
+      }
+      portalUid = groupPortalUids[0];
+    }
+    const layoutUidFilter = portalUid ? void 0 : layoutUid || (groupRoute ? await this.resolveInheritedDesktopRouteUiLayoutUids(groupRoute, transaction) : void 0);
+    const matchedPages = await this.findFlowPageRoutesByParentIdAndTitle(
+      hasGroupRouteId ? groupRouteId : null,
+      pageTitle,
+      transaction,
+      layoutUidFilter,
+      portalUid
+    );
     if (!matchedPages.length) {
       return document;
     }
     if (matchedPages.length > 1) {
+      const locationLabel = hasGroupRouteId ? `under navigation.group.routeId '${groupRouteId}'` : portalUid ? `at the root of portal '${portalUid}'` : `at the root of ui layout '${layoutUid}'`;
       (0, import_errors.throwBadRequest)(
-        `flowSurfaces applyBlueprint navigation.group.routeId '${groupRouteId}' already has ${matchedPages.length} flow pages titled '${pageTitle}'; pass target.pageSchemaUid explicitly before applyBlueprint`
+        `flowSurfaces applyBlueprint ${locationLabel} already has ${matchedPages.length} flow pages titled '${pageTitle}'; pass target.pageSchemaUid explicitly before applyBlueprint`
       );
     }
     const pageSchemaUid = String(this.readRouteField(matchedPages[0], "schemaUid") || "").trim();
     if (!pageSchemaUid) {
+      const locationLabel = hasGroupRouteId ? `under navigation.group.routeId '${groupRouteId}'` : portalUid ? `at the root of portal '${portalUid}'` : `at the root of ui layout '${layoutUid}'`;
       (0, import_errors.throwBadRequest)(
-        `flowSurfaces applyBlueprint existing flow page '${pageTitle}' under navigation.group.routeId '${groupRouteId}' is missing schemaUid; pass target.pageSchemaUid explicitly before applyBlueprint`
+        `flowSurfaces applyBlueprint existing flow page '${pageTitle}' ${locationLabel} is missing schemaUid; pass target.pageSchemaUid explicitly before applyBlueprint`
       );
     }
     return {
@@ -3100,13 +3767,18 @@ class FlowSurfacesService {
       navigation: void 0
     };
   }
-  async prepareApplyBlueprintRequest(values, transaction, createdKanbanSortFields) {
+  async prepareApplyBlueprintRequest(values, options = {}, createdKanbanSortFields) {
     var _a;
     const initialDocument = (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(values);
-    const groupResolvedDocument = await this.resolveApplyBlueprintCreateNavigationGroup(initialDocument, transaction);
-    const document = await this.resolveApplyBlueprintCreatePageIdentity(groupResolvedDocument, transaction);
-    await this.prepareApplyBlueprintKanbanBlocks(document, transaction, createdKanbanSortFields);
-    const replaceTarget = document.mode === "replace" && document.target ? await this.resolveApplyBlueprintReplaceTargetInfo(document.target.pageSchemaUid, transaction) : void 0;
+    await this.assertApplyBlueprintCreateNavigationTarget(initialDocument, options);
+    const mobileNormalizedDocument = await this.normalizeApplyBlueprintCreateMobileNavigation(initialDocument, options);
+    const groupResolvedDocument = await this.resolveApplyBlueprintCreateNavigationGroup(
+      mobileNormalizedDocument,
+      options.transaction
+    );
+    const document = await this.resolveApplyBlueprintCreatePageIdentity(groupResolvedDocument, options.transaction);
+    await this.prepareApplyBlueprintKanbanBlocks(document, options.transaction, createdKanbanSortFields);
+    const replaceTarget = document.mode === "replace" && document.target ? await this.resolveApplyBlueprintReplaceTargetInfo(document.target.pageSchemaUid, options.transaction) : void 0;
     if (document.mode === "replace" && document.tabs.length > 1 && typeof ((_a = document.page) == null ? void 0 : _a.enableTabs) === "undefined" && (replaceTarget == null ? void 0 : replaceTarget.pageEnableTabs) === false) {
       (0, import_errors.throwBadRequest)(
         `flowSurfaces applyBlueprint replace mode requires page.enableTabs=true when tabs.length > 1 and the current page has enableTabs=false`
@@ -3756,11 +4428,36 @@ class FlowSurfacesService {
     }
   }
   async assertApplyBlueprintAuthoringPayload(values, options = {}) {
+    var _a, _b;
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
+    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid((_b = values == null ? void 0 : values.navigation) == null ? void 0 : _b.portalUid);
+    this.assertNavigationTargetIsExclusive("applyBlueprint", layoutUid, portalUid, {
+      layout: "values.navigation.layoutUid",
+      portal: "values.navigation.portalUid"
+    });
+    const resolvedPortal = portalUid ? await this.navigationTargets.resolvePortal(portalUid, {
+      actionName: "applyBlueprint",
+      path: "values.navigation.portalUid",
+      currentRoles: options.currentRoles,
+      transaction: options.transaction
+    }) : void 0;
     await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("applyBlueprint", values, {
       transaction: options.transaction,
       enabledPackages,
-      findMenuGroupRoutesByTitle: (title, transaction) => this.findMenuGroupRoutesByTitle(title, transaction),
+      findMenuGroupRoutesByTitle: (title, transaction, targetLayoutUid, targetPortalUid) => this.findMenuGroupRoutesByTitle(title, transaction, targetLayoutUid, targetPortalUid),
+      getUiLayoutTypeByUid: (layoutUid2, transaction) => this.getDesktopRouteUiLayoutTypeByUid(layoutUid2, transaction),
+      getPortalLayoutTypeByUid: async (targetPortalUid, transaction) => {
+        if ((resolvedPortal == null ? void 0 : resolvedPortal.uid) === targetPortalUid) {
+          return resolvedPortal.layoutType;
+        }
+        return (await this.navigationTargets.resolvePortal(targetPortalUid, {
+          actionName: "applyBlueprint",
+          path: "values.navigation.portalUid",
+          currentRoles: options.currentRoles,
+          transaction
+        })).layoutType;
+      },
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey || "main", collectionName || "")
     });
   }
@@ -3768,7 +4465,7 @@ class FlowSurfacesService {
     if (options.skipAuthoringValidation !== true) {
       await this.assertApplyBlueprintAuthoringPayload(values, options);
     }
-    const prepared = await this.prepareApplyBlueprintRequest(values, options.transaction, createdKanbanSortFields);
+    const prepared = await this.prepareApplyBlueprintRequest(values, options, createdKanbanSortFields);
     const popupTemplateAliasSession = this.createPopupTemplateAliasSession();
     const popupTemplateTreeCache = /* @__PURE__ */ new Map();
     this.validateApplyBlueprintPopupTemplateAliases(prepared.document, popupTemplateAliasSession);
@@ -4399,6 +5096,7 @@ class FlowSurfacesService {
         );
       }
       const popupProfile = await this.resolvePopupBlockProfile(node.uid, null, node, transaction).catch(() => null);
+      const sourceId = String(openView.sourceId || "").trim() || ((popupProfile == null ? void 0 : popupProfile.sourceIdInferred) ? "" : String((popupProfile == null ? void 0 : popupProfile.sourceId) || "").trim()) || void 0;
       const popupSourceNode = popupTargetUid ? await this.repository.findModelById(popupTargetUid, {
         transaction,
         includeAsyncNode: true
@@ -4412,7 +5110,7 @@ class FlowSurfacesService {
         collectionName: String(openView.collectionName || "").trim() || String((popupProfile == null ? void 0 : popupProfile.collectionName) || "").trim() || void 0,
         associationName: String(openView.associationName || "").trim() || String((popupProfile == null ? void 0 : popupProfile.associationName) || "").trim() || void 0,
         filterByTk: String(openView.filterByTk || "").trim() || String((popupProfile == null ? void 0 : popupProfile.filterByTk) || "").trim() || void 0,
-        sourceId: String(openView.sourceId || "").trim() || String((popupProfile == null ? void 0 : popupProfile.sourceId) || "").trim() || void 0,
+        sourceId,
         openViewStep
       };
     }
@@ -4474,10 +5172,16 @@ class FlowSurfacesService {
     return this.buildPopupTemplateOpenView(template, "reference", templateTargetUid, options);
   }
   shouldHydrateDetachedPopupTemplateBlockResourceContext(blockNode, context) {
-    if (!this.isCollectionBlockUse(blockNode == null ? void 0 : blockNode.use) || !context.associationName || !context.sourceId) {
+    if (!this.isCollectionBlockUse(blockNode == null ? void 0 : blockNode.use)) {
       return false;
     }
     const init = import_lodash.default.get(blockNode, ["stepParams", "resourceSettings", "init"]) || {};
+    if (this.resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk(init, context)) {
+      return true;
+    }
+    if (!context.associationName || !context.sourceId) {
+      return false;
+    }
     const popupDataSourceKey = context.dataSourceKey || "main";
     const blockDataSourceKey = init.dataSourceKey || "main";
     if (!context.collectionName || blockDataSourceKey !== popupDataSourceKey || init.collectionName !== context.collectionName) {
@@ -4492,6 +5196,28 @@ class FlowSurfacesService {
     }
     return blockAssociationName !== context.associationName || !this.isSameConfiguredFlowContextValue(init.sourceId, context.sourceId);
   }
+  resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk(init, context) {
+    if (!(0, import_service_helpers.hasConfiguredFlowContextValue)(init.filterByTk)) {
+      return void 0;
+    }
+    if (this.isSameConfiguredFlowContextValue(init.filterByTk, "{{ctx.view.inputArgs.filterByTk}}")) {
+      return void 0;
+    }
+    const popupDataSourceKey = context.dataSourceKey || "main";
+    const blockDataSourceKey = init.dataSourceKey || "main";
+    if (!context.collectionName || blockDataSourceKey !== popupDataSourceKey || init.collectionName !== context.collectionName) {
+      return void 0;
+    }
+    if (context.filterByTk && this.isSameConfiguredFlowContextValue(init.filterByTk, context.filterByTk)) {
+      return "{{ctx.view.inputArgs.filterByTk}}";
+    }
+    const collection = this.getCollection(popupDataSourceKey, context.collectionName);
+    const filterTargetKey = this.getCollectionFilterTargetKey(collection);
+    if (this.isSameConfiguredFlowContextValue(init.filterByTk, `{{ctx.record.${filterTargetKey}}}`)) {
+      return "{{ctx.view.inputArgs.filterByTk}}";
+    }
+    return void 0;
+  }
   collectDetachedPopupTemplateBlockResourceContextPatches(node, context, patches = []) {
     if (!node || typeof node !== "object") {
       return patches;
@@ -4499,6 +5225,7 @@ class FlowSurfacesService {
     if (node.uid && this.shouldHydrateDetachedPopupTemplateBlockResourceContext(node, context)) {
       const nextStepParams = import_lodash.default.cloneDeep(node.stepParams || {});
       const currentInit = import_lodash.default.get(nextStepParams, ["resourceSettings", "init"]) || {};
+      const filterByTk = this.resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk(currentInit, context);
       import_lodash.default.set(
         nextStepParams,
         ["resourceSettings", "init"],
@@ -4506,8 +5233,11 @@ class FlowSurfacesService {
           ...currentInit,
           dataSourceKey: context.dataSourceKey || currentInit.dataSourceKey || "main",
           collectionName: context.collectionName || currentInit.collectionName,
-          associationName: context.associationName,
-          sourceId: context.sourceId
+          ...context.associationName && context.sourceId ? {
+            associationName: context.associationName,
+            sourceId: context.sourceId
+          } : {},
+          ...filterByTk ? { filterByTk } : {}
         })
       );
       patches.push({
@@ -5750,6 +6480,9 @@ class FlowSurfacesService {
     }
     (0, import_errors.throwBadRequest)(`flowSurfaces configure does not support configureOptions on '${(current == null ? void 0 : current.use) || resolved.uid}'`);
   }
+  async listNavigationTargets(_values = {}, options = {}) {
+    return this.navigationTargets.listNavigationTargets(options.currentRoles, options.transaction);
+  }
   async createMenu(values, options = {}) {
     const publicValues = this.sanitizePublicCreateMenuValues(values || {});
     const type = publicValues.type === "group" ? "group" : "item";
@@ -5757,9 +6490,9 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)("flowSurfaces createMenu requires title");
     }
     if (type === "group") {
-      return this.createFlowMenuGroup(publicValues, options.transaction);
+      return this.createFlowMenuGroup(publicValues, options);
     }
-    return this.createFlowMenuItem(publicValues, options.transaction);
+    return this.createFlowMenuItem(publicValues, options);
   }
   async updateMenu(values, options = {}) {
     const menuRouteId = values.menuRouteId;
@@ -5767,8 +6500,55 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)("flowSurfaces updateMenu requires menuRouteId");
     }
     const route = await this.assertMenuRouteUpdatable(menuRouteId, options.transaction);
-    await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
+    const nextParentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
     await this.assertMenuParentNotSelfOrDescendant(route, values.parentMenuRouteId, options.transaction);
+    const portalUid = this.navigationTargets.normalizePortalUid(values.portalUid);
+    this.assertNavigationTargetIsExclusive("updateMenu", values.layoutUid, portalUid, {
+      layout: "values.layoutUid",
+      portal: "values.portalUid"
+    });
+    const routeScope = await this.readDesktopRouteScope(route, options.transaction);
+    if (portalUid) {
+      const portal = await this.navigationTargets.resolvePortal(portalUid, {
+        actionName: "updateMenu",
+        path: "values.portalUid",
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      await this.navigationTargets.assertRouteBelongsToPortal(
+        "updateMenu",
+        this.readRouteField(route, "id"),
+        portal.uid,
+        "values.menuRouteId",
+        options.transaction
+      );
+      if (nextParentRoute) {
+        await this.navigationTargets.assertRouteBelongsToPortal(
+          "updateMenu",
+          this.readRouteField(nextParentRoute, "id"),
+          portal.uid,
+          "values.parentMenuRouteId",
+          options.transaction
+        );
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(values, "parentMenuRouteId") && nextParentRoute) {
+      const parentScope = await this.readDesktopRouteScope(nextParentRoute, options.transaction);
+      const routePortalUids = [...routeScope.portalUids].sort();
+      const parentPortalUids = [...parentScope.portalUids].sort();
+      if (!import_lodash.default.isEqual(routePortalUids, parentPortalUids) && (routePortalUids.length || parentPortalUids.length)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces updateMenu cannot move a menu route across portal scopes`, {
+          ruleId: "navigation-route-portal-mismatch",
+          path: "values.parentMenuRouteId",
+          details: {
+            routeId: this.readRouteField(route, "id"),
+            routePortalUids,
+            parentRouteId: this.readRouteField(nextParentRoute, "id"),
+            parentPortalUids
+          }
+        });
+      }
+    }
     const nextOptions = { ...this.readRouteOptions(route) };
     const updateValues = {};
     if (Object.prototype.hasOwnProperty.call(values, "title")) {
@@ -5798,13 +6578,30 @@ class FlowSurfacesService {
       });
     }
     const updated = await this.findMenuRouteById(menuRouteId, options.transaction);
+    if (updated && Object.prototype.hasOwnProperty.call(values, "parentMenuRouteId")) {
+      if (routeScope.portalUids.length) {
+        await this.attachDesktopRouteScopeToRouteAndChildren(
+          this.readRouteField(updated, "id"),
+          routeScope,
+          options.transaction
+        );
+      } else {
+        await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+          this.readRouteField(updated, "id"),
+          await this.resolveInheritedDesktopRouteUiLayoutUids(nextParentRoute, options.transaction),
+          options.transaction
+        );
+      }
+    }
     return this.buildMenuResult(updated);
   }
-  async initializeFlowPageForRoute(route, values, transaction) {
+  async initializeFlowPageForRoute(route, values, options = {}) {
+    const transaction = options.transaction;
     const routeId = this.readRouteField(route, "id");
     const pageSchemaUid = this.readRouteField(route, "schemaUid");
     const structure = await this.loadRouteBackedPageStructure(route, transaction);
     let tabRoute = structure.tabRoutes[0];
+    const routeScope = await this.resolveExistingDesktopRouteScope(values, route, "createPage", options);
     const routeOptions = this.readRouteOptions(route);
     if (!routeOptions[FLOW_SURFACE_MENU_BINDABLE_OPTION_KEY]) {
       (0, import_errors.throwBadRequest)(`flowSurfaces createPage only accepts a bindable menu route created by createMenu(type="item")`);
@@ -5826,7 +6623,7 @@ class FlowSurfacesService {
       const tabSchemaUid2 = values.tabSchemaUid || (0, import_utils.uid)();
       const tabSchemaName2 = values.tabSchemaName || (0, import_utils.uid)();
       const tabTitle = values.tabTitle || "Untitled";
-      await this.db.getRepository("desktopRoutes").create({
+      tabRoute = await this.db.getRepository("desktopRoutes").create({
         values: {
           type: "tabs",
           sort: this.allocateRouteSortValue(1),
@@ -5843,10 +6640,11 @@ class FlowSurfacesService {
         },
         transaction
       });
-      tabRoute = await this.db.getRepository("desktopRoutes").findOne({
-        filter: { schemaUid: tabSchemaUid2 },
-        transaction
-      });
+      await this.attachDesktopRouteScopeToRouteAndChildren(
+        this.readRouteField(tabRoute, "id"),
+        routeScope,
+        transaction
+      );
     } else {
       await this.db.getRepository("desktopRoutes").update({
         filterByTk: String(this.readRouteField(tabRoute, "id")),
@@ -5870,6 +6668,13 @@ class FlowSurfacesService {
         transaction
       });
     }
+    if (tabRoute) {
+      await this.attachDesktopRouteScopeToRouteAndChildren(
+        this.readRouteField(tabRoute, "id"),
+        routeScope,
+        transaction
+      );
+    }
     await this.ensureFlowRoutePageSchemaShell(pageSchemaUid, transaction);
     await this.db.getRepository("desktopRoutes").update({
       filterByTk: String(routeId),
@@ -5920,11 +6725,11 @@ class FlowSurfacesService {
     let result;
     if (!import_lodash.default.isNil(values.menuRouteId) && values.menuRouteId !== "") {
       const route = await this.assertMenuRouteBindable(values.menuRouteId, options.transaction);
-      result = await this.initializeFlowPageForRoute(route, values, options.transaction);
+      result = await this.initializeFlowPageForRoute(route, values, options);
     } else {
-      const createdMenu = await this.createFlowMenuItem(values, options.transaction);
+      const createdMenu = await this.createFlowMenuItem(values, options);
       const route = await this.assertMenuRouteBindable(createdMenu.routeId, options.transaction);
-      result = await this.initializeFlowPageForRoute(route, values, options.transaction);
+      result = await this.initializeFlowPageForRoute(route, values, options);
     }
     await this.persistCreatedKeysForAction("createPage", values, result, options.transaction);
     return result;
@@ -6009,6 +6814,11 @@ class FlowSurfacesService {
       },
       transaction: options.transaction
     });
+    const pageRouteScope = await this.readDesktopRouteScope(pageRoute, options.transaction);
+    if (!pageRouteScope.portalUids.length && !pageRouteScope.layoutUids.length) {
+      pageRouteScope.layoutUids = await this.ensureDesktopRouteUiLayouts(pageRoute, options.transaction);
+    }
+    await this.attachDesktopRouteScopeToRouteAndChildren(route.get("id"), pageRouteScope, options.transaction);
     const gridUid = await this.ensureGridChild(tabSchemaUid, "BlockGridModel", options.transaction);
     const result = {
       pageUid: pageTarget.uid,
@@ -6679,11 +7489,6 @@ class FlowSurfacesService {
           requiredFieldCount: options.requiredFieldCount
         }
       );
-      if (!(0, import_service_utils.hasOwnDefined)(normalizedSettings, "filterableFieldNames")) {
-        normalizedSettings.filterableFieldNames = (0, import_public_data_surface_default_filter.resolveFlowSurfaceDefaultFilterFieldNames)(
-          normalizedSettings.defaultFilter
-        );
-      }
     }
     return normalizedSettings;
   }
@@ -11417,6 +12222,7 @@ class FlowSurfacesService {
     }
     if (this.isAIEmployeeActionUse(current == null ? void 0 : current.use) && this.hasAIEmployeePublicSettings(normalizedValues)) {
       const enabledPackages = await this.resolveEnabledPluginPackages(options);
+      const hasRawAIEmployeeStepTasks = import_lodash.default.has(normalizedValues, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
       const aiEmployeeSettingsPayload = await this.normalizeAIEmployeeActionPublicSettings(
         "updateSettings",
         import_lodash.default.pick(normalizedValues, AI_EMPLOYEE_PUBLIC_SETTING_KEYS),
@@ -11429,7 +12235,8 @@ class FlowSurfacesService {
           promptContext: {
             kind: "target",
             targetUid: (current == null ? void 0 : current.uid) || writeTarget.uid
-          }
+          },
+          skipExistingTaskWorkContextRebase: hasRawAIEmployeeStepTasks
         }
       );
       AI_EMPLOYEE_PUBLIC_SETTING_KEYS.forEach((key) => {
@@ -11511,6 +12318,7 @@ class FlowSurfacesService {
       normalizedValues,
       nextPayload
     );
+    this.syncActionButtonSettingsForUpdateSettings(current, normalizedValues, nextPayload);
     this.syncActionTriggerWorkflowsForUpdateSettings(current, normalizedValues, nextPayload);
     const popupActionContext = options.popupActionContext || await this.resolveRecordContextPopupActionContextForHost(current, options.transaction);
     await this.normalizeOpenViewForUpdateSettings(
@@ -11562,6 +12370,12 @@ class FlowSurfacesService {
     if (Object.keys(nextPayload).length === 1) {
       return { uid: current.uid };
     }
+    await this.assertNoDuplicateAIEmployeeActionForUpdateSettings(
+      options.openViewActionName || "updateSettings",
+      current,
+      effectiveNode,
+      options.transaction
+    );
     if (target.kind === "tab" && target.tabRoute) {
       await this.routeSync.persistTabSettings(target, current, nextPayload, options.transaction);
       return {
@@ -11972,17 +12786,6 @@ class FlowSurfacesService {
       const filterValue = this.normalizeEffectivePublicDataSurfaceDefaultFilter(normalizedFilterValue, {
         requiredFieldCount: options.requiredFieldCount
       });
-      if (!hasPropsFilterableFieldNames && !hasStepFilterableFieldNames) {
-        const filterableFieldNames = (0, import_public_data_surface_default_filter.resolveFlowSurfaceDefaultFilterFieldNames)(filterValue);
-        if (filterableFieldNames.length) {
-          nextProps.filterableFieldNames = filterableFieldNames;
-          import_lodash.default.set(
-            nextStepParams,
-            ["filterSettings", "filterableFieldNames", "filterableFieldNames"],
-            import_lodash.default.cloneDeep(filterableFieldNames)
-          );
-        }
-      }
       nextProps.defaultFilterValue = import_lodash.default.cloneDeep(filterValue);
       nextProps.filterValue = import_lodash.default.cloneDeep(filterValue);
       import_lodash.default.set(nextStepParams, ["filterSettings", "defaultFilter", "defaultFilter"], import_lodash.default.cloneDeep(filterValue));
@@ -12029,6 +12832,65 @@ class FlowSurfacesService {
       nextPayload.stepParams = nextStepParams;
     }
   }
+  syncActionButtonSettingsForUpdateSettings(current, normalizedValues, nextPayload) {
+    if (!this.supportsActionButtonSettingsSync(current)) {
+      return;
+    }
+    const requestedProps = this.pickRequestedActionButtonSettings(normalizedValues.props);
+    const requestedButtonGeneral = this.pickRequestedActionButtonSettings(
+      import_lodash.default.get(normalizedValues, ["stepParams", "buttonSettings", "general"])
+    );
+    const hasRequestedProps = Object.keys(requestedProps).length > 0;
+    const hasRequestedButtonGeneral = Object.keys(requestedButtonGeneral).length > 0;
+    if (!hasRequestedProps && !hasRequestedButtonGeneral) {
+      return;
+    }
+    const hasRequestedTitle = Object.prototype.hasOwnProperty.call(requestedProps, "title") || Object.prototype.hasOwnProperty.call(requestedButtonGeneral, "title");
+    const shouldStripImplicitTitle = (requestedProps.iconOnly === true || requestedButtonGeneral.iconOnly === true) && !hasRequestedTitle;
+    const nextProps = import_lodash.default.cloneDeep(
+      import_lodash.default.isPlainObject(nextPayload.props) ? nextPayload.props : import_lodash.default.isPlainObject(current == null ? void 0 : current.props) ? current.props : {}
+    );
+    const nextStepParams = import_lodash.default.cloneDeep(
+      import_lodash.default.isPlainObject(nextPayload.stepParams) ? nextPayload.stepParams : import_lodash.default.isPlainObject(current == null ? void 0 : current.stepParams) ? current.stepParams : {}
+    );
+    Object.entries(requestedProps).forEach(([key, value]) => {
+      if (Object.prototype.hasOwnProperty.call(requestedButtonGeneral, key)) {
+        return;
+      }
+      import_lodash.default.set(nextStepParams, ["buttonSettings", "general", key], import_lodash.default.cloneDeep(value));
+    });
+    Object.entries(requestedButtonGeneral).forEach(([key, value]) => {
+      if (Object.prototype.hasOwnProperty.call(requestedProps, key)) {
+        return;
+      }
+      nextProps[key] = import_lodash.default.cloneDeep(value);
+    });
+    if (shouldStripImplicitTitle) {
+      delete nextProps.title;
+      if (import_lodash.default.isPlainObject(import_lodash.default.get(nextStepParams, ["buttonSettings", "general"]))) {
+        delete nextStepParams.buttonSettings.general.title;
+      }
+    }
+    nextPayload.props = nextProps;
+    nextPayload.stepParams = nextStepParams;
+  }
+  supportsActionButtonSettingsSync(current) {
+    var _a, _b, _c, _d, _e, _f;
+    const contract = (0, import_catalog.getNodeContract)(current == null ? void 0 : current.use);
+    return ((_b = (_a = contract.domains.props) == null ? void 0 : _a.allowedKeys) == null ? void 0 : _b.includes("iconOnly")) && ((_f = (_e = (_d = (_c = contract.domains.stepParams) == null ? void 0 : _c.groups) == null ? void 0 : _d.buttonSettings) == null ? void 0 : _e.allowedPaths) == null ? void 0 : _f.includes("general.iconOnly"));
+  }
+  pickRequestedActionButtonSettings(input) {
+    const picked = {};
+    if (!import_lodash.default.isPlainObject(input)) {
+      return picked;
+    }
+    ACTION_BUTTON_GENERAL_SETTING_KEYS.forEach((key) => {
+      if (Object.prototype.hasOwnProperty.call(input, key) && !import_lodash.default.isUndefined(input[key])) {
+        picked[key] = import_lodash.default.cloneDeep(input[key]);
+      }
+    });
+    return picked;
+  }
   syncCreatedFieldWrapperTitleFieldStepParams(node) {
     const mirror = (UPDATE_SETTINGS_STEP_PARAM_MIRRORS_BY_USE[(node == null ? void 0 : node.use) || ""] || []).find(
       (item) => item.domain === "props" && item.key === "titleField"
@@ -13694,6 +14556,111 @@ class FlowSurfacesService {
     }
     return target;
   }
+  normalizeExportBlueprintRequest(input) {
+    if (!import_lodash.default.isPlainObject(input)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint payload must be an object`);
+    }
+    const unsupportedKeys = Object.keys(input).filter((key) => key !== "target" && key !== "options");
+    if (unsupportedKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint only accepts target and options`);
+    }
+    if (!import_lodash.default.isPlainObject(input.target)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint requires target`);
+    }
+    const targetInput = input.target;
+    const target = (0, import_service_utils.buildDefinedPayload)({
+      uid: this.normalizeExportBlueprintLocatorValue(targetInput.uid, "uid"),
+      pageSchemaUid: this.normalizeExportBlueprintLocatorValue(targetInput.pageSchemaUid, "pageSchemaUid"),
+      tabSchemaUid: this.normalizeExportBlueprintLocatorValue(targetInput.tabSchemaUid, "tabSchemaUid"),
+      routeId: this.normalizeExportBlueprintLocatorValue(targetInput.routeId, "routeId")
+    });
+    const unsupportedTargetKeys = Object.keys(targetInput).filter(
+      (key) => !["uid", "pageSchemaUid", "tabSchemaUid", "routeId"].includes(key)
+    );
+    if (unsupportedTargetKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint target only accepts uid, pageSchemaUid, tabSchemaUid or routeId`);
+    }
+    if (!Object.keys(target).length) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces exportBlueprint target requires one of uid, pageSchemaUid, tabSchemaUid or routeId`
+      );
+    }
+    if (Object.keys(target).length > 1) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces exportBlueprint target only accepts exactly one locator: uid, pageSchemaUid, tabSchemaUid or routeId`
+      );
+    }
+    if (target.tabSchemaUid) {
+      (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+    }
+    return {
+      target,
+      unsupportedPolicy: this.normalizeExportBlueprintUnsupportedPolicy(input.options)
+    };
+  }
+  normalizeExportBlueprintUnsupportedPolicy(input) {
+    if (import_lodash.default.isUndefined(input)) {
+      return "error";
+    }
+    if (!import_lodash.default.isPlainObject(input)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint options must be an object`);
+    }
+    const options = input;
+    const unsupportedKeys = Object.keys(options).filter((key) => key !== "unsupported");
+    if (unsupportedKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint options only accepts unsupported`);
+    }
+    const policy = options.unsupported;
+    if (import_lodash.default.isUndefined(policy)) {
+      return "error";
+    }
+    if (policy === "error" || policy === "warn") {
+      return policy;
+    }
+    (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint options.unsupported must be 'error' or 'warn'`);
+  }
+  normalizeExportBlueprintLocatorValue(value, key) {
+    if (import_lodash.default.isNil(value)) {
+      return void 0;
+    }
+    if (typeof value !== "string" && typeof value !== "number") {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint target.${key} must be a string`);
+    }
+    const normalized = String(value).trim();
+    return normalized || void 0;
+  }
+  readRouteString(route, key) {
+    var _a;
+    const routeRecord = route;
+    const value = ((_a = routeRecord == null ? void 0 : routeRecord.get) == null ? void 0 : _a.call(routeRecord, key)) ?? (routeRecord == null ? void 0 : routeRecord[key]);
+    const normalized = typeof value === "string" ? value.trim() : "";
+    return normalized || void 0;
+  }
+  resolveExportBlueprintPageSchemaUid(target, resolved) {
+    const pageSchemaUid = this.readRouteString(resolved.pageRoute, "schemaUid") || (target.pageSchemaUid ? String(target.pageSchemaUid).trim() : "");
+    if (!pageSchemaUid) {
+      (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+    }
+    return pageSchemaUid;
+  }
+  async assertExportBlueprintRootTarget(target, resolved, pageSchemaUid, transaction) {
+    const targetUid = target.uid ? String(target.uid).trim() : "";
+    if (!targetUid) {
+      return;
+    }
+    if (targetUid === pageSchemaUid) {
+      return;
+    }
+    const rootPageModel = await this.repository.findModelByParentId(pageSchemaUid, {
+      transaction,
+      subKey: "page",
+      includeAsyncNode: false
+    });
+    if ((rootPageModel == null ? void 0 : rootPageModel.uid) && targetUid === String(rootPageModel.uid).trim()) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+  }
   normalizeContextPath(path) {
     if (import_lodash.default.isUndefined(path) || import_lodash.default.isNull(path)) {
       return void 0;
@@ -16860,13 +17827,20 @@ class FlowSurfacesService {
           description: changes.description,
           className: changes.className
         }),
-        stepParams: (0, import_service_utils.hasDefinedValue)(changes, ["code", "version"]) ? {
-          jsSettings: {
-            runJs: (0, import_service_utils.buildDefinedPayload)({
-              code: changes.code,
-              version: changes.version
-            })
-          }
+        stepParams: (0, import_service_utils.hasDefinedValue)(changes, ["code", "version", "showBlockCard"]) ? {
+          jsSettings: (0, import_service_utils.buildDefinedPayload)({
+            ...(0, import_service_utils.hasDefinedValue)(changes, ["code", "version"]) ? {
+              runJs: (0, import_service_utils.buildDefinedPayload)({
+                code: changes.code,
+                version: changes.version
+              })
+            } : {},
+            ...(0, import_service_utils.hasOwnDefined)(changes, "showBlockCard") ? {
+              showBlockCard: {
+                showBlockCard: changes.showBlockCard
+              }
+            } : {}
+          })
         } : void 0
       },
       options
@@ -17448,19 +18422,21 @@ class FlowSurfacesService {
     }
     return JSON.stringify(value);
   }
-  buildAIEmployeeActionDedupIdentity(values) {
+  buildAIEmployeeActionDedupIdentity(values, defaultActionWorkContext) {
     var _a, _b, _c, _d, _e, _f;
     const username = String(((_b = (_a = values == null ? void 0 : values.props) == null ? void 0 : _a.aiEmployee) == null ? void 0 : _b.username) || "").trim();
     if (!username) {
       return "";
     }
+    const workContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_d = (_c = values == null ? void 0 : values.props) == null ? void 0 : _c.context) == null ? void 0 : _d.workContext,
+      defaultActionWorkContext
+    );
     return this.stableSerializeAIEmployeeValue({
       username,
-      auto: typeof ((_c = values == null ? void 0 : values.props) == null ? void 0 : _c.auto) === "boolean" ? values.props.auto : false,
-      workContext: this.normalizeAIEmployeeWorkContextForDedupIdentity((_e = (_d = values == null ? void 0 : values.props) == null ? void 0 : _d.context) == null ? void 0 : _e.workContext),
-      tasks: this.normalizeAIEmployeeTasksForDedupIdentity(
-        import_lodash.default.get(values, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])
-      ),
+      auto: typeof ((_e = values == null ? void 0 : values.props) == null ? void 0 : _e.auto) === "boolean" ? values.props.auto : false,
+      workContext,
+      tasks: this.normalizeAIEmployeeTasksForDedupIdentity(this.readAIEmployeePersistedTasks(values), workContext),
       style: {
         ...AI_EMPLOYEE_DEFAULT_STYLE,
         ...import_lodash.default.isPlainObject((_f = values == null ? void 0 : values.props) == null ? void 0 : _f.style) ? import_lodash.default.pick(values.props.style, AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
@@ -17468,11 +18444,35 @@ class FlowSurfacesService {
     });
   }
   normalizeAIEmployeeWorkContextForDedupIdentity(value) {
-    return import_lodash.default.castArray(value || []).map(
-      (item) => import_lodash.default.isPlainObject(item) ? import_lodash.default.pick(item, AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS) : item
-    );
+    return import_lodash.default.castArray(value || []).map((item) => {
+      if (!import_lodash.default.isPlainObject(item)) {
+        return item;
+      }
+      const output = import_lodash.default.pick(item, AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS);
+      if (!Object.prototype.hasOwnProperty.call(output, "type") || import_lodash.default.isUndefined(output.type) || output.type === null) {
+        output.type = "flow-model";
+      }
+      return output;
+    });
+  }
+  normalizeAIEmployeeActionWorkContextForDedupIdentity(value, defaultWorkContext) {
+    if (!Array.isArray(value)) {
+      return import_lodash.default.cloneDeep(defaultWorkContext || []);
+    }
+    return this.normalizeAIEmployeeWorkContextForDedupIdentity(value);
   }
-  normalizeAIEmployeeTasksForDedupIdentity(value) {
+  normalizeAIEmployeeDefaultActionWorkContextForSelfUid(selfUid) {
+    const uid2 = String(selfUid || "").trim();
+    return uid2 ? [{ type: "flow-model", uid: uid2 }] : [];
+  }
+  normalizeAIEmployeeTaskWorkContextForDedupIdentity(value, defaultWorkContext) {
+    const normalized = this.normalizeAIEmployeeWorkContextForDedupIdentity(value);
+    if (Array.isArray(defaultWorkContext) && !normalized.length) {
+      return import_lodash.default.cloneDeep(defaultWorkContext);
+    }
+    return normalized;
+  }
+  normalizeAIEmployeeTasksForDedupIdentity(value, defaultWorkContext) {
     return import_lodash.default.castArray(value || []).map((task) => {
       if (!import_lodash.default.isPlainObject(task)) {
         return task;
@@ -17481,9 +18481,19 @@ class FlowSurfacesService {
       if (import_lodash.default.isPlainObject(output.message)) {
         output.message = import_lodash.default.pick(output.message, AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS);
         if (Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
-          output.message.workContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(output.message.workContext);
+          output.message.workContext = this.normalizeAIEmployeeTaskWorkContextForDedupIdentity(
+            output.message.workContext,
+            defaultWorkContext
+          );
         }
       }
+      if (!import_lodash.default.isPlainObject(output.message) && Array.isArray(defaultWorkContext)) {
+        output.message = {
+          workContext: import_lodash.default.cloneDeep(defaultWorkContext)
+        };
+      } else if (import_lodash.default.isPlainObject(output.message) && !Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
+        output.message.workContext = import_lodash.default.cloneDeep(defaultWorkContext || []);
+      }
       if (import_lodash.default.isPlainObject(output.model)) {
         output.model = import_lodash.default.pick(output.model, AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS);
       }
@@ -17493,25 +18503,38 @@ class FlowSurfacesService {
       return output;
     });
   }
-  async assertNoDuplicateAIEmployeeAction(actionName, parentUid, values, transaction) {
+  async assertNoDuplicateAIEmployeeAction(actionName, parentUid, values, transaction, excludeUid) {
     var _a;
-    const identity = this.buildAIEmployeeActionDedupIdentity(values);
-    if (!identity) {
-      return;
-    }
     const parentNode = await this.repository.findModelById(parentUid, {
       transaction,
       includeAsyncNode: true
     });
-    const duplicate = import_lodash.default.castArray(((_a = parentNode == null ? void 0 : parentNode.subModels) == null ? void 0 : _a.actions) || []).find((action) => {
+    const defaultActionWorkContext = this.normalizeAIEmployeeDefaultActionWorkContextForSelfUid(
+      await this.resolveAIEmployeeActionSelfUidFromParentNode(parentNode, transaction)
+    );
+    const identity = this.buildAIEmployeeActionDedupIdentity(values, defaultActionWorkContext);
+    if (!identity) {
+      return;
+    }
+    let duplicate;
+    for (const action of import_lodash.default.castArray(((_a = parentNode == null ? void 0 : parentNode.subModels) == null ? void 0 : _a.actions) || [])) {
       if (!this.isAIEmployeeActionUse(action == null ? void 0 : action.use)) {
-        return false;
+        continue;
       }
-      return this.buildAIEmployeeActionDedupIdentity({
-        props: action.props,
-        stepParams: action.stepParams
-      }) === identity;
-    });
+      if (excludeUid && String((action == null ? void 0 : action.uid) || "") === excludeUid) {
+        continue;
+      }
+      if (this.buildAIEmployeeActionDedupIdentity(
+        {
+          props: action.props,
+          stepParams: action.stepParams
+        },
+        defaultActionWorkContext
+      ) === identity) {
+        duplicate = action;
+        break;
+      }
+    }
     if (!(duplicate == null ? void 0 : duplicate.uid)) {
       return;
     }
@@ -17526,6 +18549,25 @@ class FlowSurfacesService {
       }
     );
   }
+  async assertNoDuplicateAIEmployeeActionForUpdateSettings(actionName, current, effectiveNode, transaction) {
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
+      return;
+    }
+    const parentUid = String((current == null ? void 0 : current.parentId) || "").trim() || ((current == null ? void 0 : current.uid) ? await this.locator.findParentUid(current.uid, transaction).catch(() => "") : "");
+    if (!parentUid) {
+      return;
+    }
+    await this.assertNoDuplicateAIEmployeeAction(
+      actionName,
+      parentUid,
+      {
+        props: effectiveNode == null ? void 0 : effectiveNode.props,
+        stepParams: effectiveNode == null ? void 0 : effectiveNode.stepParams
+      },
+      transaction,
+      String((current == null ? void 0 : current.uid) || "")
+    );
+  }
   hasAIEmployeePublicSettings(settings) {
     return import_lodash.default.isPlainObject(settings) && AI_EMPLOYEE_PUBLIC_SETTING_KEYS.some((key) => Object.prototype.hasOwnProperty.call(settings, key));
   }
@@ -17580,11 +18622,24 @@ class FlowSurfacesService {
     var _a;
     const stepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
     if (Array.isArray(stepTasks)) {
-      return stepTasks;
+      return this.normalizeAIEmployeeLegacyInheritedTaskWorkContext(stepTasks);
     }
-    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    const legacyPropsTasks = this.normalizeAIEmployeeLegacyInheritedTaskWorkContext((_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks);
     return Array.isArray(legacyPropsTasks) ? legacyPropsTasks : [];
   }
+  normalizeAIEmployeeLegacyInheritedTaskWorkContext(tasks) {
+    if (!Array.isArray(tasks)) {
+      return tasks;
+    }
+    return tasks.map((task) => {
+      if (!import_lodash.default.isPlainObject(task) || !import_lodash.default.isPlainObject(task.message) || task.message.workContext !== null) {
+        return task;
+      }
+      const nextTask = import_lodash.default.cloneDeep(task);
+      delete nextTask.message.workContext;
+      return nextTask;
+    });
+  }
   buildAIEmployeeTaskStepParams(tasks) {
     const stepParams = {};
     import_lodash.default.set(stepParams, AI_EMPLOYEE_TASK_STEP_PARAMS_PATH, import_lodash.default.cloneDeep(tasks));
@@ -17613,7 +18668,7 @@ class FlowSurfacesService {
     if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
       return;
     }
-    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    const legacyPropsTasks = this.normalizeAIEmployeeLegacyInheritedTaskWorkContext((_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks);
     const hasLegacyPropsTasks = Array.isArray(legacyPropsTasks);
     const hasNextStepTasks = import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
     const currentStepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
@@ -17785,6 +18840,20 @@ class FlowSurfacesService {
       };
     });
   }
+  normalizeAIEmployeeEffectiveActionWorkContext(actionName, settings, currentProps, options) {
+    var _a;
+    const hasSettingsWorkContext = Object.prototype.hasOwnProperty.call(settings, "workContext");
+    const currentWorkContext = (_a = currentProps == null ? void 0 : currentProps.context) == null ? void 0 : _a.workContext;
+    if (!hasSettingsWorkContext && !Array.isArray(currentWorkContext) && !options.requireUsername && !options.selfUid) {
+      return void 0;
+    }
+    const rawWorkContext = hasSettingsWorkContext ? settings.workContext : Array.isArray(currentWorkContext) ? currentWorkContext : [{ type: "flow-model", target: "self" }];
+    return this.normalizeAIEmployeeWorkContext(actionName, rawWorkContext, {
+      selfUid: options.selfUid,
+      keyMap: options.keyMap,
+      path: "settings.workContext"
+    });
+  }
   normalizeAIEmployeeTaskModel(actionName, path, value) {
     if (import_lodash.default.isUndefined(value) || value === null) {
       return value;
@@ -18100,6 +19169,7 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     );
   }
   async normalizeAIEmployeeStepParamTasksForUpdateSettings(current, nextPayload, writeTarget, options) {
+    var _a, _b, _c, _d;
     if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use) || !import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])) {
       return;
     }
@@ -18108,15 +19178,63 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       return;
     }
     const actionName = options.openViewActionName || "updateSettings";
-    const normalizedTasks = this.normalizeAIEmployeeTasks(
+    const selfUid = await this.resolveAIEmployeeActionSelfUid(current || { uid: writeTarget.uid }, options.transaction);
+    const currentPropsForDefault = import_lodash.default.mergeWith(
+      {},
+      import_lodash.default.isPlainObject(current == null ? void 0 : current.props) ? current.props : {},
+      import_lodash.default.isPlainObject(nextPayload.props) ? nextPayload.props : {},
+      (_currentValue, nextValue) => {
+        if (Array.isArray(nextValue)) {
+          return import_lodash.default.cloneDeep(nextValue);
+        }
+        return void 0;
+      }
+    );
+    const defaultWorkContext = this.normalizeAIEmployeeEffectiveActionWorkContext(
       actionName,
-      tasks,
-      this.readAIEmployeePersistedTasks(current),
+      {},
+      currentPropsForDefault,
       {
-        selfUid: await this.resolveAIEmployeeActionSelfUid(current || { uid: writeTarget.uid }, options.transaction),
-        path: "stepParams.shortcutSettings.editTasks.tasks"
+        selfUid,
+        requireUsername: true
       }
     );
+    const currentTasks = this.readAIEmployeePersistedTasks(current);
+    const previousActionWorkContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_b = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.context) == null ? void 0 : _b.workContext,
+      this.normalizeAIEmployeeDefaultActionWorkContextForSelfUid(selfUid)
+    );
+    const nextActionWorkContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_c = currentPropsForDefault == null ? void 0 : currentPropsForDefault.context) == null ? void 0 : _c.workContext,
+      defaultWorkContext
+    );
+    if (Array.isArray(defaultWorkContext) && !import_lodash.default.isEqual((_d = currentPropsForDefault == null ? void 0 : currentPropsForDefault.context) == null ? void 0 : _d.workContext, defaultWorkContext)) {
+      nextPayload.props = import_lodash.default.mergeWith(
+        {},
+        currentPropsForDefault,
+        {
+          context: {
+            workContext: import_lodash.default.cloneDeep(defaultWorkContext)
+          }
+        },
+        (_currentValue, nextValue) => {
+          if (Array.isArray(nextValue)) {
+            return import_lodash.default.cloneDeep(nextValue);
+          }
+          return void 0;
+        }
+      );
+    }
+    const currentTasksForNormalization = this.rebaseAIEmployeeInheritedTaskWorkContext(
+      currentTasks,
+      previousActionWorkContext,
+      nextActionWorkContext
+    );
+    const normalizedTasks = this.normalizeAIEmployeeTasks(actionName, tasks, currentTasksForNormalization, {
+      selfUid,
+      defaultWorkContext,
+      path: "stepParams.shortcutSettings.editTasks.tasks"
+    });
     import_lodash.default.set(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH], normalizedTasks);
   }
   normalizeAIEmployeeTaskMessage(actionName, path, value, existing, options) {
@@ -18145,13 +19263,18 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     if (Object.prototype.hasOwnProperty.call(nextMessage, "user") && typeof nextMessage.user !== "string") {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.user must be a string`);
     }
-    if (Object.prototype.hasOwnProperty.call(value, "workContext")) {
+    if (value.workContext === null) {
+      delete nextMessage.workContext;
+    } else if (Object.prototype.hasOwnProperty.call(value, "workContext")) {
       nextMessage.workContext = this.normalizeAIEmployeeWorkContext(actionName, value.workContext, {
         selfUid: options.selfUid,
         keyMap: options.keyMap,
         path: `${path}.workContext`
       });
     }
+    if (!Object.prototype.hasOwnProperty.call(nextMessage, "workContext") && this.shouldMaterializeAIEmployeeTaskDefaultWorkContext(options.defaultWorkContext)) {
+      nextMessage.workContext = import_lodash.default.cloneDeep(options.defaultWorkContext);
+    }
     return nextMessage;
   }
   normalizeAIEmployeeTaskPatch(actionName, patch, existing, options) {
@@ -18175,7 +19298,8 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       if (key === "message") {
         next.message = this.normalizeAIEmployeeTaskMessage(actionName, `${options.path}.message`, value, next.message, {
           selfUid: options.selfUid,
-          keyMap: options.keyMap
+          keyMap: options.keyMap,
+          defaultWorkContext: options.defaultWorkContext
         });
         return;
       }
@@ -18225,6 +19349,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     if (!import_lodash.default.isPlainObject(next.message)) {
       next.message = {};
     }
+    if (!Object.prototype.hasOwnProperty.call(next.message, "workContext") && this.shouldMaterializeAIEmployeeTaskDefaultWorkContext(options.defaultWorkContext)) {
+      next.message.workContext = import_lodash.default.cloneDeep(options.defaultWorkContext);
+    }
     if (import_lodash.default.isPlainObject(next.skillSettings)) {
       if (Array.isArray(next.skillSettings.skills) && !Object.prototype.hasOwnProperty.call(next.skillSettings, "skillsVersion")) {
         next.skillSettings.skillsVersion = 2;
@@ -18251,10 +19378,52 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       nextTasks[index] = this.normalizeAIEmployeeTaskPatch(actionName, task, existingTasks[index], {
         selfUid: options.selfUid,
         keyMap: options.keyMap,
-        path: `${options.path}[${index}]`
+        path: `${options.path}[${index}]`,
+        defaultWorkContext: options.defaultWorkContext
       });
     });
-    return nextTasks;
+    return this.withAIEmployeeTaskDefaultWorkContext(nextTasks, options.defaultWorkContext);
+  }
+  withAIEmployeeTaskDefaultWorkContext(tasks, defaultWorkContext) {
+    const nextTasks = Array.isArray(tasks) ? import_lodash.default.cloneDeep(tasks) : [];
+    if (!this.shouldMaterializeAIEmployeeTaskDefaultWorkContext(defaultWorkContext)) {
+      return nextTasks;
+    }
+    return nextTasks.map((task) => {
+      if (!import_lodash.default.isPlainObject(task)) {
+        return task;
+      }
+      const nextTask = import_lodash.default.cloneDeep(task);
+      if (!import_lodash.default.isPlainObject(nextTask.message)) {
+        nextTask.message = {
+          workContext: import_lodash.default.cloneDeep(defaultWorkContext)
+        };
+      } else if (!Object.prototype.hasOwnProperty.call(nextTask.message, "workContext")) {
+        nextTask.message.workContext = import_lodash.default.cloneDeep(defaultWorkContext);
+      }
+      return nextTask;
+    });
+  }
+  shouldMaterializeAIEmployeeTaskDefaultWorkContext(defaultWorkContext) {
+    return Array.isArray(defaultWorkContext) && defaultWorkContext.length > 0;
+  }
+  rebaseAIEmployeeInheritedTaskWorkContext(currentTasks, previousActionWorkContext, nextActionWorkContext) {
+    const tasks = this.normalizeAIEmployeeLegacyInheritedTaskWorkContext(currentTasks) || [];
+    if (!previousActionWorkContext.length || import_lodash.default.isEqual(previousActionWorkContext, nextActionWorkContext)) {
+      return tasks;
+    }
+    return tasks.map((task) => {
+      const nextTask = import_lodash.default.cloneDeep(task);
+      if (import_lodash.default.isPlainObject(nextTask == null ? void 0 : nextTask.message)) {
+        const currentTaskWorkContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(
+          nextTask.message.workContext
+        );
+        if (import_lodash.default.isEqual(currentTaskWorkContext, previousActionWorkContext)) {
+          delete nextTask.message.workContext;
+        }
+      }
+      return nextTask;
+    });
   }
   normalizeAIEmployeeActionSettingsReferences(actionName, settings, options) {
     if (!this.hasAIEmployeePublicSettings(settings)) {
@@ -18268,15 +19437,22 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       });
     }
     if (Object.prototype.hasOwnProperty.call(nextSettings, "tasks")) {
+      const defaultWorkContext = this.normalizeAIEmployeeEffectiveActionWorkContext(
+        actionName,
+        nextSettings,
+        {},
+        options
+      );
       nextSettings.tasks = this.normalizeAIEmployeeTasks(actionName, nextSettings.tasks, [], {
         ...options,
-        path: "settings.tasks"
+        path: "settings.tasks",
+        defaultWorkContext
       });
     }
     return nextSettings;
   }
   async normalizeAIEmployeeActionPublicSettings(actionName, settings, options) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     this.assertAIEmployeePluginEnabled(actionName, options.enabledPackages);
     if (!import_lodash.default.isPlainObject(settings)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} AI employee settings must be an object`);
@@ -18296,6 +19472,17 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     }
     const props = {};
     const stepParams = {};
+    const effectiveActionWorkContext = this.normalizeAIEmployeeEffectiveActionWorkContext(
+      actionName,
+      settings,
+      currentProps,
+      options
+    );
+    const previousActionWorkContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_c = currentProps == null ? void 0 : currentProps.context) == null ? void 0 : _c.workContext,
+      this.normalizeAIEmployeeDefaultActionWorkContextForSelfUid(options.selfUid)
+    );
+    const nextActionWorkContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(effectiveActionWorkContext);
     if (effectiveUsername && (hasUsername || options.requireUsername)) {
       props.aiEmployee = {
         ...import_lodash.default.isPlainObject(currentProps.aiEmployee) ? import_lodash.default.cloneDeep(currentProps.aiEmployee) : {},
@@ -18309,28 +19496,25 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       }
       props.auto = auto;
     }
-    if (Object.prototype.hasOwnProperty.call(settings, "workContext") || options.requireUsername) {
-      const rawWorkContext = Object.prototype.hasOwnProperty.call(settings, "workContext") ? settings.workContext : [{ type: "flow-model", target: "self" }];
+    if (Array.isArray(effectiveActionWorkContext) && (Object.prototype.hasOwnProperty.call(settings, "workContext") || options.requireUsername || !import_lodash.default.isEqual((_d = currentProps == null ? void 0 : currentProps.context) == null ? void 0 : _d.workContext, effectiveActionWorkContext))) {
       props.context = {
         ...import_lodash.default.isPlainObject(currentProps.context) ? import_lodash.default.cloneDeep(currentProps.context) : {},
-        workContext: this.normalizeAIEmployeeWorkContext(actionName, rawWorkContext, {
-          selfUid: options.selfUid,
-          keyMap: options.keyMap,
-          path: "settings.workContext"
-        })
+        workContext: import_lodash.default.cloneDeep(effectiveActionWorkContext)
       };
     }
     if (Object.prototype.hasOwnProperty.call(settings, "tasks")) {
-      const normalizedTasks = this.normalizeAIEmployeeTasks(
-        actionName,
-        settings.tasks,
-        this.readAIEmployeePersistedTasks(options.current),
-        {
-          selfUid: options.selfUid,
-          keyMap: options.keyMap,
-          path: "settings.tasks"
-        }
+      const currentTasks = this.readAIEmployeePersistedTasks(options.current);
+      const currentTasksForNormalization = this.rebaseAIEmployeeInheritedTaskWorkContext(
+        currentTasks,
+        previousActionWorkContext,
+        nextActionWorkContext
       );
+      const normalizedTasks = this.normalizeAIEmployeeTasks(actionName, settings.tasks, currentTasksForNormalization, {
+        selfUid: options.selfUid,
+        keyMap: options.keyMap,
+        path: "settings.tasks",
+        defaultWorkContext: effectiveActionWorkContext
+      });
       const validation = options.promptContext && normalizedTasks.length ? await this.buildAIEmployeePromptValidationContext(
         actionName,
         [
@@ -18351,6 +19535,17 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       const tasks = this.appendAIEmployeeCurrentRecordPromptVariableToTasks(normalizedTasks, validation);
       this.assertAIEmployeeTaskPromptVariablesAllowed(actionName, tasks, validation);
       import_lodash.default.merge(stepParams, this.buildAIEmployeeTaskStepParams(tasks));
+    } else if (!options.skipExistingTaskWorkContextRebase && Object.prototype.hasOwnProperty.call(settings, "workContext") && !import_lodash.default.isEqual(previousActionWorkContext, nextActionWorkContext)) {
+      const currentTasks = this.readAIEmployeePersistedTasks(options.current);
+      const rebasedTasks = this.rebaseAIEmployeeInheritedTaskWorkContext(
+        currentTasks,
+        previousActionWorkContext,
+        nextActionWorkContext
+      );
+      const tasks = this.withAIEmployeeTaskDefaultWorkContext(rebasedTasks, effectiveActionWorkContext);
+      if (tasks.length) {
+        import_lodash.default.merge(stepParams, this.buildAIEmployeeTaskStepParams(tasks));
+      }
     }
     if (Object.prototype.hasOwnProperty.call(settings, "style") || options.requireUsername) {
       const style = Object.prototype.hasOwnProperty.call(settings, "style") ? settings.style : {};
@@ -18392,7 +19587,16 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       transaction,
       includeAsyncNode: true
     });
-    if (["TableActionsColumnModel", "ListItemModel", "GridCardItemModel"].includes(String((parentNode == null ? void 0 : parentNode.use) || ""))) {
+    return await this.resolveAIEmployeeActionSelfUidFromParentNode(parentNode, transaction) || parentUid;
+  }
+  async resolveAIEmployeeActionSelfUidFromParentNode(parentNode, transaction) {
+    const parentUid = String((parentNode == null ? void 0 : parentNode.uid) || "").trim();
+    if (!parentUid) {
+      return "";
+    }
+    if (["TableActionsColumnModel", "ListItemModel", "GridCardItemModel", "CommentItemModel"].includes(
+      String((parentNode == null ? void 0 : parentNode.use) || "")
+    )) {
       const ownerUid = String((parentNode == null ? void 0 : parentNode.parentId) || "").trim() || ((parentNode == null ? void 0 : parentNode.uid) ? await this.locator.findParentUid(parentNode.uid, transaction).catch(() => "") : "");
       return ownerUid || parentUid;
     }
@@ -18441,13 +19645,14 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     }
     const normalizedDefaultFilter = (0, import_service_utils.hasOwnDefined)(changes, "defaultFilter") ? this.normalizeFilterActionDefaultFilterValue(changes.defaultFilter) : void 0;
     const stepParams = {};
-    if ((0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "type", "danger", "color", "linkageRules"])) {
+    if ((0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "iconOnly", "type", "danger", "color", "linkageRules"])) {
       stepParams.buttonSettings = {
-        ...(0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "type", "danger", "color"]) ? {
+        ...(0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "iconOnly", "type", "danger", "color"]) ? {
           general: (0, import_service_utils.buildDefinedPayload)({
             title: changes.title,
             tooltip: changes.tooltip,
             icon: changes.icon,
+            iconOnly: changes.iconOnly,
             type: changes.type,
             danger: changes.danger,
             color: changes.color
@@ -18657,6 +19862,7 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       title: changes.title,
       tooltip: changes.tooltip,
       icon: changes.icon,
+      iconOnly: changes.iconOnly,
       type: changes.type,
       htmlType: changes.htmlType,
       position: changes.position,
@@ -18786,6 +19992,11 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       useStrictOnly: input.useStrictOnly
     });
   }
+  isCollectionTitleField(collection, fieldName) {
+    const normalizedFieldName = String(fieldName || "").trim();
+    const titleFieldName = String((0, import_service_helpers.getCollectionTitleFieldName)(collection) || "").trim();
+    return !!normalizedFieldName && normalizedFieldName === titleFieldName;
+  }
   resolveAssociationLeafDisplaySemantics(field, dataSourceKey, enabledPackages) {
     const registeredBinding = this.resolveRegisteredFieldBinding({
       containerUse: "DetailsItemModel",
@@ -18821,6 +20032,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
   }
   buildFieldMenuDirectCandidates(input) {
     const collection = this.getCollection(input.resourceInit.dataSourceKey, input.resourceInit.collectionName);
+    const explicitDefaultFieldPaths = (0, import_default_action_popup.collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths)(
+      input.defaultFieldGroups
+    );
     return (0, import_service_helpers.getCollectionFields)(collection).flatMap((field) => {
       var _a;
       const fieldName = (0, import_service_helpers.getFieldName)(field);
@@ -18831,6 +20045,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       if (input.generatedPopupOnly && !(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupBusinessField)(field)) {
         return [];
       }
+      if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(collection, field) && !explicitDefaultFieldPaths.has(fieldName)) {
+        return [];
+      }
       if (input.mode === "table" && ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.treeChildren)) {
         return [];
       }
@@ -18918,6 +20135,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
         if (!targetFieldName) {
           continue;
         }
+        if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(targetCollection, targetField) && !this.isCollectionTitleField(targetCollection, targetFieldName)) {
+          continue;
+        }
         nextCandidates.push({
           field: targetField,
           fieldPath: `${associationPathName}.${targetFieldName}`,
@@ -19092,7 +20312,7 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     const getFields = (targetCollection) => (0, import_service_helpers.getCollectionFields)(targetCollection);
     const isFilterFieldVisible = (field) => (0, import_service_helpers.getFieldFilterable)(field) !== false && !!(0, import_service_helpers.getFieldInterface)(field);
     const directFields = getFields(collection).filter(
-      (field) => ["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(field) : !!(0, import_service_helpers.getFieldInterface)(field)
+      (field) => !(0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(collection, field) && (["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(field) : !!(0, import_service_helpers.getFieldInterface)(field))
     );
     if (!directFields.length && !collection) {
       return [];
@@ -19106,9 +20326,13 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       if (!(0, import_service_helpers.isAssociationField)(field) || !targetCollection) {
         return [];
       }
-      return getFields(targetCollection).filter(
-        (targetField) => ["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(targetField) : !!(0, import_service_helpers.getFieldInterface)(targetField)
-      ).map((targetField) => ({
+      return getFields(targetCollection).filter((targetField) => {
+        const targetFieldName = (0, import_service_helpers.getFieldName)(targetField);
+        if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(targetCollection, targetField) && !this.isCollectionTitleField(targetCollection, targetFieldName)) {
+          return false;
+        }
+        return ["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(targetField) : !!(0, import_service_helpers.getFieldInterface)(targetField);
+      }).map((targetField) => ({
         field: targetField,
         fieldPath: `${(0, import_service_helpers.getFieldName)(field)}.${(0, import_service_helpers.getFieldName)(targetField)}`,
         associationPathName: (0, import_service_helpers.getFieldName)(field),