@nocobase/plugin-flow-engine 2.2.0-beta.9 → 3.0.0-alpha.1

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

@@ -66,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");
@@ -689,7 +690,6 @@ function assertNoFlowSurfaceIdTitleFieldSettings(value, options = {}) {
   };
   visit(value, options.basePath || []);
 }
-const DEFAULT_ADMIN_UI_LAYOUT_UID = "admin-layout-model";
 const MOBILE_UI_LAYOUT_TYPE = "mobile";
 class FlowSurfacesService {
   constructor(plugin) {
@@ -711,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");
@@ -924,7 +927,7 @@ class FlowSurfacesService {
       transaction
     });
   }
-  async findMenuGroupRoutesByTitle(title, transaction, layoutUid) {
+  async findMenuGroupRoutesByTitle(title, transaction, layoutUid, portalUid) {
     const normalizedTitle = String(title || "").trim();
     if (!normalizedTitle) {
       return [];
@@ -938,6 +941,20 @@ 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;
@@ -957,13 +974,13 @@ class FlowSurfacesService {
     }
     return String(routeParentId ?? "") === String(parentId ?? "");
   }
-  async findMenuGroupRoutesByParentIdAndTitle(parentId, title, transaction, layoutUid) {
-    const routes = await this.findMenuGroupRoutesByTitle(title, transaction, layoutUid);
+  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, layoutUid) {
+  async findFlowPageRoutesByParentIdAndTitle(parentId, title, transaction, layoutUid, portalUid) {
     const normalizedTitle = String(title || "").trim();
     if (!normalizedTitle) {
       return [];
@@ -978,6 +995,22 @@ class FlowSurfacesService {
         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()) {
@@ -1091,12 +1124,12 @@ class FlowSurfacesService {
     }
     const defaultLayout = await this.db.getRepository("uiLayouts").findOne({
       filter: {
-        uid: DEFAULT_ADMIN_UI_LAYOUT_UID,
+        uid: import_navigation_targets.DEFAULT_ADMIN_UI_LAYOUT_UID,
         enabled: true
       },
       transaction
     });
-    return defaultLayout ? [DEFAULT_ADMIN_UI_LAYOUT_UID] : [];
+    return defaultLayout ? [import_navigation_targets.DEFAULT_ADMIN_UI_LAYOUT_UID] : [];
   }
   async findDesktopRouteUiLayoutByUid(layoutUid, transaction) {
     const normalizedLayoutUid = this.normalizeExplicitDesktopRouteLayoutUid(layoutUid);
@@ -1147,6 +1180,289 @@ class FlowSurfacesService {
     }
     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)
+    };
+  }
+  buildDesktopRouteScopeForPortal(portal) {
+    return {
+      portalUids: portal.routeScopeKind === "portal" ? [portal.uid] : [],
+      layoutUids: portal.routeScopeKind === "layout" ? [portal.layoutUid] : [],
+      selectedPortal: portal,
+      layoutType: portal.layoutType
+    };
+  }
+  assertAdminLayoutCreateScope(actionName, scope, path) {
+    if (!this.navigationTargets.hasMultiPortalCapability() || scope.selectedPortal || !scope.layoutUids.includes(import_navigation_targets.DEFAULT_ADMIN_UI_LAYOUT_UID)) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} cannot create navigation directly in the Admin layout`, {
+      ruleId: "navigation-admin-layout-not-portal-target",
+      path,
+      details: {
+        layoutUid: import_navigation_targets.DEFAULT_ADMIN_UI_LAYOUT_UID,
+        uiBuilderAllowed: false,
+        adminLayoutFallbackAllowed: false,
+        agentInstruction: "Resolve the target Portal first. For a no-code Portal, pass portalUid (navigation.portalUid in applyBlueprint); for an AI Portal, stop this Flow Surfaces write and implement the request in the Portal source code."
+      }
+    });
+  }
+  getPortalRouteFilterUid(portal) {
+    return (portal == null ? void 0 : portal.routeScopeKind) === "portal" ? portal.uid : void 0;
+  }
+  async assertRouteBelongsToResolvedPortal(actionName, route, portal, path, transaction) {
+    if (portal.routeScopeKind === "layout") {
+      await this.assertDesktopRouteBelongsToUiLayout(actionName, route, portal.layoutUid, path, transaction);
+      return;
+    }
+    await this.navigationTargets.assertRouteBelongsToPortal(
+      actionName,
+      this.readRouteField(route, "id"),
+      portal.uid,
+      path,
+      transaction
+    );
+  }
+  async resolveDefaultDesktopRouteScope(actionName, options = {}) {
+    if (this.navigationTargets.hasMultiPortalCapability()) {
+      const portal = await this.navigationTargets.resolveDefaultPortal({
+        actionName,
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      return this.buildDesktopRouteScopeForPortal(portal);
+    }
+    const layoutUids = await this.resolveDefaultDesktopRouteUiLayoutUids(options.transaction);
+    return {
+      portalUids: [],
+      layoutUids,
+      layoutType: layoutUids.length === 1 ? await this.getDesktopRouteUiLayoutTypeByUid(layoutUids[0], options.transaction) : void 0
+    };
+  }
+  async resolveDesktopRouteMatchScope(layoutUid, portalUid, actionName, options = {}) {
+    if (portalUid) {
+      const portal = await this.navigationTargets.resolvePortal(portalUid, {
+        actionName,
+        path: "values.navigation.portalUid",
+        currentRoles: options.currentRoles,
+        transaction: options.transaction
+      });
+      return {
+        layoutUids: portal.routeScopeKind === "layout" ? [portal.layoutUid] : void 0,
+        portalUid: this.getPortalRouteFilterUid(portal)
+      };
+    }
+    if (this.normalizeDesktopRouteLayoutUidFilter(layoutUid).length) {
+      return { layoutUids: layoutUid, portalUid: void 0 };
+    }
+    const defaultScope = await this.resolveDefaultDesktopRouteScope(actionName, options);
+    return {
+      layoutUids: defaultScope.layoutUids.length ? defaultScope.layoutUids : void 0,
+      portalUid: this.getPortalRouteFilterUid(defaultScope.selectedPortal)
+    };
+  }
+  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.assertRouteBelongsToResolvedPortal(
+          actionName,
+          parentRoute,
+          portal,
+          "values.parentMenuRouteId",
+          options.transaction
+        );
+      }
+      return this.buildDesktopRouteScopeForPortal(portal);
+    }
+    if (layoutUid) {
+      const scope2 = { portalUids: [], layoutUids: [layoutUid] };
+      this.assertAdminLayoutCreateScope(actionName, scope2, "values.layoutUid");
+      await this.assertEnabledDesktopRouteUiLayoutUid(layoutUid, actionName, "values.layoutUid", options.transaction);
+      if (parentRoute) {
+        await this.assertDesktopRouteBelongsToUiLayout(
+          actionName,
+          parentRoute,
+          layoutUid,
+          "values.parentMenuRouteId",
+          options.transaction
+        );
+      }
+      return {
+        ...scope2,
+        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
+        };
+      }
+    }
+    if (!parentRoute) {
+      return this.resolveDefaultDesktopRouteScope(actionName, options);
+    }
+    const layoutUids = await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, options.transaction);
+    const scope = {
+      portalUids: [],
+      layoutUids
+    };
+    this.assertAdminLayoutCreateScope(actionName, scope, "values.parentMenuRouteId");
+    return {
+      ...scope,
+      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.assertRouteBelongsToResolvedPortal(
+        actionName,
+        route,
+        portal,
+        "values.menuRouteId",
+        options.transaction
+      );
+      return this.buildDesktopRouteScopeForPortal(portal);
+    }
+    if (layoutUid) {
+      const scope2 = { ...routeScope, layoutUids: [layoutUid] };
+      this.assertAdminLayoutCreateScope(actionName, scope2, "values.layoutUid");
+      await this.assertEnabledDesktopRouteUiLayoutUid(layoutUid, actionName, "values.layoutUid", options.transaction);
+      await this.assertDesktopRouteBelongsToUiLayout(
+        actionName,
+        route,
+        layoutUid,
+        "values.menuRouteId",
+        options.transaction
+      );
+      return {
+        ...scope2,
+        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
+      };
+    }
+    let layoutUids = routeScope.layoutUids;
+    if (!layoutUids.length) {
+      const parentRouteId = this.readRouteField(route, "parentId");
+      const parentRoute = import_lodash.default.isNil(parentRouteId) ? null : await this.findMenuRouteById(parentRouteId, options.transaction);
+      layoutUids = await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, options.transaction);
+    }
+    const scope = {
+      portalUids: [],
+      layoutUids
+    };
+    this.assertAdminLayoutCreateScope(actionName, scope, "values.menuRouteId");
+    if (!routeScope.layoutUids.length) {
+      await this.setDesktopRouteUiLayouts(this.readRouteField(route, "id"), layoutUids, options.transaction);
+    }
+    return {
+      ...scope,
+      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`, {
@@ -1194,23 +1510,6 @@ class FlowSurfacesService {
       }
     });
   }
-  async resolveRequestedDesktopRouteUiLayoutUids(values, parentRoute, actionName, transaction) {
-    const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid(values.layoutUid);
-    if (layoutUid) {
-      await this.assertEnabledDesktopRouteUiLayoutUid(layoutUid, actionName, "values.layoutUid", transaction);
-      if (parentRoute) {
-        await this.assertDesktopRouteBelongsToUiLayout(
-          actionName,
-          parentRoute,
-          layoutUid,
-          "values.parentMenuRouteId",
-          transaction
-        );
-      }
-      return [layoutUid];
-    }
-    return this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction);
-  }
   async setDesktopRouteUiLayouts(routeId, uiLayoutUids, transaction) {
     const relationRouteId = this.normalizeDesktopRouteRelationId(routeId);
     if (import_lodash.default.isUndefined(relationRouteId) || !uiLayoutUids.length || !this.hasDesktopRouteUiLayoutsRelation()) {
@@ -1308,21 +1607,17 @@ class FlowSurfacesService {
       });
     }
   }
-  async createFlowMenuGroup(values, transaction) {
-    const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, transaction);
+  async createFlowMenuGroup(values, options = {}) {
+    const parentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
     const parentId = this.readRouteField(parentRoute, "id") ?? null;
-    const routeUiLayoutUids = await this.resolveRequestedDesktopRouteUiLayoutUids(
-      values,
-      parentRoute,
-      "createMenu",
-      transaction
-    );
+    const routeScope = await this.resolveRequestedDesktopRouteScope(values, parentRoute, "createMenu", options);
     const title = String(values.title || "").trim();
     const existingGroups = await this.findMenuGroupRoutesByParentIdAndTitle(
       parentId,
       title,
-      transaction,
-      routeUiLayoutUids
+      options.transaction,
+      routeScope.layoutUids,
+      this.getPortalRouteFilterUid(routeScope.selectedPortal)
     );
     if (existingGroups.length === 1) {
       return this.buildMenuResult(existingGroups[0]);
@@ -1359,24 +1654,19 @@ class FlowSurfacesService {
         hideInMenu: !!values.hideInMenu,
         parentId
       },
-      transaction
+      transaction: options.transaction
     });
-    await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+    await this.attachDesktopRouteScopeToRouteAndChildren(
       this.readRouteField(route, "id"),
-      routeUiLayoutUids,
-      transaction
+      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 routeUiLayoutUids = await this.resolveRequestedDesktopRouteUiLayoutUids(
-      values,
-      parentRoute,
-      "createMenu",
-      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)();
@@ -1419,20 +1709,20 @@ class FlowSurfacesService {
           }
         ]
       },
-      transaction
+      transaction: options.transaction
     });
-    await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+    await this.attachDesktopRouteScopeToRouteAndChildren(
       this.readRouteField(createdRoute, "id"),
-      routeUiLayoutUids,
-      transaction
+      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,
@@ -1448,7 +1738,7 @@ class FlowSurfacesService {
         subType: "object",
         ...pageTree
       },
-      { transaction }
+      { transaction: options.transaction }
     );
     return this.buildMenuResult(route, {
       pageSchemaUid,
@@ -1460,7 +1750,16 @@ class FlowSurfacesService {
     });
   }
   sanitizePublicCreateMenuValues(values) {
-    return import_lodash.default.pick(values, ["title", "type", "layoutUid", "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");
@@ -1834,7 +2133,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,
@@ -1851,13 +2150,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) {
@@ -3358,7 +3658,7 @@ class FlowSurfacesService {
       tabs
     };
   }
-  async resolveApplyBlueprintCreateNavigationGroup(document, transaction) {
+  async resolveApplyBlueprintCreateNavigationGroup(document, options = {}) {
     var _a;
     if (document.mode !== "create" || !import_lodash.default.isPlainObject((_a = document.navigation) == null ? void 0 : _a.group)) {
       return document;
@@ -3371,11 +3671,14 @@ class FlowSurfacesService {
       return document;
     }
     const layoutUid = this.normalizeExplicitDesktopRouteLayoutUid(document.navigation.layoutUid);
+    const portalUid = this.navigationTargets.normalizePortalUid(document.navigation.portalUid);
+    const matchScope = await this.resolveDesktopRouteMatchScope(layoutUid, portalUid, "applyBlueprint", options);
     const matchedRoutes = await this.findMenuGroupRoutesByParentIdAndTitle(
       null,
       groupTitle,
-      transaction,
-      layoutUid || await this.resolveDefaultDesktopRouteUiLayoutUids(transaction)
+      options.transaction,
+      matchScope.layoutUids,
+      matchScope.portalUid
     );
     if (!matchedRoutes.length) {
       return document;
@@ -3401,13 +3704,38 @@ class FlowSurfacesService {
       }
     };
   }
-  async normalizeApplyBlueprintCreateMobileNavigation(document, transaction) {
-    var _a;
+  async resolveApplyBlueprintDefaultNavigationTarget(document, options = {}) {
+    var _a, _b, _c, _d;
+    if (document.mode !== "create" || ((_a = document.navigation) == null ? void 0 : _a.layoutUid) || ((_b = document.navigation) == null ? void 0 : _b.portalUid) || !import_lodash.default.isUndefined((_d = (_c = document.navigation) == null ? void 0 : _c.group) == null ? void 0 : _d.routeId) || !this.navigationTargets.hasMultiPortalCapability()) {
+      return document;
+    }
+    const portal = await this.navigationTargets.resolveDefaultPortal({
+      actionName: "applyBlueprint",
+      currentRoles: options.currentRoles,
+      transaction: options.transaction
+    });
+    return {
+      ...document,
+      navigation: {
+        ...document.navigation,
+        portalUid: portal.uid
+      }
+    };
+  }
+  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);
-    if (!await this.isMobileDesktopRouteUiLayoutUid(layoutUid, transaction)) {
+    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 {
@@ -3415,73 +3743,138 @@ class FlowSurfacesService {
       navigation: (0, import_service_utils.buildDefinedPayload)({
         ...document.navigation,
         layoutUid,
+        portalUid,
         group: void 0
       })
     };
   }
-  async assertApplyBlueprintCreateNavigationLayout(document, transaction) {
-    var _a, _b, _c;
+  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);
-    if (!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.assertRouteBelongsToResolvedPortal(
+        "applyBlueprint",
+        groupRoute2,
+        portal,
+        "values.navigation.group.routeId",
+        options.transaction
+      );
+      return;
+    }
+    this.assertAdminLayoutCreateScope(
+      "applyBlueprint",
+      { portalUids: [], layoutUids: [layoutUid] },
+      "values.navigation.layoutUid"
+    );
     await this.assertEnabledDesktopRouteUiLayoutUid(
       layoutUid,
       "applyBlueprint",
       "values.navigation.layoutUid",
-      transaction
+      options.transaction
     );
-    if (await this.isMobileDesktopRouteUiLayoutUid(layoutUid, transaction)) {
+    if (await this.isMobileDesktopRouteUiLayoutUid(layoutUid, options.transaction)) {
       return;
     }
-    const groupRouteId = (_c = (_b = document.navigation) == null ? void 0 : _b.group) == null ? void 0 : _c.routeId;
+    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, transaction);
+    const groupRoute = await this.assertMenuParentIsGroup(groupRouteId, options.transaction);
     await this.assertDesktopRouteBelongsToUiLayout(
       "applyBlueprint",
       groupRoute,
       layoutUid,
       "values.navigation.group.routeId",
-      transaction
+      options.transaction
     );
   }
-  async resolveApplyBlueprintCreatePageIdentity(document, transaction) {
-    var _a, _b, _c, _d, _e, _f;
+  async resolveApplyBlueprintCreatePageIdentity(document, options = {}) {
+    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 layoutUid = this.normalizeExplicitDesktopRouteLayoutUid((_c = document.navigation) == null ? void 0 : _c.layoutUid);
-    const pageTitle = String(((_d = document.page) == null ? void 0 : _d.title) || ((_f = (_e = document.navigation) == null ? void 0 : _e.item) == null ? void 0 : _f.title) || "").trim();
+    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) {
+    if (!pageTitle || !hasGroupRouteId && !layoutUid && !portalUid) {
       return document;
     }
-    const groupRoute = hasGroupRouteId ? await this.findMenuRouteById(groupRouteId, transaction) : null;
-    const layoutUidFilter = layoutUid || (groupRoute ? await this.resolveInheritedDesktopRouteUiLayoutUids(groupRoute, transaction) : void 0);
+    const groupRoute = hasGroupRouteId ? await this.findMenuRouteById(groupRouteId, options.transaction) : null;
+    const groupScope = groupRoute && !portalUid ? await this.readDesktopRouteScope(groupRoute, options.transaction) : void 0;
+    if (!portalUid && groupRoute) {
+      const groupPortalUids = (groupScope == null ? void 0 : groupScope.portalUids) || [];
+      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 portalMatchScope = portalUid ? await this.resolveDesktopRouteMatchScope(layoutUid, portalUid, "applyBlueprint", options) : void 0;
+    let layoutUidFilter = (portalMatchScope == null ? void 0 : portalMatchScope.layoutUids) || layoutUid;
+    if (!portalMatchScope && !layoutUid && groupRoute) {
+      layoutUidFilter = (groupScope == null ? void 0 : groupScope.layoutUids.length) ? groupScope.layoutUids : await this.resolveInheritedDesktopRouteUiLayoutUids(groupRoute, options.transaction);
+      this.assertAdminLayoutCreateScope(
+        "applyBlueprint",
+        { portalUids: [], layoutUids: this.normalizeDesktopRouteLayoutUidFilter(layoutUidFilter) },
+        "values.navigation.group.routeId"
+      );
+    }
+    const portalUidFilter = portalMatchScope == null ? void 0 : portalMatchScope.portalUid;
     const matchedPages = await this.findFlowPageRoutesByParentIdAndTitle(
       hasGroupRouteId ? groupRouteId : null,
       pageTitle,
-      transaction,
-      layoutUidFilter
+      options.transaction,
+      layoutUidFilter,
+      portalUidFilter
     );
     if (!matchedPages.length) {
       return document;
     }
     if (matchedPages.length > 1) {
-      const locationLabel = hasGroupRouteId ? `under navigation.group.routeId '${groupRouteId}'` : `at the root of ui layout '${layoutUid}'`;
+      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 ${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}'` : `at the root of ui layout '${layoutUid}'`;
+      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}' ${locationLabel} is missing schemaUid; pass target.pageSchemaUid explicitly before applyBlueprint`
       );
@@ -3495,21 +3888,19 @@ class FlowSurfacesService {
       navigation: void 0
     };
   }
-  async prepareApplyBlueprintRequest(values, transaction, createdKanbanSortFields) {
+  async prepareApplyBlueprintRequest(values, options = {}, createdKanbanSortFields) {
     var _a;
-    const initialDocument = (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(values);
-    await this.assertApplyBlueprintCreateNavigationLayout(initialDocument, transaction);
-    const mobileNormalizedDocument = await this.normalizeApplyBlueprintCreateMobileNavigation(
-      initialDocument,
-      transaction
-    );
+    const parsedDocument = (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(values);
+    const initialDocument = await this.resolveApplyBlueprintDefaultNavigationTarget(parsedDocument, options);
+    await this.assertApplyBlueprintCreateNavigationTarget(initialDocument, options);
+    const mobileNormalizedDocument = await this.normalizeApplyBlueprintCreateMobileNavigation(initialDocument, options);
     const groupResolvedDocument = await this.resolveApplyBlueprintCreateNavigationGroup(
       mobileNormalizedDocument,
-      transaction
+      options
     );
-    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;
+    const document = await this.resolveApplyBlueprintCreatePageIdentity(groupResolvedDocument, options);
+    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`
@@ -4159,12 +4550,47 @@ 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, layoutUid) => this.findMenuGroupRoutesByTitle(title, transaction, layoutUid),
-      getUiLayoutTypeByUid: (layoutUid, transaction) => this.getDesktopRouteUiLayoutTypeByUid(layoutUid, transaction),
+      findMenuGroupRoutesByTitle: async (title, transaction, targetLayoutUid, targetPortalUid) => {
+        const matchScope = await this.resolveDesktopRouteMatchScope(
+          targetLayoutUid,
+          targetPortalUid,
+          "applyBlueprint",
+          {
+            transaction,
+            currentRoles: options.currentRoles
+          }
+        );
+        return this.findMenuGroupRoutesByTitle(title, transaction, matchScope.layoutUids, matchScope.portalUid);
+      },
+      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 || "")
     });
   }
@@ -4172,7 +4598,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);
@@ -4803,6 +5229,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
@@ -4816,7 +5243,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
       };
     }
@@ -6186,6 +6613,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";
@@ -6193,9 +6623,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;
@@ -6205,6 +6635,53 @@ class FlowSurfacesService {
     const route = await this.assertMenuRouteUpdatable(menuRouteId, 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.assertRouteBelongsToResolvedPortal(
+        "updateMenu",
+        route,
+        portal,
+        "values.menuRouteId",
+        options.transaction
+      );
+      if (nextParentRoute) {
+        await this.assertRouteBelongsToResolvedPortal(
+          "updateMenu",
+          nextParentRoute,
+          portal,
+          "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")) {
@@ -6235,25 +6712,29 @@ class FlowSurfacesService {
     }
     const updated = await this.findMenuRouteById(menuRouteId, options.transaction);
     if (updated && Object.prototype.hasOwnProperty.call(values, "parentMenuRouteId")) {
-      await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
-        this.readRouteField(updated, "id"),
-        await this.resolveInheritedDesktopRouteUiLayoutUids(nextParentRoute, options.transaction),
-        options.transaction
-      );
+      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 layoutUid = this.normalizeExplicitDesktopRouteLayoutUid(values.layoutUid);
-    if (layoutUid) {
-      await this.assertEnabledDesktopRouteUiLayoutUid(layoutUid, "createPage", "values.layoutUid", transaction);
-      await this.assertDesktopRouteBelongsToUiLayout("createPage", route, layoutUid, "values.menuRouteId", transaction);
-    }
-    const routeUiLayoutUids = await this.ensureDesktopRouteUiLayouts(route, transaction);
+    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")`);
@@ -6292,7 +6773,11 @@ class FlowSurfacesService {
         },
         transaction
       });
-      await this.setDesktopRouteUiLayouts(this.readRouteField(tabRoute, "id"), routeUiLayoutUids, transaction);
+      await this.attachDesktopRouteScopeToRouteAndChildren(
+        this.readRouteField(tabRoute, "id"),
+        routeScope,
+        transaction
+      );
     } else {
       await this.db.getRepository("desktopRoutes").update({
         filterByTk: String(this.readRouteField(tabRoute, "id")),
@@ -6317,7 +6802,11 @@ class FlowSurfacesService {
       });
     }
     if (tabRoute) {
-      await this.setDesktopRouteUiLayouts(this.readRouteField(tabRoute, "id"), routeUiLayoutUids, transaction);
+      await this.attachDesktopRouteScopeToRouteAndChildren(
+        this.readRouteField(tabRoute, "id"),
+        routeScope,
+        transaction
+      );
     }
     await this.ensureFlowRoutePageSchemaShell(pageSchemaUid, transaction);
     await this.db.getRepository("desktopRoutes").update({
@@ -6369,11 +6858,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;
@@ -6458,11 +6947,11 @@ class FlowSurfacesService {
       },
       transaction: options.transaction
     });
-    await this.setDesktopRouteUiLayouts(
-      route.get("id"),
-      await this.ensureDesktopRouteUiLayouts(pageRoute, options.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,