@ankhorage/studio 0.14.0 → 0.16.0

package/dist/manifestState.js

@@ -1,3 +1,5 @@
+import { NAVIGATOR_TYPES } from '@ankhorage/contracts';
+import { insertNodeAtPlacement, moveNodeToPlacement } from './index';
 export const DEFAULT_STUDIO_SCREEN_TEMPLATE = {
     id: 'tpl-screen-empty',
     type: 'Screen',
@@ -103,6 +105,215 @@ export function groupScreenRouteEntries(entries) {
     }
     return Array.from(groups.values());
 }
+/**
+ * Verifies the Studio manifest invariant that route registry keys and stable
+ * ScreenSpec identities are the same unique value.
+ */
+export function hasCanonicalStudioScreenRegistryIdentity(screens) {
+    const screenIds = new Set();
+    for (const [registryKey, screen] of Object.entries(screens)) {
+        if (registryKey !== screen.id || screenIds.has(screen.id))
+            return false;
+        screenIds.add(screen.id);
+    }
+    return true;
+}
+function resolveCanonicalStudioScreen(manifest, screenId) {
+    if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens))
+        return undefined;
+    return manifest.screens[screenId];
+}
+/**
+ * Derives the complete package-neutral screen/navigation authoring model from
+ * the manifest without flattening its navigator tree.
+ */
+export function deriveStudioScreenNavigationModel(manifest) {
+    const primaryNavigatorPath = getPrimaryNavigatorPath(manifest.navigator.routes);
+    const primaryNavigator = findNavigatorAtPath(manifest.navigator, primaryNavigatorPath) ?? manifest.navigator;
+    const diagnostics = [];
+    const referencesByRegistryKey = new Map();
+    collectNavigationModelReferences({
+        navigator: manifest.navigator,
+        screens: manifest.screens,
+        primaryNavigatorPath,
+        parentPath: [],
+        routePathPrefix: [],
+        runtimePathPrefix: [],
+        diagnostics,
+        referencesByRegistryKey,
+    });
+    const screenIdCounts = new Map();
+    for (const screen of Object.values(manifest.screens)) {
+        screenIdCounts.set(screen.id, (screenIdCounts.get(screen.id) ?? 0) + 1);
+    }
+    const reportedDuplicateScreenIds = new Set();
+    const screens = Object.entries(manifest.screens).map(([registryKey, screen]) => {
+        const screenId = screen.id;
+        const routeReferences = referencesByRegistryKey.get(registryKey) ?? [];
+        if (registryKey !== screenId) {
+            diagnostics.push({
+                code: 'screen-registry-key-mismatch',
+                message: `Screen registry key "${registryKey}" does not match stable ScreenSpec.id "${screenId}".`,
+                parentPath: [],
+                screenId,
+            });
+        }
+        if ((screenIdCounts.get(screenId) ?? 0) > 1 && !reportedDuplicateScreenIds.has(screenId)) {
+            reportedDuplicateScreenIds.add(screenId);
+            diagnostics.push({
+                code: 'duplicate-screen-id',
+                message: `Stable ScreenSpec.id "${screenId}" is used by multiple screen registry entries.`,
+                parentPath: [],
+                screenId,
+            });
+        }
+        if (routeReferences.length > 1) {
+            diagnostics.push({
+                code: 'ambiguous-screen-route-reference',
+                message: `Screen "${screenId}" is referenced by ${routeReferences.length} routes.`,
+                parentPath: [],
+                screenId,
+            });
+        }
+        return { screenId, screen, routeReferences };
+    });
+    return {
+        primaryNavigatorPath,
+        primaryNavigator,
+        screens,
+        diagnostics,
+    };
+}
+/**
+ * Returns a concrete canonical app pathname only when a screen has one route
+ * reference and that route does not require runtime parameters.
+ */
+export function resolveStudioScreenAppPath(model, screenId) {
+    const matchingEntries = model.screens.filter((candidate) => candidate.screenId === screenId);
+    if (matchingEntries.length !== 1)
+        return null;
+    const [entry] = matchingEntries;
+    if (!entry)
+        return null;
+    if (entry.routeReferences.length !== 1)
+        return null;
+    const [reference] = entry.routeReferences;
+    if (!reference)
+        return null;
+    const hasDynamicSegment = reference.pathnamePattern
+        .split('/')
+        .some((segment) => segment.startsWith(':') || /^\[.*\]$/u.test(segment));
+    if (hasDynamicSegment)
+        return null;
+    const matchingReferences = model.screens.flatMap((candidate) => candidate.routeReferences.filter((candidateReference) => candidateReference.pathnamePattern === reference.pathnamePattern));
+    return matchingReferences.length === 1 ? reference.pathnamePattern : null;
+}
+function collectNavigationModelReferences(args) {
+    const { navigator, screens, primaryNavigatorPath, parentPath, routePathPrefix, runtimePathPrefix, diagnostics, referencesByRegistryKey, } = args;
+    const siblingNameCounts = new Map();
+    for (const route of navigator.routes) {
+        siblingNameCounts.set(route.name, (siblingNameCounts.get(route.name) ?? 0) + 1);
+    }
+    if (navigator.routes.length === 0) {
+        diagnostics.push({
+            code: 'empty-navigator',
+            message: `Navigator at "${formatParentPath(parentPath)}" has no routes.`,
+            parentPath,
+        });
+    }
+    if (navigator.initialRouteName !== undefined &&
+        siblingNameCounts.get(navigator.initialRouteName) !== 1) {
+        diagnostics.push({
+            code: 'invalid-initial-route',
+            message: `Initial route "${navigator.initialRouteName}" is not one unambiguous direct route of "${formatParentPath(parentPath)}".`,
+            parentPath,
+            routeName: navigator.initialRouteName,
+        });
+    }
+    for (const [siblingIndex, route] of navigator.routes.entries()) {
+        const routePath = [...routePathPrefix, route.name];
+        const runtimePath = appendRuntimeRoutePath(runtimePathPrefix, route);
+        const isPrimaryNavigatorMember = pathsEqual(parentPath, primaryNavigatorPath);
+        if ((siblingNameCounts.get(route.name) ?? 0) > 1 &&
+            navigator.routes.findIndex((candidate) => candidate.name === route.name) === siblingIndex) {
+            diagnostics.push({
+                code: 'duplicate-sibling-route-name',
+                message: `Route name "${route.name}" is duplicated under "${formatParentPath(parentPath)}".`,
+                parentPath,
+                routeName: route.name,
+                screenId: route.screenId,
+            });
+        }
+        if (!route.screenId && !route.navigator) {
+            diagnostics.push({
+                code: 'missing-route-target',
+                message: `Route "${route.name}" has neither a screen nor a nested navigator.`,
+                parentPath,
+                routeName: route.name,
+            });
+        }
+        else if (route.screenId && route.navigator) {
+            diagnostics.push({
+                code: 'ambiguous-route-target',
+                message: `Route "${route.name}" targets both a screen and a nested navigator.`,
+                parentPath,
+                routeName: route.name,
+                screenId: route.screenId,
+            });
+        }
+        if (route.screenId) {
+            if (!screens[route.screenId]) {
+                diagnostics.push({
+                    code: 'missing-screen-reference',
+                    message: `Route "${route.name}" references missing screen "${route.screenId}".`,
+                    parentPath,
+                    routeName: route.name,
+                    screenId: route.screenId,
+                });
+            }
+            else {
+                const reference = {
+                    route,
+                    parentPath,
+                    routePath,
+                    pathnamePattern: toCanonicalRoutePattern(runtimePath),
+                    siblingIndex,
+                    navigatorType: navigator.type,
+                    isPrimaryNavigatorMember,
+                    showInPrimaryNavigation: route.showInPrimaryNavigation !== false,
+                    isPrimaryInitialRoute: isPrimaryNavigatorMember && navigator.initialRouteName === route.name,
+                };
+                const currentReferences = referencesByRegistryKey.get(route.screenId) ?? [];
+                currentReferences.push(reference);
+                referencesByRegistryKey.set(route.screenId, currentReferences);
+            }
+        }
+        if (route.navigator) {
+            collectNavigationModelReferences({
+                navigator: route.navigator,
+                screens,
+                primaryNavigatorPath,
+                parentPath: routePath,
+                routePathPrefix: routePath,
+                runtimePathPrefix: runtimePath,
+                diagnostics,
+                referencesByRegistryKey,
+            });
+        }
+    }
+}
+function appendRuntimeRoutePath(runtimePathPrefix, route) {
+    const explicitPath = route.path?.trim();
+    const segmentPath = explicitPath ?? route.name;
+    const segments = segmentPath.split('/').filter(Boolean);
+    return explicitPath?.startsWith('/') ? segments : [...runtimePathPrefix, ...segments];
+}
+function pathsEqual(first, second) {
+    return first.length === second.length && first.every((value, index) => value === second[index]);
+}
+function formatParentPath(parentPath) {
+    return parentPath.length === 0 ? '<root>' : parentPath.join('/');
+}
 export function listScreenIdsInRouteOrder(routes) {
     return collectScreenRouteEntries(routes).map((entry) => entry.screenId);
 }
@@ -112,6 +323,8 @@ export function listScreenIdsInRouteOrder(routes) {
  * back to the first route that reaches an available screen.
  */
 export function resolveInitialScreenId(navigator, screens) {
+    if (screens && !hasCanonicalStudioScreenRegistryIdentity(screens))
+        return null;
     const initialRoute = navigator.initialRouteName
         ? navigator.routes.find((route) => route.name === navigator.initialRouteName)
         : undefined;
@@ -125,22 +338,22 @@ export function resolveInitialScreenId(navigator, screens) {
                 return nestedScreenId;
         }
         if (route.screenId && (!screens || screens[route.screenId])) {
-            return route.screenId;
+            return screens ? (screens[route.screenId]?.id ?? null) : route.screenId;
         }
     }
     return null;
 }
 export function resolveInitialActiveScreenId(manifest) {
-    if (!manifest)
+    if (!manifest || !hasCanonicalStudioScreenRegistryIdentity(manifest.screens))
         return null;
     const firstRoutedScreenId = resolveInitialScreenId(manifest.navigator, manifest.screens);
-    const [firstScreenId] = Object.keys(manifest.screens);
+    const [firstScreenId] = Object.values(manifest.screens).map((screen) => screen.id);
     return firstRoutedScreenId ?? firstScreenId ?? null;
 }
 export function resolveActiveRootNode(manifest, activeScreenId) {
     if (!manifest || !activeScreenId)
         return null;
-    return manifest.screens[activeScreenId]?.root ?? null;
+    return resolveCanonicalStudioScreen(manifest, activeScreenId)?.root ?? null;
 }
 export function findNodeInManifest(root, id) {
     if (root.id === id)
@@ -158,9 +371,11 @@ export function resolveSafeSelectedNodeId(rootNode, selectedNodeId) {
     return findNodeInManifest(rootNode, selectedNodeId) ? selectedNodeId : null;
 }
 export function findScreenIdForNode(manifest, nodeId) {
-    for (const [screenId, screen] of Object.entries(manifest.screens)) {
+    if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens))
+        return null;
+    for (const screen of Object.values(manifest.screens)) {
         if (findNodeInManifest(screen.root, nodeId)) {
-            return screenId;
+            return screen.id;
         }
     }
     return null;
@@ -168,7 +383,7 @@ export function findScreenIdForNode(manifest, nodeId) {
 export function updateStudioManifestNode(manifest, activeScreenId, nodeId, newProps) {
     if (!activeScreenId)
         return manifest;
-    const screen = manifest.screens[activeScreenId];
+    const screen = resolveCanonicalStudioScreen(manifest, activeScreenId);
     if (!screen)
         return manifest;
     const newRoot = updateNodeInManifestTree(screen.root, nodeId, newProps);
@@ -188,13 +403,17 @@ export function updateStudioManifestNode(manifest, activeScreenId, nodeId, newPr
 export function deleteStudioManifestNode(manifest, activeScreenId, nodeId) {
     if (!activeScreenId)
         return manifest;
-    const screen = manifest.screens[activeScreenId];
+    const screen = resolveCanonicalStudioScreen(manifest, activeScreenId);
     if (!screen || screen.root.id === nodeId)
         return manifest;
+    const deletedNode = findNodeInManifest(screen.root, nodeId);
+    if (!deletedNode)
+        return manifest;
     const newRoot = removeNodeFromManifestTree(screen.root, nodeId);
     if (!newRoot || newRoot === screen.root)
         return manifest;
-    const nextDataBindings = Object.fromEntries(Object.entries(manifest.dataBindings ?? {}).filter(([componentId]) => componentId !== nodeId));
+    const deletedNodeIds = collectNodeIds(deletedNode);
+    const nextDataBindings = Object.fromEntries(Object.entries(manifest.dataBindings ?? {}).filter(([componentId, binding]) => !deletedNodeIds.has(componentId) && !deletedNodeIds.has(binding.componentId)));
     return {
         ...manifest,
         dataBindings: nextDataBindings,
@@ -207,42 +426,20 @@ export function deleteStudioManifestNode(manifest, activeScreenId, nodeId) {
         },
     };
 }
-export function moveStudioManifestNode(manifest, activeScreenId, nodeId, direction) {
-    if (!activeScreenId)
-        return manifest;
-    const screen = manifest.screens[activeScreenId];
-    if (!screen)
-        return manifest;
-    const newRoot = moveNodeInManifestTree(screen.root, nodeId, direction);
-    if (newRoot === screen.root)
-        return manifest;
-    return {
-        ...manifest,
-        screens: {
-            ...manifest.screens,
-            [activeScreenId]: {
-                ...screen,
-                root: newRoot,
-            },
-        },
-    };
-}
 export function insertStudioManifestNodeAtPlacement(args) {
     const { manifest, activeScreenId, placement, newNode, componentMeta } = args;
     if (!activeScreenId)
         return null;
-    const screen = manifest.screens[activeScreenId];
+    const screen = resolveCanonicalStudioScreen(manifest, activeScreenId);
     if (!screen)
         return null;
-    if (!validateManifestNodePlacement(screen.root, placement, newNode.type, componentMeta))
-        return null;
-    const insertion = insertChildAtIndex({
-        node: screen.root,
-        parentId: placement.parentId,
-        index: placement.index,
-        newNode,
+    const insertion = insertNodeAtPlacement({
+        root: screen.root,
+        placement,
+        componentMeta,
+        makeNode: () => newNode,
     });
-    if (!insertion.inserted)
+    if (!insertion)
         return null;
     return {
         manifest: {
@@ -251,7 +448,7 @@ export function insertStudioManifestNodeAtPlacement(args) {
                 ...manifest.screens,
                 [activeScreenId]: {
                     ...screen,
-                    root: insertion.node,
+                    root: insertion.root,
                 },
             },
         },
@@ -262,32 +459,16 @@ export function moveStudioManifestNodeToPlacement(args) {
     const { manifest, activeScreenId, nodeId, placement, componentMeta } = args;
     if (!activeScreenId)
         return null;
-    const screen = manifest.screens[activeScreenId];
+    const screen = resolveCanonicalStudioScreen(manifest, activeScreenId);
     if (!screen)
         return null;
-    const source = findNodeWithParent(screen.root, nodeId);
-    if (!source?.parent)
-        return null;
-    if (placement.parentId === nodeId)
-        return null;
-    if (isDescendantNode(source.node, placement.parentId))
-        return null;
-    const adjustedPlacement = adjustMovePlacement({ source, placement });
-    if (!adjustedPlacement)
-        return null;
-    const removed = removeNodeForMove({ node: screen.root, nodeId });
-    if (!removed.removedNode)
-        return null;
-    if (!validateManifestNodePlacement(removed.node, adjustedPlacement, removed.removedNode.type, componentMeta)) {
-        return null;
-    }
-    const inserted = insertChildAtIndex({
-        node: removed.node,
-        parentId: adjustedPlacement.parentId,
-        index: adjustedPlacement.index,
-        newNode: removed.removedNode,
+    const movement = moveNodeToPlacement({
+        root: screen.root,
+        nodeId,
+        placement,
+        componentMeta,
     });
-    if (!inserted.inserted)
+    if (!movement)
         return null;
     return {
         manifest: {
@@ -296,11 +477,11 @@ export function moveStudioManifestNodeToPlacement(args) {
                 ...manifest.screens,
                 [activeScreenId]: {
                     ...screen,
-                    root: inserted.node,
+                    root: movement.root,
                 },
             },
         },
-        movedNodeId: removed.removedNode.id,
+        movedNodeId: movement.movedNodeId,
     };
 }
 export function updateStudioManifestDataBindings(manifest, dataBindings) {
@@ -453,7 +634,10 @@ export function findRoutesAtParentPath(routes, parentPath) {
     const [segment, ...rest] = parentPath;
     if (!segment)
         return null;
-    const route = routes.find((item) => item.name === segment);
+    const matches = routes.filter((item) => item.name === segment);
+    if (matches.length !== 1)
+        return null;
+    const [route] = matches;
     if (!route?.navigator?.routes)
         return null;
     return findRoutesAtParentPath(route.navigator.routes, rest);
@@ -462,8 +646,12 @@ export function insertRouteAtParentPath(routes, parentPath, newRoute) {
     if (parentPath.length === 0)
         return [...routes, newRoute];
     const [segment, ...rest] = parentPath;
+    const matches = routes.filter((route) => route.name === segment && route.navigator);
+    if (matches.length !== 1)
+        return routes;
+    const [targetRoute] = matches;
     return routes.map((route) => {
-        if (route.name !== segment || !route.navigator?.routes)
+        if (route !== targetRoute || !route.navigator?.routes)
             return route;
         return {
             ...route,
@@ -480,7 +668,10 @@ export function findNavigatorAtPath(navigator, parentPath) {
     const [segment, ...rest] = parentPath;
     if (!segment)
         return null;
-    const route = navigator.routes.find((item) => item.name === segment);
+    const matches = navigator.routes.filter((item) => item.name === segment);
+    if (matches.length !== 1)
+        return null;
+    const [route] = matches;
     if (!route?.navigator)
         return null;
     return findNavigatorAtPath(route.navigator, rest);
@@ -489,10 +680,14 @@ export function updateNavigatorAtPath(navigator, parentPath, updater) {
     if (parentPath.length === 0)
         return updater(navigator);
     const [segment, ...rest] = parentPath;
+    const matches = navigator.routes.filter((route) => route.name === segment && route.navigator);
+    if (matches.length !== 1)
+        return navigator;
+    const [targetRoute] = matches;
     return {
         ...navigator,
         routes: navigator.routes.map((route) => {
-            if (route.name !== segment || !route.navigator)
+            if (route !== targetRoute || !route.navigator)
                 return route;
             return {
                 ...route,
@@ -502,6 +697,8 @@ export function updateNavigatorAtPath(navigator, parentPath, updater) {
     };
 }
 export function setStudioManifestNavigatorType(manifest, type) {
+    if (!NAVIGATOR_TYPES.includes(type))
+        return manifest;
     const primaryNavigatorPath = getPrimaryNavigatorPath(manifest.navigator.routes);
     const currentNavigator = findNavigatorAtPath(manifest.navigator, primaryNavigatorPath);
     if (!currentNavigator || currentNavigator.type === type)
@@ -522,8 +719,9 @@ export function setStudioManifestNavigatorInitialRoute(manifest, routeName) {
     const currentNavigator = findNavigatorAtPath(manifest.navigator, primaryNavigatorPath);
     if (!currentNavigator)
         return manifest;
-    if (!currentNavigator.routes.some((route) => route.name === normalizedRoute))
+    if (currentNavigator.routes.filter((route) => route.name === normalizedRoute).length !== 1) {
         return manifest;
+    }
     if (currentNavigator.initialRouteName === normalizedRoute)
         return manifest;
     return {
@@ -534,26 +732,82 @@ export function setStudioManifestNavigatorInitialRoute(manifest, routeName) {
         })),
     };
 }
+export function setStudioManifestRoutePrimaryNavigationVisibility(args) {
+    const { manifest, parentPath, routeName, showInPrimaryNavigation } = args;
+    const navigator = findNavigatorAtPath(manifest.navigator, parentPath);
+    if (!navigator)
+        return manifest;
+    const matches = navigator.routes.filter((route) => route.name === routeName);
+    if (matches.length !== 1)
+        return manifest;
+    const [matchedRoute] = matches;
+    if (!matchedRoute)
+        return manifest;
+    const alreadyCanonical = showInPrimaryNavigation
+        ? matchedRoute.showInPrimaryNavigation === undefined
+        : matchedRoute.showInPrimaryNavigation === false;
+    if (alreadyCanonical)
+        return manifest;
+    return {
+        ...manifest,
+        navigator: updateNavigatorAtPath(manifest.navigator, parentPath, (current) => ({
+            ...current,
+            routes: current.routes.map((route) => {
+                if (route !== matchedRoute)
+                    return route;
+                if (!showInPrimaryNavigation) {
+                    return { ...route, showInPrimaryNavigation: false };
+                }
+                const { showInPrimaryNavigation: _visibility, ...visibleRoute } = route;
+                return visibleRoute;
+            }),
+        })),
+    };
+}
+export function moveStudioManifestRoute(args) {
+    const { manifest, parentPath, routeName, toIndex } = args;
+    if (!Number.isInteger(toIndex))
+        return manifest;
+    const navigator = findNavigatorAtPath(manifest.navigator, parentPath);
+    if (!navigator || toIndex < 0 || toIndex >= navigator.routes.length)
+        return manifest;
+    const matchingIndexes = navigator.routes.flatMap((route, index) => route.name === routeName ? [index] : []);
+    if (matchingIndexes.length !== 1)
+        return manifest;
+    const [fromIndex] = matchingIndexes;
+    if (fromIndex === undefined || fromIndex === toIndex)
+        return manifest;
+    return {
+        ...manifest,
+        navigator: updateNavigatorAtPath(manifest.navigator, parentPath, (current) => {
+            const routes = [...current.routes];
+            const [route] = routes.splice(fromIndex, 1);
+            if (!route)
+                return current;
+            routes.splice(toIndex, 0, route);
+            return { ...current, routes };
+        }),
+    };
+}
 export function addStudioManifestScreen(args) {
     const { manifest, activeScreenId, createId = generateManifestStateId } = args;
+    if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens)) {
+        return { manifest, activeScreenId };
+    }
     const trimmedName = args.name.trim();
     if (!trimmedName)
         return { manifest, activeScreenId };
     const baseRouteName = normalizeRouteName(trimmedName);
-    const activeParentPath = activeScreenId
-        ? findParentPathForScreenId(manifest.navigator.routes, activeScreenId)
-        : null;
-    const fallbackParentPath = getPrimaryNavigatorPath(manifest.navigator.routes);
-    const activeParentRoutes = activeParentPath !== null
-        ? findRoutesAtParentPath(manifest.navigator.routes, activeParentPath)
-        : null;
-    const parentPath = activeParentPath && activeParentRoutes ? activeParentPath : fallbackParentPath;
-    const siblingRoutes = findRoutesAtParentPath(manifest.navigator.routes, parentPath) ?? [];
+    const parentPath = args.parentPath ?? getPrimaryNavigatorPath(manifest.navigator.routes);
+    const siblingRoutes = findRoutesAtParentPath(manifest.navigator.routes, parentPath);
+    if (!siblingRoutes)
+        return { manifest, activeScreenId };
+    const existingScreenIds = new Set(Object.values(manifest.screens).map((screen) => screen.id));
     let screenId = createId('Screen');
-    while (manifest.screens[screenId]) {
+    while (manifest.screens[screenId] || existingScreenIds.has(screenId)) {
         screenId = createId('Screen');
     }
-    const existingPatterns = new Set(collectScreenRouteEntries(manifest.navigator.routes).map((entry) => toCanonicalRoutePattern(entry.routePath)));
+    const existingPatterns = new Set(collectCanonicalRoutePatterns(manifest.navigator.routes));
     const routeName = makeUniqueRouteNameForParent(baseRouteName, siblingRoutes, parentPath, existingPatterns);
     const newScreen = {
         id: screenId,
@@ -581,46 +835,33 @@ export function addStudioManifestScreen(args) {
     };
 }
 export function deleteStudioManifestScreen(manifest, screenId, activeScreenId) {
+    if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens)) {
+        return { manifest, activeScreenId };
+    }
     if (Object.keys(manifest.screens).length <= 1)
         return { manifest, activeScreenId };
+    const deletedScreen = manifest.screens[screenId];
+    if (!deletedScreen)
+        return { manifest, activeScreenId };
     const { [screenId]: _deletedScreen, ...remainingScreens } = manifest.screens;
     const remainingScreenIds = Object.keys(remainingScreens);
-    let safeRoutes = removeScreenIdFromRoutes(manifest.navigator.routes, screenId);
-    if (safeRoutes.length === 0 && remainingScreenIds.length > 0) {
-        const [fallbackScreenId] = remainingScreenIds;
-        if (!fallbackScreenId)
-            return { manifest, activeScreenId };
-        const fallbackScreen = remainingScreens[fallbackScreenId];
-        safeRoutes = [
-            {
-                name: makeUniqueSiblingRouteName('screen', []),
-                label: fallbackScreen?.name ?? 'Screen',
-                screenId: fallbackScreenId,
-            },
-        ];
-    }
+    const safeRoutes = removeScreenIdFromRoutes(manifest.navigator.routes, screenId);
     const orderedScreenIds = listScreenIdsInRouteOrder(safeRoutes).filter((id) => !!remainingScreens[id]);
     const nextActiveScreenId = !activeScreenId || activeScreenId === screenId || !remainingScreens[activeScreenId]
         ? (orderedScreenIds[0] ?? remainingScreenIds[0] ?? null)
         : activeScreenId;
+    const deletedNodeIds = collectNodeIds(deletedScreen.root);
+    const dataBindings = Object.fromEntries(Object.entries(manifest.dataBindings ?? {}).filter(([componentId, binding]) => !deletedNodeIds.has(componentId) && !deletedNodeIds.has(binding.componentId)));
     return {
         activeScreenId: nextActiveScreenId,
         manifest: {
             ...manifest,
+            dataBindings,
             screens: remainingScreens,
-            navigator: {
+            navigator: normalizeNavigatorAfterRouteUpdate({
                 ...manifest.navigator,
                 routes: safeRoutes,
-            },
-        },
-    };
-}
-export function reorderStudioManifestScreens(manifest, newRoutes) {
-    return {
-        ...manifest,
-        navigator: {
-            ...manifest.navigator,
-            routes: newRoutes,
+            }),
         },
     };
 }
@@ -686,6 +927,17 @@ function normalizeRouteName(value) {
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '') || 'screen');
 }
+function collectCanonicalRoutePatterns(routes, runtimePathPrefix = []) {
+    const patterns = [];
+    for (const route of routes) {
+        const runtimePath = appendRuntimeRoutePath(runtimePathPrefix, route);
+        patterns.push(toCanonicalRoutePattern(runtimePath));
+        if (route.navigator) {
+            patterns.push(...collectCanonicalRoutePatterns(route.navigator.routes, runtimePath));
+        }
+    }
+    return patterns;
+}
 function cloneNodeWithNewIds(node, createId) {
     const clonedNode = {
         ...node,
@@ -728,132 +980,15 @@ function removeNodeFromManifestTree(root, nodeId) {
     const hasChanged = nextChildren.some((child, index) => child !== root.children?.[index]);
     return hasChanged ? { ...root, children: nextChildren } : root;
 }
-function moveNodeInManifestTree(root, nodeId, direction) {
-    if (root.id === nodeId || !root.children)
-        return root;
-    const index = root.children.findIndex((child) => child.id === nodeId);
-    if (index !== -1) {
-        const targetIndex = direction === 'up' ? index - 1 : index + 1;
-        if (targetIndex < 0 || targetIndex >= root.children.length)
-            return root;
-        const currentNode = root.children[index];
-        const targetNode = root.children[targetIndex];
-        if (!currentNode || !targetNode)
-            return root;
-        const nextChildren = [...root.children];
-        nextChildren[index] = targetNode;
-        nextChildren[targetIndex] = currentNode;
-        return { ...root, children: nextChildren };
-    }
-    const nextChildren = root.children.map((child) => moveNodeInManifestTree(child, nodeId, direction));
-    const hasChanged = nextChildren.some((child, childIndex) => child !== root.children?.[childIndex]);
-    return hasChanged ? { ...root, children: nextChildren } : root;
-}
-function findNodeWithParent(root, nodeId) {
-    if (root.id === nodeId)
-        return { node: root, parent: null, index: -1 };
+function collectNodeIds(root) {
+    const ids = new Set();
     const visit = (node) => {
-        const children = node.children ?? [];
-        for (const [index, child] of children.entries()) {
-            if (child.id === nodeId)
-                return { node: child, parent: node, index };
-            const nested = visit(child);
-            if (nested)
-                return nested;
-        }
-        return null;
+        ids.add(node.id);
+        for (const child of node.children ?? [])
+            visit(child);
     };
-    return visit(root);
-}
-function validateManifestNodePlacement(root, placement, childType, componentMeta) {
-    const parent = findNodeInManifest(root, placement.parentId);
-    if (!parent)
-        return false;
-    const meta = componentMeta[parent.type];
-    if (!meta?.allowedChildren.includes(childType))
-        return false;
-    const children = parent.children ?? [];
-    if (placement.referenceId && !children.some((child) => child.id === placement.referenceId)) {
-        return false;
-    }
-    return placement.index >= 0 && placement.index <= children.length;
-}
-function insertChildAtIndex(args) {
-    const { node, parentId, index, newNode } = args;
-    if (node.id === parentId) {
-        const children = node.children ?? [];
-        if (index < 0 || index > children.length)
-            return { node, inserted: false };
-        return {
-            node: {
-                ...node,
-                children: [...children.slice(0, index), newNode, ...children.slice(index)],
-            },
-            inserted: true,
-        };
-    }
-    if (!node.children?.length)
-        return { node, inserted: false };
-    const results = node.children.map((child) => insertChildAtIndex({ node: child, parentId, index, newNode }));
-    const inserted = results.some((result) => result.inserted);
-    return inserted
-        ? { node: { ...node, children: results.map((result) => result.node) }, inserted }
-        : { node, inserted };
-}
-function isDescendantNode(node, descendantId) {
-    for (const child of node.children ?? []) {
-        if (child.id === descendantId || isDescendantNode(child, descendantId))
-            return true;
-    }
-    return false;
-}
-function removeNodeForMove(args) {
-    const { node, nodeId } = args;
-    const children = node.children ?? [];
-    const directIndex = children.findIndex((child) => child.id === nodeId);
-    if (directIndex !== -1) {
-        const removedNode = children[directIndex];
-        if (!removedNode)
-            return { node, removedNode: null };
-        return {
-            node: {
-                ...node,
-                children: children.filter((child) => child.id !== nodeId),
-            },
-            removedNode,
-        };
-    }
-    const nextChildren = [];
-    let removedNode = null;
-    for (const child of children) {
-        if (removedNode) {
-            nextChildren.push(child);
-            continue;
-        }
-        const { node: nextChild, removedNode: nextRemovedNode } = removeNodeForMove({
-            node: child,
-            nodeId,
-        });
-        if (nextRemovedNode)
-            removedNode = nextRemovedNode;
-        nextChildren.push(nextChild);
-    }
-    if (!removedNode)
-        return { node, removedNode: null };
-    return { node: { ...node, children: nextChildren }, removedNode };
-}
-function adjustMovePlacement(args) {
-    const { source, placement } = args;
-    if (!source.parent)
-        return null;
-    if (placement.referenceId === source.node.id)
-        return null;
-    if (placement.parentId !== source.parent.id)
-        return placement;
-    const adjustedIndex = source.index < placement.index ? placement.index - 1 : placement.index;
-    if (adjustedIndex === source.index)
-        return null;
-    return { ...placement, index: adjustedIndex };
+    visit(root);
+    return ids;
 }
 function normalizeNavigatorAfterRouteUpdate(navigator) {
     const nextRoutes = navigator.routes;