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

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,6 +690,7 @@ function assertNoFlowSurfaceIdTitleFieldSettings(value, options = {}) {
   };
   visit(value, options.basePath || []);
 }
+const MOBILE_UI_LAYOUT_TYPE = "mobile";
 class FlowSurfacesService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -709,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");
@@ -922,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",
@@ -936,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)) {
@@ -943,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)) {
@@ -1030,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);
@@ -1082,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]);
     }
@@ -1111,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(),
@@ -1122,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)();
@@ -1142,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(),
@@ -1175,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,
@@ -1199,7 +1649,7 @@ class FlowSurfacesService {
         subType: "object",
         ...pageTree
       },
-      { transaction }
+      { transaction: options.transaction }
     );
     return this.buildMenuResult(route, {
       pageSchemaUid,
@@ -1211,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");
@@ -3122,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;
     }
@@ -3147,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 {
@@ -3181,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`
@@ -3837,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 || "")
     });
   }
@@ -3849,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);
@@ -5864,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";
@@ -5871,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;
@@ -5881,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")) {
@@ -5912,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")`);
@@ -5940,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),
@@ -5957,10 +6640,11 @@ class FlowSurfacesService {
         },
         transaction
       });
-      tabRoute = await this.db.getRepository("desktopRoutes").findOne({
-        filter: { schemaUid: tabSchemaUid2 },
+      await this.attachDesktopRouteScopeToRouteAndChildren(
+        this.readRouteField(tabRoute, "id"),
+        routeScope,
         transaction
-      });
+      );
     } else {
       await this.db.getRepository("desktopRoutes").update({
         filterByTk: String(this.readRouteField(tabRoute, "id")),
@@ -5984,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),
@@ -6034,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;
@@ -6123,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,