@superblocksteam/vite-plugin-file-sync 2.0.167-next.0 → 2.0.168-next.0

package/dist/router-parser.js

@@ -23,8 +23,7 @@ function countRouteObjects(routes) {
         count += 1;
         for (const property of element.properties) {
             if (property.type === "ObjectProperty" &&
-                property.key.type === "Identifier" &&
-                property.key.name === "children" &&
+                getStaticPropertyKey(property) === "children" &&
                 property.value.type === "ArrayExpression") {
                 count += countRouteObjects(property.value);
             }
@@ -121,7 +120,6 @@ function extractReactRouterImports(content) {
             throw new Error("react-router import not found");
         }
         const parsedReactRouterImport = parseStaticImport(reactRouterImport);
-        // loop over named imports
         if (parsedReactRouterImport.namedImports) {
             // for each named import
             for (const [name, alias] of Object.entries(parsedReactRouterImport.namedImports)) {
@@ -245,7 +243,6 @@ async function findAllTsFiles(rootDir) {
  * Find the router file in the project (React Router v7)
  */
 export async function findRouterFile(rootDir) {
-    // Check cache first with mtime validation
     if (cachedRouterFileLocation) {
         try {
             const stats = await stat(cachedRouterFileLocation.path);
@@ -394,9 +391,72 @@ function resolveCallableMemberExpression(member, callableImportMap) {
  *   () => obj.prop()                      (when obj.prop is a known import-returning callable)
  *   () => obj.prop().then(mod => (...))   (same, with .then() chained)
  */
-function extractImportPathFromFunction(node, callableImportMap) {
+function extractImportPathFromFunction(node, ctx = {}, enclosingBindings) {
+    const { callableImportMap, unwrapHelpers } = ctx;
     const body = node.body;
+    const localBindings = new Map(enclosingBindings);
+    for (const param of node.params) {
+        for (const name of collectPatternNames(param)) {
+            localBindings.set(name, null);
+        }
+    }
     if (body.type === "BlockStatement") {
+        const returnArgs = [];
+        for (const statement of body.body) {
+            if (statement.type === "FunctionDeclaration" ||
+                statement.type === "ClassDeclaration") {
+                if (statement.id)
+                    localBindings.set(statement.id.name, null);
+            }
+            else if (statement.type === "VariableDeclaration") {
+                for (const decl of statement.declarations) {
+                    let init = decl.init;
+                    if (init?.type === "AwaitExpression")
+                        init = init.argument;
+                    if (decl.id.type === "Identifier") {
+                        localBindings.set(decl.id.name, init ?? null);
+                    }
+                    else {
+                        const traceable = init &&
+                            extractImportSpecifierFromExpression(init, callableImportMap)
+                            ? init
+                            : null;
+                        for (const name of collectPatternNames(decl.id)) {
+                            localBindings.set(name, traceable);
+                        }
+                    }
+                }
+            }
+            else if (statement.type === "ReturnStatement") {
+                let arg = statement.argument;
+                if (arg?.type === "AwaitExpression")
+                    arg = arg.argument;
+                if (arg)
+                    returnArgs.push(arg);
+            }
+        }
+        const ambiguity = ctx.ambiguity;
+        const ambiguitySeenOnEntry = ambiguity?.seen ?? false;
+        if (ambiguity)
+            ambiguity.seen = false;
+        if (unwrapHelpers) {
+            for (const arg of returnArgs) {
+                const path = extractImportPathFromLazyValue(arg, ctx, localBindings);
+                if (path) {
+                    if (ambiguity)
+                        ambiguity.seen = ambiguitySeenOnEntry;
+                    return path;
+                }
+            }
+        }
+        const returnWasAmbiguous = ambiguity?.seen ?? false;
+        if (ambiguity)
+            ambiguity.seen = ambiguitySeenOnEntry || returnWasAmbiguous;
+        if (returnWasAmbiguous) {
+            getLogger().debug("Router parser: the return traced through an ambiguous helper call; " +
+                "suppressing the source-order declaration fallback so the route drops instead of guessing.");
+            return null;
+        }
         for (const statement of body.body) {
             if (statement.type === "VariableDeclaration") {
                 for (const decl of statement.declarations) {
@@ -421,8 +481,51 @@ function extractImportPathFromFunction(node, callableImportMap) {
     }
     // Expression body — possibly wrapped in `await`
     const expr = body.type === "AwaitExpression" && body.argument ? body.argument : body;
+    if (unwrapHelpers) {
+        return extractImportPathFromLazyValue(expr, ctx, localBindings);
+    }
     return extractImportSpecifierFromExpression(expr, callableImportMap);
 }
+const LAZY_RESOLUTION_VISIT_BUDGET = 10_000;
+function newLazyResolutionBudget() {
+    return { remaining: LAZY_RESOLUTION_VISIT_BUDGET };
+}
+function collectPatternNames(pattern, names = []) {
+    switch (pattern.type) {
+        case "Identifier":
+            names.push(pattern.name);
+            break;
+        case "ObjectPattern":
+            for (const prop of pattern.properties) {
+                collectPatternNames(prop.type === "RestElement" ? prop.argument : prop.value, names);
+            }
+            break;
+        case "ArrayPattern":
+            for (const element of pattern.elements) {
+                if (element)
+                    collectPatternNames(element, names);
+            }
+            break;
+        case "AssignmentPattern":
+            collectPatternNames(pattern.left, names);
+            break;
+        case "RestElement":
+            collectPatternNames(pattern.argument, names);
+            break;
+    }
+    return names;
+}
+const STATIC_PAGE_KEYS = new Set(["Component", "element"]);
+const ROUTE_METADATA_KEYS = new Set([
+    "loader",
+    "action",
+    "ErrorBoundary",
+    "errorElement",
+    "handle",
+    "shouldRevalidate",
+    "HydrateFallback",
+    "hydrateFallbackElement",
+]);
 /**
  * Extract the page import specifier from a route loader expression: a `lazy:`
  * property value, a top-level const initializer bound as a loader, or a
@@ -443,23 +546,75 @@ function extractImportPathFromFunction(node, callableImportMap) {
  * route and the editor renders the "404 / route has been deleted" overlay over
  * an app that actually works.
  *
- * An `Identifier` resolves through `lazyLoaderBindings` (a const bound to a
- * loader, e.g. `const overview = lazyPage(...); { lazy: overview }`), at any
- * nesting depth — `overview`, `(overview as any)`, `withAuth(overview)`.
  *
- * Limitation: when a helper receives multiple import-bearing arguments (e.g.
- * `withFallback(() => import("./a"), () => import("./b"))`), the first import
- * found wins. Every real/tested loader shape carries exactly one importer.
  */
-function extractImportPathFromLazyValue(node, callableImportMap, lazyLoaderBindings) {
+function extractImportPathFromLazyValue(node, ctx = {}, localBindings) {
+    const { callableImportMap, lazyLoaderBindings, allImports, unwrapHelpers } = ctx;
+    if (ctx.budget) {
+        if (ctx.budget.remaining <= 0)
+            return null;
+        ctx.budget.remaining -= 1;
+        if (ctx.budget.remaining === 0) {
+            getLogger().debug("Router parser: lazy-value resolution visit budget exhausted; giving up on this value.");
+        }
+    }
+    const recurse = (child, bindings = localBindings) => extractImportPathFromLazyValue(child, ctx, bindings);
     node = unwrapTsWrappers(node);
-    // `lazy: overview` — a const bound to a loader elsewhere in the file.
     if (node.type === "Identifier") {
-        return lazyLoaderBindings?.get(node.name) ?? null;
+        if (localBindings?.has(node.name)) {
+            const localInit = localBindings.get(node.name);
+            if (!localInit)
+                return null;
+            const withoutSelf = new Map(localBindings);
+            withoutSelf.delete(node.name);
+            return recurse(localInit, withoutSelf);
+        }
+        return (lazyLoaderBindings?.get(node.name) ?? allImports?.get(node.name) ?? null);
+    }
+    if (node.type === "AwaitExpression" && node.argument) {
+        return recurse(node.argument);
     }
     if (node.type === "ArrowFunctionExpression" ||
         node.type === "FunctionExpression") {
-        return extractImportPathFromFunction(node, callableImportMap);
+        return extractImportPathFromFunction(node, ctx, localBindings);
+    }
+    if (unwrapHelpers && node.type === "ObjectExpression") {
+        const resolveValue = (value, valueCtx, bindings = localBindings) => {
+            if (value.type === "ArrowFunctionExpression" ||
+                value.type === "FunctionExpression") {
+                return null;
+            }
+            return extractImportPathFromLazyValue(value, valueCtx, bindings);
+        };
+        const pageKeys = resolveReturnedObjectPageKeys(node, (value, bindings) => resolveValue(value, ctx, bindings), localBindings);
+        if (pageKeys.sawStaticPageKey)
+            return pageKeys.path;
+        const fallbackCtx = { ...ctx, allImports: undefined };
+        for (const prop of node.properties) {
+            let value = null;
+            if (prop.type === "SpreadElement") {
+                value = prop.argument;
+            }
+            else if (prop.type === "ObjectProperty") {
+                const key = getStaticPropertyKey(prop);
+                if (key !== null &&
+                    (STATIC_PAGE_KEYS.has(key) || ROUTE_METADATA_KEYS.has(key))) {
+                    continue;
+                }
+                value = prop.value;
+            }
+            if (!value)
+                continue;
+            const path = resolveValue(value, fallbackCtx);
+            if (path)
+                return path;
+        }
+        return null;
+    }
+    if (unwrapHelpers &&
+        node.type === "MemberExpression" &&
+        (!node.computed || node.property.type === "StringLiteral")) {
+        return recurse(node.object);
     }
     if (node.type === "CallExpression") {
         // The call itself may already resolve to an import: `import("...")`,
@@ -472,18 +627,74 @@ function extractImportPathFromLazyValue(node, callableImportMap, lazyLoaderBindi
         // callee's object (the wrapper call), not in this call's arguments.
         if (node.callee.type === "MemberExpression" &&
             node.callee.object.type === "CallExpression") {
-            const fromWrapper = extractImportPathFromLazyValue(node.callee.object, callableImportMap, lazyLoaderBindings);
+            const fromWrapper = recurse(node.callee.object);
             if (fromWrapper)
                 return fromWrapper;
         }
         // Helper-wrapped importer, possibly nested (e.g.
-        // `withAuth(lazyPage(() => import("...")))`). Recurse into each argument so
-        // any depth of wrapping still yields the underlying import.
+        const argCtx = { ...ctx, allImports: undefined };
+        const argSpecifiers = [];
         for (const arg of node.arguments) {
-            const path = extractImportPathFromLazyValue(arg, callableImportMap, lazyLoaderBindings);
-            if (path)
-                return path;
+            const path = extractImportPathFromLazyValue(arg, argCtx, localBindings);
+            if (path && !argSpecifiers.includes(path))
+                argSpecifiers.push(path);
         }
+        if (argSpecifiers.length > 1) {
+            if (ctx.ambiguity)
+                ctx.ambiguity.seen = true;
+            if (unwrapHelpers) {
+                getLogger().debug(`Router parser: helper call carries ${argSpecifiers.length} distinct import specifiers (${argSpecifiers.join(", ")}); treating the call as unresolved.`);
+            }
+            return null;
+        }
+        if (ctx.ambiguity?.seen)
+            return null;
+        if (argSpecifiers.length === 1)
+            return argSpecifiers[0] ?? null;
+    }
+    return null;
+}
+function resolveReturnedObjectPageKeys(obj, resolveValue, localBindings) {
+    let sawStaticPageKey = false;
+    let path = null;
+    for (const prop of obj.properties) {
+        if (prop.type === "SpreadElement") {
+            const literal = resolveSpreadObjectLiteral(prop.argument, localBindings);
+            if (!literal)
+                continue;
+            const inner = resolveReturnedObjectPageKeys(literal.object, resolveValue, literal.bindings);
+            if (inner.sawStaticPageKey) {
+                sawStaticPageKey = true;
+                path = inner.path;
+            }
+            continue;
+        }
+        const key = getStaticPropertyKey(prop);
+        if (key === null || !STATIC_PAGE_KEYS.has(key))
+            continue;
+        sawStaticPageKey = true;
+        path =
+            prop.type === "ObjectProperty"
+                ? resolveValue(prop.value, localBindings)
+                : null;
+    }
+    return { sawStaticPageKey, path };
+}
+function resolveSpreadObjectLiteral(argument, localBindings) {
+    const unwrapped = unwrapTsWrappers(argument);
+    if (unwrapped.type === "ObjectExpression") {
+        return { object: unwrapped, bindings: localBindings };
+    }
+    if (unwrapped.type === "Identifier" && localBindings?.has(unwrapped.name)) {
+        const init = localBindings.get(unwrapped.name);
+        if (!init)
+            return null;
+        const literal = unwrapTsWrappers(init);
+        if (literal.type !== "ObjectExpression")
+            return null;
+        const withoutSelf = new Map(localBindings);
+        withoutSelf.delete(unwrapped.name);
+        return { object: literal, bindings: withoutSelf };
     }
     return null;
 }
@@ -502,6 +713,14 @@ function unwrapTsWrappers(node) {
     }
     return node;
 }
+function isUntraceableLazyModuleReference(node, allImports, lazyLoaderBindings) {
+    if (node.type === "Identifier") {
+        return !(lazyLoaderBindings?.has(node.name) ?? false);
+    }
+    return (node.type === "MemberExpression" &&
+        node.object.type === "Identifier" &&
+        allImports.has(node.object.name));
+}
 /**
  * Static key of an object member: identifier (`lazy:`) or string literal
  * (`"lazy":`). Computed keys are not statically knowable and return null.
@@ -542,6 +761,16 @@ function classifyRouteFragment(obj) {
     }
     return sawUnknowableKey ? "unknown" : "non-page";
 }
+function fragmentHasStaticPageKey(obj) {
+    for (const prop of obj.properties) {
+        if (prop.type === "SpreadElement")
+            continue;
+        const name = getStaticPropertyKey(prop);
+        if (name && STATIC_PAGE_KEYS.has(name))
+            return true;
+    }
+    return false;
+}
 /**
  * Classify a local factory by the object literal it returns. Only bodies
  * made of straight-line statements are inspected; anything that could hide
@@ -573,17 +802,16 @@ function classifyLocalFactory(fn) {
     }
     return { shape: "unknown", fragment: null };
 }
-/**
- * Extract the page import from an object literal spread into a route
- * (`...{ lazy: () => import("...") }` or a const bound to one). Later page
- * keys override earlier ones, matching runtime object semantics. Broader
- * than the explicit-property loop by design: classifyRouteFragment counts
- * method shorthand and string-literal keys as page-bearing, so extraction
- * must recognize the same shapes or a "page" fragment would silently
- * extract nothing.
- */
 function extractPageImportFromFragment(fragment, allImports, callableImportMap, lazyLoaderBindings) {
     let importPath = null;
+    const lazyCtx = {
+        callableImportMap,
+        lazyLoaderBindings,
+        allImports,
+        unwrapHelpers: true,
+        budget: newLazyResolutionBudget(),
+        ambiguity: { seen: false },
+    };
     for (const prop of fragment.properties) {
         if (prop.type === "SpreadElement")
             continue;
@@ -592,14 +820,17 @@ function extractPageImportFromFragment(fragment, allImports, callableImportMap,
             continue;
         if (prop.type === "ObjectMethod") {
             if (key === "lazy") {
-                const path = extractImportPathFromFunction(prop, callableImportMap);
+                const path = extractImportPathFromFunction(prop, lazyCtx);
                 if (path)
                     importPath = path;
             }
             continue;
         }
         if (key === "lazy") {
-            const path = extractImportPathFromLazyValue(prop.value, callableImportMap, lazyLoaderBindings);
+            const lazyValue = unwrapTsWrappers(prop.value);
+            const path = isUntraceableLazyModuleReference(lazyValue, allImports, lazyLoaderBindings)
+                ? null
+                : extractImportPathFromLazyValue(prop.value, lazyCtx);
             if (path)
                 importPath = path;
         }
@@ -614,20 +845,6 @@ function extractPageImportFromFragment(fragment, allImports, callableImportMap,
     }
     return importPath;
 }
-/**
- * Resolve what a route-object spread contributes to the route's page.
- *
- * "page": the spread verifiably carries a page key (an object literal, a
- * const bound to one, or a local factory call, direct or through a const,
- * whose return shape is inspectable); its import participates like an
- * explicit property.
- * "none": the spread verifiably carries no page key and must be ignored, so
- * a loader-only helper's import is never mistaken for the page.
- * "heuristic": the parser cannot classify the contribution (an imported
- * factory, or an indirection it does not chase); the first import found in
- * the expression is offered as a fallback for the caller to use only when
- * nothing verified resolves.
- */
 function resolveSpreadContribution(argument, allImports, callableImportMap, lazyLoaderBindings, spreadBindings) {
     const unwrapped = unwrapTsWrappers(argument);
     let fragment = null;
@@ -656,6 +873,7 @@ function resolveSpreadContribution(argument, allImports, callableImportMap, lazy
             return {
                 kind: "page",
                 importPath: localOnly(extractPageImportFromFragment(fragment, allImports, callableImportMap, lazyLoaderBindings)),
+                hasStaticPageKey: fragmentHasStaticPageKey(fragment),
             };
         }
         if (shape === "non-page")
@@ -667,18 +885,34 @@ function resolveSpreadContribution(argument, allImports, callableImportMap, lazy
         if (factory?.shape === "page") {
             // The importer is usually passed in through the call's arguments; a
             // zero-argument factory instead hardcodes it in the returned fragment.
-            const fromArguments = localOnly(extractImportPathFromLazyValue(argument, callableImportMap, lazyLoaderBindings));
+            const fromArguments = localOnly(extractImportPathFromLazyValue(argument, {
+                callableImportMap,
+                lazyLoaderBindings,
+                budget: newLazyResolutionBudget(),
+                ambiguity: { seen: false },
+            }));
             const fromFragment = factory.fragment
                 ? localOnly(extractPageImportFromFragment(factory.fragment, allImports, callableImportMap, lazyLoaderBindings))
                 : null;
-            return { kind: "page", importPath: fromArguments ?? fromFragment };
+            return {
+                kind: "page",
+                importPath: fromArguments ?? fromFragment,
+                hasStaticPageKey: factory.fragment
+                    ? fragmentHasStaticPageKey(factory.fragment)
+                    : false,
+            };
         }
         if (factory?.shape === "non-page")
             return { kind: "none" };
     }
     return {
         kind: "heuristic",
-        importPath: localOnly(extractImportPathFromLazyValue(argument, callableImportMap, lazyLoaderBindings)),
+        importPath: localOnly(extractImportPathFromLazyValue(argument, {
+            callableImportMap,
+            lazyLoaderBindings,
+            budget: newLazyResolutionBudget(),
+            ambiguity: { seen: false },
+        })),
     };
 }
 /**
@@ -710,7 +944,11 @@ function extractLazyImportPath(node) {
             arg.type !== "FunctionExpression")) {
         return null;
     }
-    return extractImportPathFromFunction(arg);
+    return extractImportPathFromFunction(arg, {
+        unwrapHelpers: true,
+        budget: newLazyResolutionBudget(),
+        ambiguity: { seen: false },
+    });
 }
 /**
  * Extract all static imports
@@ -874,7 +1112,12 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
                 // from allImports so Component/element identifier resolution stays
                 // limited to actual component bindings.
                 if (isTopLevel && !lazyLoaderBindings.has(node.id.name)) {
-                    const loaderImportPath = extractImportPathFromLazyValue(node.init, callableImportMap, lazyLoaderBindings);
+                    const loaderImportPath = extractImportPathFromLazyValue(node.init, {
+                        callableImportMap,
+                        lazyLoaderBindings,
+                        budget: newLazyResolutionBudget(),
+                        ambiguity: { seen: false },
+                    });
                     if (loaderImportPath && isLocalModuleSpecifier(loaderImportPath)) {
                         lazyLoaderBindings.set(node.id.name, loaderImportPath);
                     }
@@ -916,7 +1159,6 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
                 }
             },
         });
-        // Process routes asynchronously after traverse
         if (routesArray) {
             await extractRoutesFromArray(routesArray, routes, routerFilePath, rootDir, "", allImports, callableImportMap, lazyLoaderBindings, spreadBindings);
             if (routeObjectCount > 0 && routes.length === 0) {
@@ -954,8 +1196,10 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
     let pageImportPath = null;
     let children = null;
     let hasIndex = false;
+    let unresolvedLazy = null;
     let heuristicSpreadImportPath = null;
     let sawUnresolvedPageSpread = false;
+    let hasAuthoritativeStaticPage = false;
     for (const prop of node.properties) {
         // A route may receive its page property through a spread instead of a
         // literal key: `{ path: "/home", ...gatedLazy(() => import("...")) }`.
@@ -966,16 +1210,14 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
         if (prop.type === "SpreadElement") {
             const contribution = resolveSpreadContribution(prop.argument, allImports, callableImportMap, lazyLoaderBindings, spreadBindings);
             if (contribution.kind === "page") {
+                if (!contribution.hasStaticPageKey && hasAuthoritativeStaticPage) {
+                    continue;
+                }
+                hasAuthoritativeStaticPage = false;
                 if (contribution.importPath) {
                     pageImportPath = contribution.importPath;
                 }
                 else {
-                    // The spread verifiably carries the route's page and it could not
-                    // be resolved. At runtime it overrides whatever came before it, so
-                    // an earlier contributor's import is discarded and the heuristic
-                    // fallback suppressed; mapping either would point the route at a
-                    // file the router no longer renders. The route drops unless a
-                    // later contributor resolves.
                     pageImportPath = null;
                     sawUnresolvedPageSpread = true;
                     getLogger().debug(`Router parser: a spread on route "${routePath ?? "(index)"}" in ${routerFilePath} ` +
@@ -990,7 +1232,7 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
         }
         if (prop.type !== "ObjectProperty")
             continue;
-        const key = prop.key.type === "Identifier" ? prop.key.name : null;
+        const key = getStaticPropertyKey(prop);
         if (key === "path" && prop.value.type === "StringLiteral") {
             routePath = prop.value.value;
         }
@@ -998,15 +1240,40 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
             hasIndex = prop.value.value;
         }
         else if (key === "lazy") {
-            const path = extractImportPathFromLazyValue(prop.value, callableImportMap, lazyLoaderBindings);
-            if (path)
-                pageImportPath = path;
+            const lazyValue = unwrapTsWrappers(prop.value);
+            const isUntraceableModuleReference = isUntraceableLazyModuleReference(lazyValue, allImports, lazyLoaderBindings);
+            const path = isUntraceableModuleReference
+                ? null
+                : extractImportPathFromLazyValue(prop.value, {
+                    callableImportMap,
+                    lazyLoaderBindings,
+                    allImports,
+                    unwrapHelpers: true,
+                    budget: newLazyResolutionBudget(),
+                    ambiguity: { seen: false },
+                });
+            if (path) {
+                if (!hasAuthoritativeStaticPage) {
+                    pageImportPath = path;
+                }
+            }
+            else {
+                unresolvedLazy = {
+                    type: prop.value.type,
+                    line: prop.value.loc?.start.line ?? null,
+                };
+                if (!hasAuthoritativeStaticPage) {
+                    pageImportPath = null;
+                    heuristicSpreadImportPath = null;
+                }
+            }
         }
         else if (key === "Component" && prop.value.type === "Identifier") {
             // Component property uses an identifier: Component: HomePage
             const componentName = prop.value.name;
             if (allImports.has(componentName)) {
                 pageImportPath = allImports.get(componentName);
+                hasAuthoritativeStaticPage = true;
             }
             else {
                 logUnresolvedComponent("Component", componentName, routerFilePath);
@@ -1016,6 +1283,7 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
             const elementImportPath = resolveElementImportPath(prop.value, allImports);
             if (elementImportPath) {
                 pageImportPath = elementImportPath;
+                hasAuthoritativeStaticPage = true;
             }
             else if (prop.value.type === "CallExpression") {
                 const callee = prop.value.callee.type === "Identifier"
@@ -1039,10 +1307,14 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
         heuristicSpreadImportPath &&
         !sawUnresolvedPageSpread) {
         pageImportPath = heuristicSpreadImportPath;
-        getLogger().debug(`Router parser: route "${routePath ?? "(index)"}" in ${routerFilePath} has no verified page property; ` +
+        getLogger().debug(`Router parser: route "${routePath ?? "(index)"}" in ${routerFilePath} has no page property the parser could resolve; ` +
             `treating import "${heuristicSpreadImportPath}" from a spread the parser could not classify as the page. ` +
             `If that spread contributes a loader rather than a page, the mapping will be wrong.`);
     }
+    if (!pageImportPath && unresolvedLazy) {
+        const routeLabel = routePath ?? `index under "${parentPath || "/"}"`;
+        getLogger().debug(`Router parser: could not resolve lazy value (${unresolvedLazy.type}) for route "${routeLabel}" at line ${unresolvedLazy.line ?? "?"} in ${routerFilePath}; the route will not appear in the page list.`);
+    }
     // Check if any children have index: true
     let hasIndexChild = false;
     if (children) {
@@ -1050,8 +1322,7 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
             if (child && child.type === "ObjectExpression") {
                 for (const prop of child.properties) {
                     if (prop.type === "ObjectProperty" &&
-                        prop.key.type === "Identifier" &&
-                        prop.key.name === "index" &&
+                        getStaticPropertyKey(prop) === "index" &&
                         prop.value.type === "BooleanLiteral" &&
                         prop.value.value === true) {
                         hasIndexChild = true;