@designcrowd/library.brand-page 6.0.11 → 6.0.13

package/lib/src/metadata-builder/ai-metadata-executor.js

@@ -45,7 +45,7 @@ export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
                     type: BUILDER_TYPES.MOVE_SECTION,
                     payload: {
                         contentId: arg.content_id,
-                        position: arg.position,
+                        moveBeforeContentId: arg.move_before_content_id,
                         targetPageId: arg.target_page_id,
                     },
                 };
@@ -82,6 +82,29 @@ export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
                     },
                 };
             }
+            case AI_ASSISTANT_TOOL_NAMES.MOVE_PAGE: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.MOVE_PAGE,
+                    payload: {
+                        pageId: arg.page_id,
+                        parentPageId: arg.parent_page_id,
+                        moveBeforePageId: arg.move_before_page_id,
+                    },
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.SET_PAGE_VISIBILITY: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.SET_PAGE_VISIBILITY,
+                    payload: {
+                        pageId: arg.page_id,
+                        isHidden: arg.is_hidden,
+                    },
+                };
+            }
             case AI_ASSISTANT_TOOL_NAMES.UPDATE_FOOTER: {
                 const arg = toolcall.arguments;
                 return {

package/lib/src/metadata-builder/builders/footer-builder.js

@@ -2,6 +2,7 @@ import {} from '../../brand-page/models';
 import { BaseMetadataBuilder, } from '../models';
 import { FOOTER_CHECKS } from './section-rules/footer.rules';
 import { applyDetachedStyleOverride, normalizeStyleValue, } from './section-field-utils';
+import { generateItemId, removeItemsByIds, repositionItemByAnchor, } from './item-id-utils';
 const normaliseSocialUrl = (url) => {
     for (const prefix of ['mailto:', 'tel:']) {
         if (url.startsWith(prefix))
@@ -10,6 +11,7 @@ const normaliseSocialUrl = (url) => {
     return url;
 };
 const makeSocialLink = (icon, url) => ({
+    id: generateItemId(),
     imageUrl: icon || '',
     url: normaliseSocialUrl(url || ''),
     imageTitle: '',
@@ -18,8 +20,7 @@ const makeSocialLink = (icon, url) => ({
     imageLink: '',
 });
 const hasSocialLinkMutation = (args) => args._replace_social_links === true ||
-    (args._remove_social_link_indices?.length ?? 0) > 0 ||
-    (args._reorder_social_links?.length ?? 0) > 0 ||
+    (args._remove_social_link_ids?.length ?? 0) > 0 ||
     (args.social_links?.length ?? 0) > 0;
 /**
  * Social links are a GLOBAL footer concern — one logical list that both
@@ -41,47 +42,37 @@ const computeSocialLinks = (current, args) => {
     if (args._replace_social_links) {
         return (args.social_links ?? []).map((l) => makeSocialLink(l.social_link_icon, l.url));
     }
-    const links = [...(current ?? [])];
-    // item_index-based updates for existing links — replace the item reference
-    // (never mutate the original object, which may be shared across viewports).
+    // Work on fresh copies so `current` (which may be shared across viewports)
+    // is never mutated. Backfill ids on the copies so legacy links become
+    // referenceable by the id-based contract (BP-5603).
+    let links = (current ?? []).map((l) => ({
+        ...l,
+        id: l.id || generateItemId(),
+    }));
+    // Remove by id — order-independent, no index shifting.
+    links = removeItemsByIds(links, args._remove_social_link_ids);
+    // Update existing links (item_id present) or insert new ones (no item_id);
+    // position/move via move_before_item_id ("__end__" or a missing anchor => end).
     for (const link of args.social_links ?? []) {
-        if (link.item_index === undefined)
-            continue;
-        const existing = links[link.item_index];
-        if (!existing)
-            continue;
-        links[link.item_index] = {
-            ...existing,
-            ...(link.social_link_icon !== undefined
-                ? { imageUrl: link.social_link_icon }
-                : {}),
-            ...(link.url !== undefined ? { url: normaliseSocialUrl(link.url) } : {}),
-        };
-    }
-    // Remove by index (descending order to preserve indices during splice).
-    if (args._remove_social_link_indices?.length) {
-        const sorted = [...args._remove_social_link_indices].sort((a, b) => b - a);
-        for (const idx of sorted) {
-            if (idx >= 0 && idx < links.length)
-                links.splice(idx, 1);
+        if (link.item_id) {
+            const index = links.findIndex((l) => l.id === link.item_id);
+            // Unknown id — skip rather than guess at a position.
+            if (index === -1)
+                continue;
+            links[index] = {
+                ...links[index],
+                ...(link.social_link_icon !== undefined
+                    ? { imageUrl: link.social_link_icon }
+                    : {}),
+                ...(link.url !== undefined
+                    ? { url: normaliseSocialUrl(link.url) }
+                    : {}),
+            };
+            repositionItemByAnchor(links, links[index], link.move_before_item_id);
         }
-    }
-    // Insert new links (descending insert_at order to preserve positions).
-    const insertLinks = (args.social_links ?? []).filter((l) => l.insert_at !== undefined && l.item_index === undefined);
-    const sortedInserts = [...insertLinks].sort((a, b) => b.insert_at - a.insert_at);
-    for (const link of sortedInserts) {
-        const pos = Math.max(0, Math.min(link.insert_at, links.length));
-        links.splice(pos, 0, makeSocialLink(link.social_link_icon, link.url));
-    }
-    // Reorder (requires ALL indices — partial reorder is not supported).
-    if (args._reorder_social_links?.length) {
-        const newOrder = args._reorder_social_links;
-        const unique = new Set(newOrder);
-        if (unique.size === newOrder.length &&
-            newOrder.every((idx) => idx >= 0 && idx < links.length)) {
-            const reordered = newOrder.map((idx) => links[idx]);
-            if (reordered.length === links.length)
-                return reordered;
+        else {
+            const newLink = makeSocialLink(link.social_link_icon, link.url);
+            repositionItemByAnchor(links, newLink, link.move_before_item_id);
         }
     }
     return links;

package/lib/src/metadata-builder/builders/item-id-utils.d.ts

@@ -0,0 +1,54 @@
+import type { BrandPageModel } from '../../brand-page/models';
+/**
+ * Sentinel anchor meaning "the end of the list", mirroring the section-level
+ * `move_before_content_id: "__end__"` convention used in base-section-builder.
+ */
+export declare const END_ITEM_ANCHOR = "__end__";
+/** Generate a stable item id. Mirrors section-level `uuid.v4()` id generation. */
+export declare const generateItemId: () => string;
+/**
+ * Walk an entire BrandPageModel and backfill a stable uuid `id` onto every
+ * nested array item that lacks one (gallery images, images/shapes/testimonial
+ * items, text items, social links, and footer social links).
+ *
+ * BP-5603: this must run BEFORE the model is minified for the AI, so the same
+ * id the AI is shown (and copies into `item_id`) is the one the executor later
+ * matches. The maker holds a single live model instance for both the minify
+ * and the apply step, so mutating it here makes the ids round-trip; they then
+ * persist on the next save. Idempotent — existing ids are preserved.
+ */
+export declare const ensureBrandPageItemIds: (model: BrandPageModel) => void;
+/**
+ * Backfill ids onto any items missing one. Per BP-5603 this runs in the
+ * metadata builder when a section is processed, so the persisted metadata
+ * returned to the client gains stable ids that subsequent AI tool calls can
+ * reference. Mutates in place.
+ */
+export declare const ensureItemIds: <T extends {
+    id?: string;
+}>(items: T[] | undefined) => void;
+/**
+ * Remove items whose id appears in `ids`. Order-independent (no descending
+ * index sort needed) — the whole point of the id-based migration. Items
+ * without an id are never removed by id.
+ */
+export declare const removeItemsByIds: <T extends {
+    id?: string;
+}>(items: T[] | undefined, ids: string[] | undefined) => T[];
+/**
+ * Position `item` within `items` relative to an anchor id — the item-level
+ * mirror of base-section-builder's `moveContent`:
+ *
+ * - `moveBeforeItemId === undefined`  → leave an existing item where it is;
+ *   append a new (not-yet-present) item to the end.
+ * - `moveBeforeItemId === "__end__"`  → move/insert at the very end.
+ * - anchor id found                   → insert immediately before it.
+ * - anchor id not found               → fall through to the end (same
+ *   forgiving behaviour as `moveContent`).
+ *
+ * Mutates `items` in place. `item` may be an existing element of `items`
+ * (a move) or a brand-new object (an insert).
+ */
+export declare const repositionItemByAnchor: <T extends {
+    id?: string;
+}>(items: T[], item: T, moveBeforeItemId: string | undefined) => void;

package/lib/src/metadata-builder/builders/item-id-utils.js

@@ -0,0 +1,96 @@
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Sentinel anchor meaning "the end of the list", mirroring the section-level
+ * `move_before_content_id: "__end__"` convention used in base-section-builder.
+ */
+export const END_ITEM_ANCHOR = '__end__';
+/** Generate a stable item id. Mirrors section-level `uuid.v4()` id generation. */
+export const generateItemId = () => uuidv4();
+/**
+ * Walk an entire BrandPageModel and backfill a stable uuid `id` onto every
+ * nested array item that lacks one (gallery images, images/shapes/testimonial
+ * items, text items, social links, and footer social links).
+ *
+ * BP-5603: this must run BEFORE the model is minified for the AI, so the same
+ * id the AI is shown (and copies into `item_id`) is the one the executor later
+ * matches. The maker holds a single live model instance for both the minify
+ * and the apply step, so mutating it here makes the ids round-trip; they then
+ * persist on the next save. Idempotent — existing ids are preserved.
+ */
+export const ensureBrandPageItemIds = (model) => {
+    const ensureContentItemIds = (content) => {
+        // Every array field that the minifier surfaces as a list of items.
+        for (const field of ['images', 'items', 'textItems', 'links']) {
+            const arr = content[field];
+            if (Array.isArray(arr))
+                ensureItemIds(arr);
+        }
+    };
+    for (const page of model.pages ?? []) {
+        for (const content of page.contents ?? []) {
+            ensureContentItemIds(content);
+        }
+    }
+    ensureItemIds(model.pageFooterDesktop?.socialLinks);
+    ensureItemIds(model.pageFooterMobile?.socialLinks);
+};
+/**
+ * Backfill ids onto any items missing one. Per BP-5603 this runs in the
+ * metadata builder when a section is processed, so the persisted metadata
+ * returned to the client gains stable ids that subsequent AI tool calls can
+ * reference. Mutates in place.
+ */
+export const ensureItemIds = (items) => {
+    if (!items)
+        return;
+    for (const item of items) {
+        if (!item.id)
+            item.id = generateItemId();
+    }
+};
+/**
+ * Remove items whose id appears in `ids`. Order-independent (no descending
+ * index sort needed) — the whole point of the id-based migration. Items
+ * without an id are never removed by id.
+ */
+export const removeItemsByIds = (items, ids) => {
+    if (!items?.length)
+        return items ?? [];
+    if (!ids?.length)
+        return items;
+    const toRemove = new Set(ids);
+    return items.filter((item) => !item.id || !toRemove.has(item.id));
+};
+/**
+ * Position `item` within `items` relative to an anchor id — the item-level
+ * mirror of base-section-builder's `moveContent`:
+ *
+ * - `moveBeforeItemId === undefined`  → leave an existing item where it is;
+ *   append a new (not-yet-present) item to the end.
+ * - `moveBeforeItemId === "__end__"`  → move/insert at the very end.
+ * - anchor id found                   → insert immediately before it.
+ * - anchor id not found               → fall through to the end (same
+ *   forgiving behaviour as `moveContent`).
+ *
+ * Mutates `items` in place. `item` may be an existing element of `items`
+ * (a move) or a brand-new object (an insert).
+ */
+export const repositionItemByAnchor = (items, item, moveBeforeItemId) => {
+    const currentIndex = items.indexOf(item);
+    if (moveBeforeItemId === undefined) {
+        if (currentIndex === -1)
+            items.push(item);
+        return;
+    }
+    if (currentIndex !== -1)
+        items.splice(currentIndex, 1);
+    const anchorIndex = moveBeforeItemId === END_ITEM_ANCHOR
+        ? -1
+        : items.findIndex((i) => i.id === moveBeforeItemId);
+    if (anchorIndex !== -1) {
+        items.splice(anchorIndex, 0, item);
+    }
+    else {
+        items.push(item);
+    }
+};

package/lib/src/metadata-builder/builders/move-page-builder.d.ts

@@ -0,0 +1,32 @@
+import type { BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { Logger } from '../logger';
+export interface MovePagePayload {
+    /** The page to move (resolved from page_id). */
+    pageId: string;
+    /**
+     * Destination parent: a page_id to nest under, or null/undefined for top-level.
+     * Analogous to move_section's target_page_id.
+     */
+    parentPageId?: string | null;
+    /**
+     * Position anchor at the destination level: the page_id of the sibling to
+     * insert before, or "__end__" to append. Omitted/null → append at end.
+     * Analogous to move_section's move_before_content_id.
+     */
+    moveBeforePageId?: string | null;
+}
+export declare class MovePageBuilder extends BaseMetadataBuilder<MovePagePayload> {
+    constructor(request: MetadataBuilderRequest<MovePagePayload>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+    /**
+     * Resolve the insertion index within destinationOrders.
+     *
+     * moveBeforePageId anchors by pageId of a sibling at that level.
+     * "__end__" or omitted/null → append. Unknown anchor → append.
+     */
+    private resolveIndex;
+}

package/lib/src/metadata-builder/builders/move-page-builder.js

@@ -0,0 +1,137 @@
+import { getPageSlugFromPageTitle } from '../../brand-page-maker/utils/slug.util';
+import { BaseMetadataBuilder, } from '../models';
+import { detachOrder, findOrderAnywhere, findParentRouteId, getSiblingSlugsAtDepth, syncPagesWithNavOrders, } from './nav-utils';
+export class MovePageBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const errors = [];
+        const payload = this.request.payload;
+        if (!payload?.pageId) {
+            errors.push('pageId is required for move_page');
+        }
+        return { errors };
+    }
+    async buildAsync(model) {
+        this.log('Build called');
+        const validation = await this.validateAsync();
+        if (validation.errors.length) {
+            return { request: this.request, model, errors: validation.errors };
+        }
+        const { pageId, parentPageId, moveBeforePageId } = this.request.payload;
+        // Build lookup: pageId → NavRoute.
+        const routeByPageId = new Map(model.nav.routes.map((r) => [r.pageId, r]));
+        // --- Find the target route ---
+        const targetRoute = routeByPageId.get(pageId);
+        if (!targetRoute) {
+            return {
+                request: this.request,
+                model,
+                errors: [`Page with ID "${pageId}" not found`],
+            };
+        }
+        const targetRouteId = targetRoute.id;
+        // Find the NavOrder for the target (must exist in the tree).
+        const targetOrder = findOrderAnywhere(model.nav.orders, targetRouteId);
+        if (!targetOrder) {
+            return {
+                request: this.request,
+                model,
+                errors: [`NavOrder for page "${pageId}" not found in nav.orders`],
+            };
+        }
+        // --- GUARD: parent cannot equal target ---
+        if (parentPageId && parentPageId === pageId) {
+            return {
+                request: this.request,
+                model,
+                errors: [`A page cannot be nested under itself`],
+            };
+        }
+        // --- GUARD: home page (orders[0]) cannot be nested ---
+        const homeRouteId = model.nav.orders[0]?.routeId;
+        if (parentPageId && homeRouteId === targetRouteId) {
+            return {
+                request: this.request,
+                model,
+                errors: [`Home page "${pageId}" cannot be nested under another page`],
+            };
+        }
+        // --- Resolve destination level ---
+        let destinationOrders;
+        if (parentPageId) {
+            const parentRoute = routeByPageId.get(parentPageId);
+            if (!parentRoute) {
+                return {
+                    request: this.request,
+                    model,
+                    errors: [`Parent page with ID "${parentPageId}" not found`],
+                };
+            }
+            // GUARD: parent must be a root-level page (depth-1 cap).
+            const isParentAtRoot = model.nav.orders.some((o) => o.routeId === parentRoute.id);
+            if (!isParentAtRoot) {
+                return {
+                    request: this.request,
+                    model,
+                    errors: [
+                        `Parent page "${parentPageId}" is itself a subpage — nesting beyond depth 1 is not supported`,
+                    ],
+                };
+            }
+            const parentOrder = findOrderAnywhere(model.nav.orders, parentRoute.id);
+            // GUARD: target page must not have its own subRoutes when being nested.
+            if (targetOrder.subRoutes.length > 0) {
+                return {
+                    request: this.request,
+                    model,
+                    errors: [
+                        `Page "${pageId}" has subpages and cannot itself be nested under another page`,
+                    ],
+                };
+            }
+            destinationOrders = parentOrder.subRoutes;
+        }
+        else {
+            // Moving to top level (un-nest or reorder at root).
+            destinationOrders = model.nav.orders;
+        }
+        // Record the old parent before any mutation for slug recompute.
+        const oldParentRouteId = findParentRouteId(model.nav.orders, targetRouteId);
+        // Detach the target from its current position.
+        detachOrder(model.nav.orders, targetRouteId);
+        // --- Resolve insertion index ---
+        const insertIndex = this.resolveIndex(destinationOrders, moveBeforePageId, routeByPageId);
+        destinationOrders.splice(insertIndex, 0, targetOrder);
+        // --- Slug recompute only when parent changed ---
+        const newParentRouteId = findParentRouteId(model.nav.orders, targetRouteId) ?? undefined;
+        // After detach+re-insert, undefined means root.
+        const effectiveOldParent = oldParentRouteId ?? undefined;
+        if (newParentRouteId !== effectiveOldParent) {
+            const siblingSlugs = getSiblingSlugsAtDepth(model, newParentRouteId, targetRouteId);
+            targetRoute.pageSlug = getPageSlugFromPageTitle(targetRoute.displayName, siblingSlugs);
+        }
+        syncPagesWithNavOrders(model);
+        this.log({
+            message: `Moved page "${pageId}" — parent: ${parentPageId ?? 'root'}, before: ${moveBeforePageId ?? 'end'}`,
+        });
+        return { request: this.request, model };
+    }
+    /**
+     * Resolve the insertion index within destinationOrders.
+     *
+     * moveBeforePageId anchors by pageId of a sibling at that level.
+     * "__end__" or omitted/null → append. Unknown anchor → append.
+     */
+    resolveIndex(destinationOrders, moveBeforePageId, routeByPageId) {
+        if (!moveBeforePageId || moveBeforePageId === '__end__') {
+            return destinationOrders.length;
+        }
+        const anchorRoute = routeByPageId.get(moveBeforePageId);
+        if (!anchorRoute)
+            return destinationOrders.length;
+        const idx = destinationOrders.findIndex((o) => o.routeId === anchorRoute.id);
+        return idx !== -1 ? idx : destinationOrders.length;
+    }
+}

package/lib/src/metadata-builder/builders/nav-utils.d.ts

@@ -0,0 +1,26 @@
+import type { BrandPageModel, NavOrder } from '../../brand-page/models';
+/**
+ * Resync model.pages[] to match the DFS walk of model.nav.orders.
+ * Pages not referenced in nav are appended at the end (defensive).
+ * Mutates and returns model.pages in place.
+ */
+export declare const syncPagesWithNavOrders: (model: BrandPageModel) => BrandPageModel["pages"];
+/**
+ * Find a NavOrder by routeId anywhere in the tree (root + subRoutes, recursive).
+ */
+export declare const findOrderAnywhere: (orders: NavOrder[], routeId: string) => NavOrder | undefined;
+/**
+ * Find the routeId of the parent that contains the target as a direct child in subRoutes.
+ * Returns undefined when the target is a root order.
+ */
+export declare const findParentRouteId: (orders: NavOrder[], targetRouteId: string, _parentId?: string) => string | undefined;
+/**
+ * Splice the NavOrder with routeId from wherever it lives (root or any subRoutes), in place.
+ */
+export declare const detachOrder: (orders: NavOrder[], routeId: string) => void;
+/**
+ * Return the slugs of all routes that are direct children at the same depth as parentRouteId.
+ * - parentRouteId === undefined → root orders.
+ * - excludeRouteId is omitted from the result (pass the route being renamed/moved).
+ */
+export declare const getSiblingSlugsAtDepth: (model: BrandPageModel, parentRouteId: string | undefined, excludeRouteId: string) => string[];

package/lib/src/metadata-builder/builders/nav-utils.js

@@ -0,0 +1,95 @@
+/**
+ * DFS walk of nav.orders (recurse subRoutes), returning every routeId in visit order.
+ */
+const dfsRouteIds = (orders) => {
+    const ids = [];
+    for (const order of orders) {
+        ids.push(order.routeId);
+        ids.push(...dfsRouteIds(order.subRoutes));
+    }
+    return ids;
+};
+/**
+ * Resync model.pages[] to match the DFS walk of model.nav.orders.
+ * Pages not referenced in nav are appended at the end (defensive).
+ * Mutates and returns model.pages in place.
+ */
+export const syncPagesWithNavOrders = (model) => {
+    const routeIds = dfsRouteIds(model.nav.orders);
+    // Build a map from pageId to its nav position so we can sort pages by encounter order.
+    const routeById = new Map(model.nav.routes.map((r) => [r.id, r]));
+    // Map from pageId → DFS index (using route→pageId lookup).
+    const routeIdToDfsIndex = new Map(routeIds.map((rid, i) => [rid, i]));
+    // Convert nav routeId order to pageId order.
+    const pageIdOrder = new Map();
+    for (const [routeId, idx] of routeIdToDfsIndex) {
+        const route = routeById.get(routeId);
+        if (route) {
+            pageIdOrder.set(route.pageId, idx);
+        }
+    }
+    const navMax = routeIds.length;
+    model.pages = [...model.pages].sort((a, b) => {
+        const ia = pageIdOrder.has(a.id) ? pageIdOrder.get(a.id) : navMax;
+        const ib = pageIdOrder.has(b.id) ? pageIdOrder.get(b.id) : navMax;
+        return ia - ib;
+    });
+    return model.pages;
+};
+/**
+ * Find a NavOrder by routeId anywhere in the tree (root + subRoutes, recursive).
+ */
+export const findOrderAnywhere = (orders, routeId) => {
+    for (const order of orders) {
+        if (order.routeId === routeId)
+            return order;
+        const found = findOrderAnywhere(order.subRoutes, routeId);
+        if (found)
+            return found;
+    }
+    return undefined;
+};
+/**
+ * Find the routeId of the parent that contains the target as a direct child in subRoutes.
+ * Returns undefined when the target is a root order.
+ */
+export const findParentRouteId = (orders, targetRouteId, _parentId) => {
+    for (const order of orders) {
+        if (order.subRoutes.some((sr) => sr.routeId === targetRouteId)) {
+            return order.routeId;
+        }
+        const found = findParentRouteId(order.subRoutes, targetRouteId, order.routeId);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+};
+/**
+ * Splice the NavOrder with routeId from wherever it lives (root or any subRoutes), in place.
+ */
+export const detachOrder = (orders, routeId) => {
+    const idx = orders.findIndex((o) => o.routeId === routeId);
+    if (idx !== -1) {
+        orders.splice(idx, 1);
+        return;
+    }
+    for (const order of orders) {
+        detachOrder(order.subRoutes, routeId);
+    }
+};
+/**
+ * Return the slugs of all routes that are direct children at the same depth as parentRouteId.
+ * - parentRouteId === undefined → root orders.
+ * - excludeRouteId is omitted from the result (pass the route being renamed/moved).
+ */
+export const getSiblingSlugsAtDepth = (model, parentRouteId, excludeRouteId) => {
+    const siblingOrders = parentRouteId === undefined
+        ? model.nav.orders
+        : (findOrderAnywhere(model.nav.orders, parentRouteId)?.subRoutes ?? []);
+    const siblingRouteIds = new Set(siblingOrders
+        .filter((o) => o.routeId !== excludeRouteId)
+        .map((o) => o.routeId));
+    return model.nav.routes
+        .filter((r) => siblingRouteIds.has(r.id))
+        .map((r) => r.pageSlug);
+};