@codelionapps/unharness 0.0.0-stage → 0.1.1

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/router-utils/instrumentation-globals.external.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ensureInstrumentationRegistered: null,
+    ensureInstrumentationRegisteredWithDeferredSpans: null,
+    getInstrumentationModule: null,
+    instrumentationOnRequestError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ensureInstrumentationRegistered: function() {
+        return ensureInstrumentationRegistered;
+    },
+    ensureInstrumentationRegisteredWithDeferredSpans: function() {
+        return ensureInstrumentationRegisteredWithDeferredSpans;
+    },
+    getInstrumentationModule: function() {
+        return getInstrumentationModule;
+    },
+    instrumentationOnRequestError: function() {
+        return instrumentationOnRequestError;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../lib/is-error"));
+const _constants = require("../../../lib/constants");
+const _interopdefault = require("../../../lib/interop-default");
+const _instrumentationnodeextensions = require("./instrumentation-node-extensions");
+const _tracer = require("../trace/tracer");
+const _constants1 = require("../trace/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let cachedInstrumentationModule;
+let instrumentationModuleLoadTiming;
+function getInstrumentationTimestamp() {
+    // Date.now() is treated as synchronous I/O while Cache Components render.
+    return performance.timeOrigin + performance.now();
+}
+function traceBackdatedInstrumentationSpan({ type, spanName, timing: { startTime, endTime, error } }) {
+    (0, _tracer.getTracer)().trace(type, {
+        spanName,
+        startTime,
+        endTime
+    }, error === undefined ? ()=>undefined : (span)=>{
+        span == null ? void 0 : span.recordException(error);
+        if ((0, _iserror.default)(error)) {
+            span == null ? void 0 : span.setAttribute('error.type', error.name);
+        }
+        span == null ? void 0 : span.setStatus({
+            code: _tracer.SpanStatusCode.ERROR,
+            message: (0, _iserror.default)(error) ? error.message : undefined
+        });
+    });
+}
+/**
+ * Takes the recorded timing of loading the instrumentation module, if not
+ * emitted yet, as a lifecycle span.
+ */ function takeInstrumentationModuleLoadSpan() {
+    if (!instrumentationModuleLoadTiming) return undefined;
+    const timing = instrumentationModuleLoadTiming;
+    instrumentationModuleLoadTiming = undefined;
+    return {
+        type: _constants1.InstrumentationSpan.loadModule,
+        spanName: 'load instrumentation module',
+        timing
+    };
+}
+function traceInstrumentationModuleLoad() {
+    const span = takeInstrumentationModuleLoadSpan();
+    if (span) {
+        traceBackdatedInstrumentationSpan(span);
+    }
+}
+async function getInstrumentationModule(projectDir, distDir) {
+    if (cachedInstrumentationModule) {
+        return cachedInstrumentationModule;
+    }
+    const startTime = getInstrumentationTimestamp();
+    let error;
+    try {
+        cachedInstrumentationModule = (0, _interopdefault.interopDefault)(await require(_nodepath.default.join(projectDir, distDir, 'server', `${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`)));
+        return cachedInstrumentationModule;
+    } catch (err) {
+        if ((0, _iserror.default)(err) && err.code !== 'ENOENT' && err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+            error = err;
+            throw err;
+        }
+    } finally{
+        instrumentationModuleLoadTiming ??= {
+            startTime,
+            endTime: getInstrumentationTimestamp(),
+            error
+        };
+    }
+}
+let instrumentationModulePromise = null;
+/**
+ * Loads `instrumentation.ts` and calls its `register()`.
+ *
+ * Its lifecycle spans (`load instrumentation module`, `register
+ * instrumentation`) are backdated and emitted afterwards, since `register()`
+ * commonly installs the tracer provider. They are emitted right away in the
+ * active context, unless `deferredSpans` is given: then successfully completed
+ * steps are added to it instead, for the caller to emit in another context
+ * (the request that triggered registration). Failed steps are always emitted
+ * right away.
+ */ async function registerInstrumentation(projectDir, distDir, deferredSpans) {
+    // Ensure registerInstrumentation is not called in production build
+    if (process.env.NEXT_PHASE === 'phase-production-build') {
+        return;
+    }
+    if (!instrumentationModulePromise) {
+        instrumentationModulePromise = getInstrumentationModule(projectDir, distDir);
+    }
+    let instrumentation;
+    try {
+        instrumentation = await instrumentationModulePromise;
+    } catch (err) {
+        // A load error is only exportable when a provider was already installed.
+        traceInstrumentationModuleLoad();
+        throw err;
+    }
+    if (instrumentation == null ? void 0 : instrumentation.register) {
+        const startTime = getInstrumentationTimestamp();
+        let error;
+        let registered = false;
+        try {
+            await instrumentation.register();
+            (0, _instrumentationnodeextensions.afterRegistration)();
+            registered = true;
+        } catch (err) {
+            error = err;
+            err.message = `An error occurred while loading instrumentation hook: ${err.message}`;
+            throw err;
+        } finally{
+            const endTime = getInstrumentationTimestamp();
+            // register() commonly installs the provider, so emit both lifecycle
+            // spans afterward with their original timestamps.
+            const spans = [
+                takeInstrumentationModuleLoadSpan(),
+                {
+                    type: _constants1.InstrumentationSpan.register,
+                    spanName: 'register instrumentation',
+                    timing: {
+                        startTime,
+                        endTime,
+                        error
+                    }
+                }
+            ].filter((span)=>span !== undefined);
+            // Only defer after a successful registration: a failing request has no
+            // request span to emit them in.
+            if (deferredSpans && registered) {
+                deferredSpans.push(...spans);
+            } else {
+                spans.forEach(traceBackdatedInstrumentationSpan);
+            }
+        }
+    } else {
+        const span = takeInstrumentationModuleLoadSpan();
+        if (span) {
+            if (deferredSpans) {
+                deferredSpans.push(span);
+            } else {
+                traceBackdatedInstrumentationSpan(span);
+            }
+        }
+    }
+}
+async function instrumentationOnRequestError(projectDir, distDir, ...args) {
+    const instrumentation = await getInstrumentationModule(projectDir, distDir);
+    try {
+        var _instrumentation_onRequestError;
+        await (instrumentation == null ? void 0 : (_instrumentation_onRequestError = instrumentation.onRequestError) == null ? void 0 : _instrumentation_onRequestError.call(instrumentation, ...args));
+    } catch (err) {
+        // Log the soft error and continue, since the original error has already been thrown
+        console.error('Error in instrumentation.onRequestError:', err);
+    }
+}
+let registerInstrumentationPromise = null;
+function ensureInstrumentationRegistered(projectDir, distDir) {
+    if (!registerInstrumentationPromise) {
+        registerInstrumentationPromise = registerInstrumentation(projectDir, distDir);
+    }
+    return registerInstrumentationPromise;
+}
+async function ensureInstrumentationRegisteredWithDeferredSpans(projectDir, distDir) {
+    if (registerInstrumentationPromise) {
+        await registerInstrumentationPromise;
+        return undefined;
+    }
+    const deferredSpans = [];
+    registerInstrumentationPromise = registerInstrumentation(projectDir, distDir, deferredSpans);
+    await registerInstrumentationPromise;
+    if (deferredSpans.length === 0) {
+        return undefined;
+    }
+    return ()=>{
+        // Emit at most once.
+        deferredSpans.splice(0).forEach(traceBackdatedInstrumentationSpan);
+    };
+}
+
+//# sourceMappingURL=instrumentation-globals.external.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/router-utils/instrumentation-node-extensions.js

@@ -0,0 +1,110 @@
+/**
+ * This extension augments opentelemetry after registration if applicable.
+ * This extension must only be loaded in Node environments.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "afterRegistration", {
+    enumerable: true,
+    get: function() {
+        return afterRegistration;
+    }
+});
+const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _clientandserverreferences = require("../../../lib/client-and-server-references");
+function afterRegistration() {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw new _invarianterror.InvariantError('Node.js instrumentation extensions should not be loaded in the Edge runtime.');
+    }
+    extendTracerProviderForCacheComponents();
+}
+function isProxyTracerProvider(provider) {
+    return 'getDelegateTracer' in provider && typeof provider.getDelegateTracer === 'function';
+}
+// In theory we only want to enable this extension when cacheComponents is enabled
+// however there are certain servers that might load instrumentation before nextConfig is available
+// and so gating it on the config might lead to skipping this extension even when it is necessary.
+// When cacheComponents is disabled this extension should be a no-op so we enable it universally.
+// Additionally, soon, cacheComponents will be enabled always so this just pulls the extension forward in time
+function extendTracerProviderForCacheComponents() {
+    let api;
+    // we want to allow users to use their own version of @opentelemetry/api if they
+    // want to, so we try to require it first, and if it fails we fall back to the
+    // version that is bundled with Next.js
+    // this is because @opentelemetry/api has to be synced with the version of
+    // @opentelemetry/tracing that is used, and we don't want to force users to use
+    // the version that is bundled with Next.js.
+    // the API is ~stable, so this should be fine
+    try {
+        api = require('@opentelemetry/api');
+    } catch (err) {
+        api = require('next/dist/compiled/@opentelemetry/api');
+    }
+    const provider = api.trace.getTracerProvider();
+    // When Cache Components is enabled we need to instrument the tracer
+    // to exit the workUnitAsyncStorage context when generating spans.
+    const originalGetTracer = provider.getTracer.bind(provider);
+    provider.getTracer = (...args)=>{
+        return instrumentTracerForCacheComponents(originalGetTracer.apply(provider, args));
+    };
+    // Tracers acquired before registration can use getDelegateTracer() from the
+    // proxy provider to get a tracer from the registered provider, bypassing the
+    // getTracer() patch above. This can be problematic when third-party
+    // instrumentation creates spans that call dynamic APIs like Math.random(),
+    // causing a prerendering error. Therefore, patch getDelegateTracer() to apply
+    // the same tracer instrumentation as getTracer().
+    if (isProxyTracerProvider(provider)) {
+        const originalGetDelegateTracer = provider.getDelegateTracer.bind(provider);
+        provider.getDelegateTracer = (...args)=>{
+            const tracer = originalGetDelegateTracer(...args);
+            return tracer === undefined ? undefined : instrumentTracerForCacheComponents(tracer);
+        };
+    }
+}
+function instrumentTracerForCacheComponents(tracer) {
+    if (WeakTracers.has(tracer)) {
+        return tracer;
+    }
+    const originalStartSpan = tracer.startSpan;
+    tracer.startSpan = (...startSpanArgs)=>{
+        return _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>originalStartSpan.apply(tracer, startSpanArgs));
+    };
+    const originalStartActiveSpan = tracer.startActiveSpan;
+    // @ts-ignore TS doesn't recognize the overloads correctly
+    tracer.startActiveSpan = (...startActiveSpanArgs)=>{
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        if (!workUnitStore) {
+            // @ts-ignore TS doesn't recognize the overloads correctly
+            return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
+        }
+        let fnIdx = 0;
+        if (startActiveSpanArgs.length === 2 && typeof startActiveSpanArgs[1] === 'function') {
+            fnIdx = 1;
+        } else if (startActiveSpanArgs.length === 3 && typeof startActiveSpanArgs[2] === 'function') {
+            fnIdx = 2;
+        } else if (startActiveSpanArgs.length > 3 && typeof startActiveSpanArgs[3] === 'function') {
+            fnIdx = 3;
+        }
+        if (fnIdx) {
+            const originalFn = startActiveSpanArgs[fnIdx];
+            if ((0, _clientandserverreferences.isUseCacheFunction)(originalFn)) {
+                console.error('A Cache Function (`use cache`) was passed to startActiveSpan which means it will receive a Span argument with a possibly random ID on every invocation leading to cache misses. Provide a wrapping function around the Cache Function that does not forward the Span argument to avoid this issue.');
+            }
+            startActiveSpanArgs[fnIdx] = withWorkUnitContext(workUnitStore, originalFn);
+        }
+        return _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>{
+            // @ts-ignore TS doesn't recognize the overloads correctly
+            return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
+        });
+    };
+    WeakTracers.add(tracer);
+    return tracer;
+}
+const WeakTracers = new WeakSet();
+function withWorkUnitContext(workUnitStore, fn) {
+    return (...args)=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(workUnitStore, fn, ...args);
+}
+
+//# sourceMappingURL=instrumentation-node-extensions.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/router-utils/normalize-catchall-routes.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    findIncompatibleParallelRouteSlots: null,
+    normalizeCatchAllRoutes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    findIncompatibleParallelRouteSlots: function() {
+        return findIncompatibleParallelRouteSlots;
+    },
+    normalizeCatchAllRoutes: function() {
+        return normalizeCatchAllRoutes;
+    }
+});
+const _apppaths = require("../../../shared/lib/router/utils/app-paths");
+const _isapppageroute = require("../../../lib/is-app-page-route");
+const _interceptionroutes = require("../../../shared/lib/router/utils/interception-routes");
+const _entryconstants = require("../../../shared/lib/entry-constants");
+const defaultNormalizer = {
+    normalize (pathname) {
+        return (0, _apppaths.normalizeAppPath)(pathname).replace(/%5F/g, '_');
+    }
+};
+function normalizeCatchAllRoutes(appPaths, normalizer = defaultNormalizer, { strictRouteMatching = false, defaultAppPaths = [] } = {}) {
+    const pageAppPaths = strictRouteMatching ? new Set(Object.values(appPaths).flat().filter(isUserAppPageRoute)) : undefined;
+    const catchAllRoutes = [
+        ...new Set(Object.values(appPaths).flat().filter(isCatchAllRoute)// Sorting is important because we want to match the most specific path.
+        .sort((a, b)=>b.split('/').length - a.split('/').length))
+    ];
+    // interception routes should only be matched by a single entrypoint
+    // we don't want to push a catch-all route to an interception route
+    // because it would mean the interception would be handled by the wrong page component
+    const filteredAppPaths = Object.keys(appPaths).filter((route)=>!(0, _interceptionroutes.isInterceptionRouteAppPath)(route));
+    for (const appPath of filteredAppPaths){
+        for (const catchAllRoute of catchAllRoutes){
+            const normalizedCatchAllRoute = normalizer.normalize(catchAllRoute);
+            const normalizedCatchAllRouteBasePath = normalizedCatchAllRoute.slice(0, normalizedCatchAllRoute.search(catchAllRouteRegex));
+            if (// check if the appPath could match the catch-all
+            appPath.startsWith(normalizedCatchAllRouteBasePath) && // check if there's not already a slot value that could match the catch-all
+            !appPaths[appPath].some((path)=>hasMatchedSlots(path, catchAllRoute))) {
+                // optional catch-all routes are not currently supported, but leaving this logic in place
+                // for when they are eventually supported.
+                if (isOptionalCatchAll(catchAllRoute)) {
+                    // optional catch-all routes should match both the root segment and any segment after it
+                    // for example, `/[[...slug]]` should match `/` and `/foo` and `/foo/bar`
+                    appPaths[appPath].push(catchAllRoute);
+                } else if (isCatchAll(catchAllRoute)) {
+                    // regular catch-all (single bracket) should only match segments after it
+                    // for example, `/[...slug]` should match `/foo` and `/foo/bar` but not `/`
+                    if (normalizedCatchAllRouteBasePath !== appPath) {
+                        appPaths[appPath].push(catchAllRoute);
+                    }
+                }
+            }
+        }
+    }
+    if (strictRouteMatching) {
+        const topology = createParallelRouteTopology(appPaths, defaultAppPaths);
+        pruneUnrenderableCatchAllRoutes(appPaths, topology);
+        const incompatibleParallelRouteSlots = findIncompatibleParallelRouteSlotsWithTopology(appPaths, topology);
+        pruneUnrenderableRoutes(appPaths, topology);
+        const matchedAppPaths = new Set(Object.values(appPaths).flat());
+        return {
+            unmatchedAppPages: [
+                ...pageAppPaths
+            ].filter((appPath)=>!matchedAppPaths.has(appPath)).sort(),
+            incompatibleParallelRouteSlots
+        };
+    }
+    return {
+        unmatchedAppPages: [],
+        incompatibleParallelRouteSlots: []
+    };
+}
+function findIncompatibleParallelRouteSlots(appPaths, defaultAppPaths = []) {
+    return findIncompatibleParallelRouteSlotsWithTopology(appPaths, createParallelRouteTopology(appPaths, defaultAppPaths));
+}
+function findIncompatibleParallelRouteSlotsWithTopology(appPaths, { allAppPaths, levelsByParent }) {
+    const incompatibleRoutes = [];
+    for (const [route, matchedAppPaths] of Object.entries(appPaths)){
+        if (isBuiltin(route) || (0, _interceptionroutes.isInterceptionRouteAppPath)(route)) continue;
+        // Interception branches can be carried alongside an ordinary matcher, but
+        // they retain state instead of satisfying a hard-navigation slot.
+        const ordinaryAppPaths = matchedAppPaths.filter((appPath)=>isUserAppPageRoute(appPath) && !(0, _interceptionroutes.isInterceptionRouteAppPath)(appPath));
+        if (ordinaryAppPaths.length === 0) continue;
+        for (const { parentSegments, namedSlots, hasChildrenSlot } of levelsByParent.values()){
+            if (!ordinaryAppPaths.some((appPath)=>hasPathPrefix(splitAppPath(appPath), parentSegments))) {
+                continue;
+            }
+            const siblingSlots = [
+                ...hasChildrenSlot ? [
+                    'children'
+                ] : [],
+                ...namedSlots
+            ];
+            const missingSlots = siblingSlots.filter((slot)=>{
+                const hasMatchedPage = ordinaryAppPaths.some((appPath)=>isPathInSlot(appPath, parentSegments, slot));
+                const hasDefault = allAppPaths.has(getDefaultAppPath(parentSegments, slot));
+                return !hasMatchedPage && !hasDefault;
+            });
+            if (missingSlots.length > 0) {
+                incompatibleRoutes.push({
+                    layoutPath: `/${parentSegments.join('/')}`,
+                    route,
+                    missingSlots: missingSlots.sort()
+                });
+            }
+        }
+    }
+    return incompatibleRoutes.sort((a, b)=>a.layoutPath === b.layoutPath ? a.route.localeCompare(b.route) : a.layoutPath.localeCompare(b.layoutPath));
+}
+function isBuiltin(appPath) {
+    return appPath === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE || appPath === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY || appPath === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE || appPath === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY;
+}
+/**
+ * Removes catch-all-derived routes that can never render because another slot
+ * at the same level has neither a matching page nor an explicit default.
+ *
+ * The built-in default for such a slot always calls `notFound()`. Keeping the
+ * route in the matcher set would therefore retain a matcher that can never
+ * construct a complete loader tree.
+ */ function pruneUnrenderableCatchAllRoutes(appPaths, { allAppPaths, levelsByParent }) {
+    for (const [route, matchedAppPaths] of Object.entries(appPaths)){
+        const catchAllAppPaths = matchedAppPaths.filter((appPath)=>isUserAppPageRoute(appPath) && isCatchAll(appPath));
+        if (catchAllAppPaths.some((catchAllAppPath)=>{
+            const catchAllSegments = splitAppPath(catchAllAppPath).slice(0, -1);
+            const interceptionMarkerIndex = catchAllSegments.findIndex((segment)=>_interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((marker)=>segment.startsWith(marker)));
+            for (const { parentSegments, namedSlots, hasChildrenSlot } of levelsByParent.values()){
+                if (!hasPathPrefix(catchAllSegments, parentSegments)) continue;
+                const catchAllSlot = getSlotAtParent(catchAllSegments, parentSegments);
+                const siblingSlots = [
+                    ...hasChildrenSlot ? [
+                        'children'
+                    ] : [],
+                    ...namedSlots
+                ];
+                // An interception response replaces one slot while retaining every
+                // sibling owned by layouts up to the interception marker. Those
+                // siblings use the null retain marker rather than a page or default.
+                // Slots inside the newly selected subtree still match normally.
+                const retainsInterceptionSiblings = interceptionMarkerIndex !== -1 && parentSegments.length <= interceptionMarkerIndex;
+                for (const siblingSlot of siblingSlots){
+                    if (siblingSlot === catchAllSlot) continue;
+                    const hasMatchedPage = matchedAppPaths.some((appPath)=>isPathInSlot(appPath, parentSegments, siblingSlot));
+                    const hasDefault = allAppPaths.has(getDefaultAppPath(parentSegments, siblingSlot));
+                    if (!hasMatchedPage && !hasDefault && !retainsInterceptionSiblings) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        })) {
+            const nonPageAppPaths = matchedAppPaths.filter((appPath)=>!isUserAppPageRoute(appPath));
+            if (nonPageAppPaths.length === 0) {
+                delete appPaths[route];
+            } else {
+                appPaths[route] = nonPageAppPaths;
+            }
+        }
+    }
+}
+/**
+ * Removes every route that cannot construct all slots at a matching layout
+ * level. Catch-all-derived routes are removed by the earlier pass so the
+ * caller can report only incompatible static matchers between the two passes.
+ */ function pruneUnrenderableRoutes(appPaths, { allAppPaths, levelsByParent }) {
+    for (const [route, matchedAppPaths] of Object.entries(appPaths)){
+        const matchedPageAppPaths = matchedAppPaths.filter(isUserAppPageRoute);
+        if (matchedPageAppPaths.length === 0) continue;
+        if (hasIncompleteParallelRoute(matchedPageAppPaths, levelsByParent.values(), allAppPaths)) {
+            const nonPageAppPaths = matchedAppPaths.filter((appPath)=>!isUserAppPageRoute(appPath));
+            if (nonPageAppPaths.length === 0) {
+                delete appPaths[route];
+            } else {
+                appPaths[route] = nonPageAppPaths;
+            }
+        }
+    }
+}
+function createParallelRouteTopology(appPaths, defaultAppPaths) {
+    const allAppPaths = new Set([
+        ...Object.entries(appPaths).filter(([route])=>!isBuiltin(route)).flatMap(([, matchedAppPaths])=>matchedAppPaths).filter(isUserAppPageRoute),
+        ...[
+            ...defaultAppPaths
+        ].filter((appPath)=>!isBuiltinAppPageEntry(appPath))
+    ]);
+    return {
+        allAppPaths,
+        levelsByParent: collectParallelRouteLevels(allAppPaths)
+    };
+}
+function collectParallelRouteLevels(allAppPaths) {
+    const levelsByParent = new Map();
+    for (const appPath of allAppPaths){
+        const segments = splitAppPath(appPath);
+        for(let i = 0; i < segments.length - 1; i++){
+            const segment = segments[i];
+            if (!isMatchableSlot(segment)) continue;
+            const parentSegments = segments.slice(0, i);
+            const parentKey = JSON.stringify(parentSegments);
+            let level = levelsByParent.get(parentKey);
+            if (!level) {
+                level = {
+                    parentSegments,
+                    namedSlots: new Set(),
+                    hasChildrenSlot: false
+                };
+                levelsByParent.set(parentKey, level);
+            }
+            level.namedSlots.add(segment);
+        }
+    }
+    for (const appPath of allAppPaths){
+        for (const level of levelsByParent.values()){
+            if (isPathInSlot(appPath, level.parentSegments, 'children')) {
+                level.hasChildrenSlot = true;
+            }
+        }
+    }
+    return levelsByParent;
+}
+function isUserAppPageRoute(appPath) {
+    return (0, _isapppageroute.isAppPageRoute)(appPath) && !isBuiltinAppPageEntry(appPath);
+}
+function isBuiltinAppPageEntry(appPath) {
+    return appPath === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY || appPath === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY;
+}
+function hasIncompleteParallelRoute(matchedAppPaths, levels, allAppPaths) {
+    const matchedSegments = matchedAppPaths.map((appPath)=>splitAppPath(appPath).slice(0, -1));
+    for (const { parentSegments, namedSlots, hasChildrenSlot } of levels){
+        const pathsAtLevel = matchedSegments.filter((segments)=>hasPathPrefix(segments, parentSegments));
+        if (pathsAtLevel.length === 0) continue;
+        // An interception response replaces one slot while retaining every
+        // sibling owned by layouts up to the interception marker. Those siblings
+        // use the null retain marker rather than a page or default. Slots inside
+        // the newly selected subtree still match normally.
+        const retainsInterceptionSiblings = pathsAtLevel.some((segments)=>{
+            const interceptionMarkerIndex = segments.findIndex((segment)=>_interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((marker)=>segment.startsWith(marker)));
+            return interceptionMarkerIndex !== -1 && parentSegments.length <= interceptionMarkerIndex;
+        });
+        const slots = [
+            ...hasChildrenSlot ? [
+                'children'
+            ] : [],
+            ...namedSlots
+        ];
+        for (const slot of slots){
+            const hasMatchedPage = matchedAppPaths.some((appPath)=>isPathInSlot(appPath, parentSegments, slot));
+            const hasDefault = allAppPaths.has(getDefaultAppPath(parentSegments, slot));
+            if (!hasMatchedPage && !hasDefault && !retainsInterceptionSiblings) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function splitAppPath(appPath) {
+    return appPath.split('/').filter(Boolean);
+}
+function hasPathPrefix(path, prefix) {
+    return prefix.every((segment, index)=>path[index] === segment);
+}
+function getSlotAtParent(path, parent) {
+    const segment = path[parent.length];
+    return (segment == null ? void 0 : segment.startsWith('@')) && segment !== '@children' ? segment : 'children';
+}
+function isPathInSlot(appPath, parent, slot) {
+    const segments = splitAppPath(appPath);
+    return hasPathPrefix(segments, parent) && getSlotAtParent(segments, parent) === slot;
+}
+function getDefaultAppPath(parent, slot) {
+    const segments = slot === 'children' ? [
+        ...parent,
+        'default'
+    ] : [
+        ...parent,
+        slot,
+        'default'
+    ];
+    return `/${segments.join('/')}`;
+}
+function hasMatchedSlots(path1, path2) {
+    const slots1 = path1.split('/').filter(isMatchableSlot);
+    const slots2 = path2.split('/').filter(isMatchableSlot);
+    // if the catch-all route does not have the same number of slots as the app path, it can't match
+    if (slots1.length !== slots2.length) return false;
+    // compare the slots in both paths. For there to be a match, each slot must be the same
+    for(let i = 0; i < slots1.length; i++){
+        if (slots1[i] !== slots2[i]) return false;
+    }
+    return true;
+}
+/**
+ * Returns true for slots that should be considered when checking for match compatibility.
+ * Excludes children slots because these are similar to having a segment-level `page`
+ * which would cause a slot length mismatch when comparing it to a catch-all route.
+ */ function isMatchableSlot(segment) {
+    return segment.startsWith('@') && segment !== '@children';
+}
+const catchAllRouteRegex = /\[?\[\.\.\./;
+function isCatchAllRoute(pathname) {
+    // Optional catch-all slots are not currently supported, and as such they are not considered when checking for match compatability.
+    return !isOptionalCatchAll(pathname) && isCatchAll(pathname);
+}
+function isOptionalCatchAll(pathname) {
+    return pathname.includes('[[...');
+}
+function isCatchAll(pathname) {
+    return pathname.includes('[...');
+}
+
+//# sourceMappingURL=normalize-catchall-routes.js.map