@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/shared/lib/app-router-types.js

@@ -7,27 +7,61 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "PrefetchHint", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    PrefetchHint: null,
+    StaticPrefetchDisabled: null,
+    SubtreePrefetchHints: null,
+    propagateSubtreeBits: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PrefetchHint: function() {
         return PrefetchHint;
+    },
+    StaticPrefetchDisabled: function() {
+        return StaticPrefetchDisabled;
+    },
+    SubtreePrefetchHints: function() {
+        return SubtreePrefetchHints;
+    },
+    propagateSubtreeBits: function() {
+        return propagateSubtreeBits;
     }
 });
 var PrefetchHint = /*#__PURE__*/ function(PrefetchHint) {
-    // This segment has a runtime prefetch enabled (via unstable_instant with
-    // prefetch: 'runtime'). Per-segment only, does not propagate to ancestors.
-    PrefetchHint[PrefetchHint["HasRuntimePrefetch"] = 1] = "HasRuntimePrefetch";
-    // This segment or one of its descendants has an instant config defined
-    // (any truthy unstable_instant, regardless of prefetch mode). Propagates
-    // upward so the root segment reflects the entire subtree.
-    PrefetchHint[PrefetchHint["SubtreeHasInstant"] = 2] = "SubtreeHasInstant";
+    // NOTE: The 0b00001 bit was previously HasRuntimePrefetch (prefetch:
+    // 'allow-runtime'). Partial Prefetching now implies runtime completeness
+    // for every segment, so the bit was removed. Do not reuse it without
+    // considering caches populated by older builds.
+    // This segment or one of its descendants opts into Partial Prefetching, i.e.
+    // uses the two-phase (Shell then Speculative) prefetch flow. Set when
+    // `prefetch` is 'partial' or 'unstable_eager' (including the defaults
+    // implied by the global `partialPrefetching` config). Propagates upward so
+    // the root segment reflects the entire subtree.
+    //
+    // Partial Prefetching segments require RUNTIME COMPLETENESS: a prefetch
+    // isn't considered done for such a segment until an entry at least as
+    // complete as a runtime response exists. This does NOT mean the segment
+    // lacks static data — the server emits static data unconditionally, and the
+    // scheduler may attempt a static prefetch first (per
+    // ShouldAttemptStaticPrefetch), issuing the runtime request only if the
+    // static response's own `needsRuntimeRequest` signal says it would
+    // return more.
+    PrefetchHint[PrefetchHint["SubtreeHasPartialPrefetching"] = 2] = "SubtreeHasPartialPrefetching";
     // This segment itself has a loading.tsx boundary.
     PrefetchHint[PrefetchHint["SegmentHasLoadingBoundary"] = 4] = "SegmentHasLoadingBoundary";
     // A descendant segment (but not this one) has a loading.tsx boundary.
     // Propagates upward so the root reflects the entire subtree.
     PrefetchHint[PrefetchHint["SubtreeHasLoadingBoundary"] = 8] = "SubtreeHasLoadingBoundary";
-    // This segment is the root layout of the application.
-    PrefetchHint[PrefetchHint["IsRootLayout"] = 16] = "IsRootLayout";
+    // This segment is at or above the application's root layout — the root layout
+    // segment itself and all of its ancestors. A dynamic param in one of these
+    // segments is a "root param".
+    PrefetchHint[PrefetchHint["IsRootLayoutOrAbove"] = 16] = "IsRootLayoutOrAbove";
     // This segment's response includes its parent's data inlined into it.
     // Set at build time by the segment size measurement pass.
     PrefetchHint[PrefetchHint["ParentInlinedIntoSelf"] = 32] = "ParentInlinedIntoSelf";
@@ -40,7 +74,86 @@ var PrefetchHint = /*#__PURE__*/ function(PrefetchHint) {
     // On the root hint node: the head was NOT inlined into any page — fetch
     // it separately. Absence of this bit means the head is bundled into a page.
     PrefetchHint[PrefetchHint["HeadOutlined"] = 256] = "HeadOutlined";
+    // The inlining hints in this tree may be stale because the tree was
+    // generated before collectPrefetchHints ran (e.g. the initial RSC payload
+    // for a fully static page at build time). When writing this tree into the
+    // cache, the route entry should be immediately expired so it gets
+    // re-fetched with correct hints. Only set during build-time prerendering,
+    // never at runtime.
+    PrefetchHint[PrefetchHint["InliningHintsStale"] = 512] = "InliningHintsStale";
+    // This segment has prefetch = 'force-disabled'. The opt-out is passive
+    // and applies to this segment only: it never INITIATES a prefetch — no
+    // static data is emitted or fetched, and it's never the reason a runtime
+    // prefetch spawns — but it may ride along in a runtime response issued on
+    // another segment's behalf. Descendants prefetch normally.
+    //
+    // TODO: Also set as an internal fallback when the prefetch hints manifest
+    // is unavailable (see #91407 mitigations), which only means "no static
+    // prefetch data exists" — not a user opt-out. Split the fallback into its
+    // own bit so the two intents can diverge.
+    PrefetchHint[PrefetchHint["PrefetchDisabled"] = 1024] = "PrefetchDisabled";
+    // NOTE: The 0b100000000000 bit was previously SubtreeHasRuntimePrefetch.
+    // Partial Prefetching now implies runtime completeness for every segment
+    // (see SubtreeHasPartialPrefetching), so the bit was removed. Do not reuse
+    // it without considering caches populated by older builds.
+    // This segment or one of its descendants prefetches "eagerly" — i.e. its
+    // effective prefetch strategy is anything other than 'partial'. Used by
+    // App Shells: a non-eager subtree relies on the shared app shell and skips
+    // its Speculative prefetch. Propagates upward so the root reflects the
+    // entire subtree.
+    PrefetchHint[PrefetchHint["SubtreeHasEagerPrefetch"] = 4096] = "SubtreeHasEagerPrefetch";
+    // This segment or one of its descendants exports `instant = false`,
+    // explicitly opting out of Partial Prefetching. Propagates upward so the root
+    // reflects the entire subtree. Used only to suppress the dev-time
+    // `<Link prefetch={true}>` warning — unlike PrefetchDisabled, it has no effect
+    // on the actual prefetch behavior.
+    PrefetchHint[PrefetchHint["SubtreeHasInstantFalse"] = 8192] = "SubtreeHasInstantFalse";
+    // The client should attempt a static prefetch for this route: the
+    // build-time prerender did not access any runtime data (cookies, headers,
+    // searchParams, ...), so a static prefetch is expected to be as complete
+    // as a runtime one. A fallback-param access only unsets the bit when the
+    // route can never be upgraded from a fallback to a concrete prerender —
+    // on an upgradeable route, ISR later produces the concrete prerender a
+    // static attempt would hit (until then, the static responses' own
+    // signal reports the insufficiency per response). Purely advisory, and
+    // both error directions are safe: if set when a runtime request is
+    // actually needed, that same response-level signal (the load-bearing
+    // `needsRuntimeRequest` promise combined with each segment's `isPartial`)
+    // directs the client to follow up — the cost is a wasted static attempt.
+    // If unset when static would have sufficed, the client goes straight to a
+    // runtime prefetch, which is a superset of the static response — the cost
+    // is only reduced cacheability. Like the other bits, this one is computed
+    // once per build and stays constant for the build's lifetime; it rides
+    // the prefetch-hints manifest into every response that carries hints —
+    // `/_tree` prefetch responses and the FlightRouterState of dynamic
+    // navigations alike. (Routes missing from the manifest — see the #91407
+    // fallbacks — simply never carry it.) Set on every node of the tree, but
+    // does not propagate.
+    PrefetchHint[PrefetchHint["ShouldAttemptStaticPrefetch"] = 16384] = "ShouldAttemptStaticPrefetch";
     return PrefetchHint;
 }({});
+const StaticPrefetchDisabled = 1024;
+const SubtreePrefetchHints = 2 | 8 | 8192 | 4096;
+function propagateSubtreeBits(parentHints, childHints) {
+    if (childHints & 2) {
+        parentHints |= 2;
+    }
+    // A child with a loading boundary (directly, or anywhere in its subtree) makes
+    // this a SubtreeHasLoadingBoundary on the parent.
+    if (childHints & (4 | 8)) {
+        parentHints |= 8;
+    }
+    // And for eager prefetch. The bit is set directly on each eager segment, so
+    // there's no separate segment-local flag — propagate it as-is.
+    if (childHints & 4096) {
+        parentHints |= 4096;
+    }
+    // And for `instant = false`. Like eager prefetch, the bit is set directly on
+    // each opted-out segment, so propagate it as-is.
+    if (childHints & 8192) {
+        parentHints |= 8192;
+    }
+    return parentHints;
+}
 
 //# sourceMappingURL=app-router-types.js.map

package/dist/node_modules/next/dist/shared/lib/constants.js

@@ -53,6 +53,7 @@ Object.defineProperty(exports, "__esModule", {
     PREFETCH_HINTS: null,
     PRERENDER_MANIFEST: null,
     REACT_LOADABLE_MANIFEST: null,
+    REQUEST_INSIGHTS_DEV_ENDPOINT: null,
     ROUTES_MANIFEST: null,
     RSC_MODULE_TYPES: null,
     SERVER_DIRECTORY: null,
@@ -230,6 +231,9 @@ _export(exports, {
     REACT_LOADABLE_MANIFEST: function() {
         return REACT_LOADABLE_MANIFEST;
     },
+    REQUEST_INSIGHTS_DEV_ENDPOINT: function() {
+        return REQUEST_INSIGHTS_DEV_ENDPOINT;
+    },
     ROUTES_MANIFEST: function() {
         return ROUTES_MANIFEST;
     },
@@ -350,6 +354,7 @@ const ROUTES_MANIFEST = 'routes-manifest.json';
 const IMAGES_MANIFEST = 'images-manifest.json';
 const SERVER_FILES_MANIFEST = 'required-server-files';
 const DEV_CLIENT_PAGES_MANIFEST = '_devPagesManifest.json';
+const REQUEST_INSIGHTS_DEV_ENDPOINT = '/_next/development/request-insights';
 const MIDDLEWARE_MANIFEST = 'middleware-manifest.json';
 const TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST = '_clientMiddlewareManifest.js';
 const TURBOPACK_CLIENT_BUILD_MANIFEST = 'client-build-manifest.json';

package/dist/node_modules/next/dist/shared/lib/deployment-id.js

@@ -50,7 +50,7 @@ function getDeploymentIdQuery(ampersand = false) {
     return '';
 }
 function getAssetToken() {
-    return process.env.NEXT_IMMUTABLE_ASSET_TOKEN || process.env.NEXT_DEPLOYMENT_ID;
+    return process.env.NEXT_SUPPORTS_IMMUTABLE_ASSETS ? undefined : process.env.NEXT_DEPLOYMENT_ID;
 }
 function getAssetTokenQuery(ampersand = false) {
     let id = getAssetToken();

package/dist/node_modules/next/dist/shared/lib/errors/empty-generate-static-params-error.js

@@ -8,17 +8,24 @@ Object.defineProperty(exports, "throwEmptyGenerateStaticParamsError", {
         return throwEmptyGenerateStaticParamsError;
     }
 });
-function throwEmptyGenerateStaticParamsError() {
-    const error = Object.defineProperty(new Error('When using Cache Components, all `generateStaticParams` functions must return at least one result. ' + 'This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\n' + 'Learn more: https://nextjs.org/docs/messages/empty-generate-static-params'), "__NEXT_ERROR_CODE", {
+function throwEmptyGenerateStaticParamsError(// Compiler-injected factory whose error stack is anchored at the user's
+// `generateStaticParams`. The transform injects it for every app page that
+// exports `generateStaticParams` by a statically-visible name, but a few
+// forms can't be detected from the page module alone (e.g. `export *`
+// re-exports), so it may be absent.
+createError) {
+    if (createError) {
+        throw createError();
+    }
+    // Fallback for the rare case the compiler couldn't inject an anchored factory
+    // (e.g. a wildcard re-export). The stack points at framework internals, but
+    // we keep it: those frames are ignore-listed in the output and stay available
+    // for debugging.
+    throw Object.defineProperty(new Error('When using Cache Components, all `generateStaticParams` functions must return at least one result. ' + 'This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\n' + 'Learn more: https://nextjs.org/docs/messages/empty-generate-static-params'), "__NEXT_ERROR_CODE", {
         value: "E898",
         enumerable: false,
         configurable: true
     });
-    error.name = 'EmptyGenerateStaticParamsError';
-    // This error is meant to interrupt the server start/build process
-    // but the stack trace isn't meaningful, as it points to internal code.
-    error.stack = undefined;
-    throw error;
 }
 
 //# sourceMappingURL=empty-generate-static-params-error.js.map

package/dist/node_modules/next/dist/shared/lib/errors/hard-deprecated-config-error.js

@@ -11,6 +11,11 @@ Object.defineProperty(exports, "HardDeprecatedConfigError", {
 class HardDeprecatedConfigError extends Error {
     constructor(message){
         super(message);
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
         // This error is meant to interrupt the server start/build process
         // but the stack trace isn't meaningful, as it points to internal code.
         this.stack = undefined;

package/dist/node_modules/next/dist/shared/lib/head.js

@@ -27,7 +27,6 @@ const _jsxruntime = require("react/jsx-runtime");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _sideeffect = /*#__PURE__*/ _interop_require_default._(require("./side-effect"));
 const _headmanagercontextsharedruntime = require("./head-manager-context.shared-runtime");
-const _warnonce = require("./utils/warn-once");
 function defaultHead() {
     const head = [
         /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
@@ -85,7 +84,6 @@ const METATYPES = [
                 keys.add(key);
             }
         }
-        // eslint-disable-next-line default-case
         switch(h.type){
             case 'title':
             case 'base':
@@ -117,6 +115,8 @@ const METATYPES = [
                     }
                 }
                 break;
+            default:
+                break;
         }
         return isUnique;
     };
@@ -128,12 +128,13 @@ const METATYPES = [
     return headChildrenElements.reduce(onlyReactElement, []).reverse().concat(defaultHead().reverse()).filter(unique()).reverse().map((c, i)=>{
         const key = c.key || i;
         if (process.env.NODE_ENV === 'development') {
+            const { warnOnce } = require('./utils/warn-once');
             // omit JSON-LD structured data snippets from the warning
             if (c.type === 'script' && c.props['type'] !== 'application/ld+json') {
                 const srcMessage = c.props['src'] ? `<script> tag with src="${c.props['src']}"` : `inline <script>`;
-                (0, _warnonce.warnOnce)(`Do not add <script> tags using next/head (see ${srcMessage}). Use next/script instead. \nSee more info here: https://nextjs.org/docs/messages/no-script-tags-in-head-component`);
+                warnOnce(`Do not add <script> tags using next/head (see ${srcMessage}). Use next/script instead. \nSee more info here: https://nextjs.org/docs/messages/no-script-tags-in-head-component`);
             } else if (c.type === 'link' && c.props['rel'] === 'stylesheet') {
-                (0, _warnonce.warnOnce)(`Do not add stylesheets using next/head (see <link rel="stylesheet"> tag with href="${c.props['href']}"). Use Document instead. \nSee more info here: https://nextjs.org/docs/messages/no-stylesheets-in-head-component`);
+                warnOnce(`Do not add stylesheets using next/head (see <link rel="stylesheet"> tag with href="${c.props['href']}"). Use Document instead. \nSee more info here: https://nextjs.org/docs/messages/no-stylesheets-in-head-component`);
             }
         }
         return /*#__PURE__*/ _react.default.cloneElement(c, {

package/dist/node_modules/next/dist/shared/lib/instant-messages.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createLinkPrefetchPartialError: null,
+    createUnrenderedSegmentError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createLinkPrefetchPartialError: function() {
+        return createLinkPrefetchPartialError;
+    },
+    createUnrenderedSegmentError: function() {
+        return createUnrenderedSegmentError;
+    }
+});
+function createUnrenderedSegmentError(route, missingFiles) {
+    let message = `Route "${route}": Could not validate that a segment in your UI has instant navigation.`;
+    if (missingFiles.length > 0) {
+        const label = missingFiles.length === 1 ? 'Dropped segment' : 'Dropped segments';
+        message += `\n\nThis segment was dropped from rendering. Issues that would prevent instant navigation will go undetected.` + `\n\n${label}:\n${missingFiles.map((p)=>`  ${p}`).join('\n')}` + `\n\nWays to fix this:` + `\n  - [render] Render the dropped segment` + `\n  - [ignore] Set \`export const instant = false\` to opt the dropped segment out of instant-navigation validation` + `\n\nLearn more: https://nextjs.org/docs/messages/instant-unrendered-segment`;
+    }
+    return Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E1286",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createLinkPrefetchPartialError(pathname) {
+    return Object.defineProperty(new Error(`Next.js encountered dynamic data during prefetching for "${pathname}".\n\n` + `This will lead to slower, more expensive prefetches.\n\n` + `Ways to fix this:\n` + `  - [upgrade] Opt into Partial Prefetching by exporting \`const prefetch = 'partial'\` from the page or layout, or by setting \`partialPrefetching: true\` in next.config to opt the whole app in\n` + `  - [disable] Remove \`prefetch={true}\` from the <Link> to use the default prefetch\n` + `  - [ignore] Set \`export const instant = false\` to opt the route out of instant-navigation validation\n\n` + `Learn more: https://nextjs.org/docs/messages/instant-link-prefetch-partial`), "__NEXT_ERROR_CODE", {
+        value: "E1435",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=instant-messages.js.map

package/dist/node_modules/next/dist/shared/lib/invariant-error.js

@@ -11,6 +11,11 @@ Object.defineProperty(exports, "InvariantError", {
 class InvariantError extends Error {
     constructor(message, options){
         super(`Invariant: ${message.endsWith('.') ? message : message + '.'} This is a bug in Next.js.`, options);
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1179",
+            enumerable: false,
+            configurable: true
+        });
         this.name = 'InvariantError';
     }
 }

package/dist/node_modules/next/dist/shared/lib/request-insights.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getRequestInsightKey: null,
+    getRequestInsightKind: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getRequestInsightKey: function() {
+        return getRequestInsightKey;
+    },
+    getRequestInsightKind: function() {
+        return getRequestInsightKind;
+    }
+});
+function getRequestInsightKind(insight) {
+    return insight.kind ?? 'request';
+}
+function getRequestInsightKey(insight) {
+    return `${getRequestInsightKind(insight)}:${insight.requestId}`;
+}
+
+//# sourceMappingURL=request-insights.js.map

package/dist/node_modules/next/dist/shared/lib/router/adapters.js

@@ -59,7 +59,10 @@ function adaptForAppRouterInstance(pagesRouter) {
         },
         prefetch (href) {
             void pagesRouter.prefetch(href);
-        }
+        },
+        // The bfcacheId concept is App Router-only. Surfaced as a stable
+        // placeholder so consumers using this adapter don't crash.
+        bfcacheId: '0'
     };
 }
 function adaptForSearchParams(router) {

package/dist/node_modules/next/dist/shared/lib/router/routes/app.js

@@ -5,8 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     isInterceptionAppRoute: null,
     isNormalizedAppRoute: null,
-    parseAppRoute: null,
-    parseAppRouteSegment: null
+    parseAppRouteSegment: null,
+    parseAppRouteWithSlots: null,
+    parseNormalizedAppRoute: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -21,11 +22,14 @@ _export(exports, {
     isNormalizedAppRoute: function() {
         return isNormalizedAppRoute;
     },
-    parseAppRoute: function() {
-        return parseAppRoute;
-    },
     parseAppRouteSegment: function() {
         return parseAppRouteSegment;
+    },
+    parseAppRouteWithSlots: function() {
+        return parseAppRouteWithSlots;
+    },
+    parseNormalizedAppRoute: function() {
+        return parseNormalizedAppRoute;
     }
 });
 const _invarianterror = require("../../invariant-error");
@@ -82,7 +86,14 @@ function isNormalizedAppRoute(route) {
 function isInterceptionAppRoute(route) {
     return route.interceptionMarker !== undefined && route.interceptingRoute !== undefined && route.interceptedRoute !== undefined;
 }
-function parseAppRoute(pathname, normalized) {
+// Bitmask for which non-URL segment types to allow during parsing.
+// By default, route groups and parallel routes are rejected because
+// they should have been stripped by normalizeAppPath. These flags
+// let callers opt in to allowing specific types.
+const OnlyRoutableSegments = /*   */ 0;
+const AllowParallelSegments = /*  */ 1;
+const AllowGroupSegments = /*     */ 2;
+function parseAppRouteImpl(pathname, allowedTypes) {
     const pathnameSegments = pathname.split('/').filter(Boolean);
     // Build segments array with static and dynamic segments
     const segments = [];
@@ -97,9 +108,16 @@ function parseAppRoute(pathname, normalized) {
         if (!appSegment) {
             continue;
         }
-        if (normalized && (appSegment.type === 'route-group' || appSegment.type === 'parallel-route')) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group or parallel route segment.`), "__NEXT_ERROR_CODE", {
-                value: "E923",
+        if (appSegment.type === 'route-group' && !(allowedTypes & AllowGroupSegments)) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group segment.`), "__NEXT_ERROR_CODE", {
+                value: "E1151",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (appSegment.type === 'parallel-route' && !(allowedTypes & AllowParallelSegments)) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a parallel route segment.`), "__NEXT_ERROR_CODE", {
+                value: "E1152",
                 enumerable: false,
                 configurable: true
             });
@@ -114,14 +132,14 @@ function parseAppRoute(pathname, normalized) {
                     configurable: true
                 });
             }
-            interceptingRoute = normalized ? parseAppRoute(parts[0], true) : parseAppRoute(parts[0], false);
-            interceptedRoute = normalized ? parseAppRoute(parts[1], true) : parseAppRoute(parts[1], false);
+            interceptingRoute = parseAppRouteImpl(parts[0], allowedTypes);
+            interceptedRoute = parseAppRouteImpl(parts[1], allowedTypes);
             interceptionMarker = appSegment.interceptionMarker;
         }
     }
     const dynamicSegments = segments.filter((segment)=>segment.type === 'dynamic');
     return {
-        normalized,
+        normalized: allowedTypes === OnlyRoutableSegments,
         pathname,
         segments,
         dynamicSegments,
@@ -130,5 +148,11 @@ function parseAppRoute(pathname, normalized) {
         interceptedRoute
     };
 }
+function parseNormalizedAppRoute(pathname) {
+    return parseAppRouteImpl(pathname, OnlyRoutableSegments);
+}
+function parseAppRouteWithSlots(pathname) {
+    return parseAppRouteImpl(pathname, AllowParallelSegments);
+}
 
 //# sourceMappingURL=app.js.map

package/dist/node_modules/next/dist/shared/lib/router/utils/escape-path-delimiters.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 function escapePathDelimiters(segment, escapeEncoded) {
-    return segment.replace(new RegExp(`([/#?]${escapeEncoded ? '|%(2f|23|3f|5c)' : ''})`, 'gi'), (char)=>encodeURIComponent(char));
+    return segment.replace(new RegExp(`([/#?\\\\]${escapeEncoded ? '|%(2f|23|3f|5c)' : ''})`, 'gi'), (char)=>encodeURIComponent(char));
 }
 
 //# sourceMappingURL=escape-path-delimiters.js.map

package/dist/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js

@@ -69,7 +69,7 @@ function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRo
         }
     ];
     // Parse the route from the provided page path.
-    const route = (0, _app.parseAppRoute)(pagePath, true);
+    const route = (0, _app.parseNormalizedAppRoute)(pagePath);
     while(stack.length > 0){
         const { tree, depth } = stack.pop();
         const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);

package/dist/node_modules/next/dist/shared/lib/router/utils/prepare-destination.js

@@ -215,7 +215,8 @@ function prepareDestination(args) {
     let destHostnameCompiler;
     if (destHostname) {
         destHostnameCompiler = (0, _routematchutils.safeCompile)(destHostname, {
-            validate: false
+            validate: false,
+            encode: encodeURIComponent
         });
     }
     // update any params in query values

package/dist/node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -1,9 +1,10 @@
 /**
- * Removes the trailing slash for a given route or page path. Preserves the
- * root page. Examples:
+ * Removes the trailing slash for a given route or page path. Examples:
  *   - `/foo/bar/` -> `/foo/bar`
  *   - `/foo/bar` -> `/foo/bar`
- *   - `/` -> `/`
+ *
+ * Uses charCodeAt (47 === '/') instead of regex to avoid the overhead of
+ * compiling and executing a RegExp on every call (~3-5x faster).
  */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -15,7 +16,7 @@ Object.defineProperty(exports, "removeTrailingSlash", {
     }
 });
 function removeTrailingSlash(route) {
-    return route.replace(/\/$/, '') || '/';
+    return route.charCodeAt(route.length - 1) === 47 && route.length > 1 ? route.slice(0, -1) : route;
 }
 
 //# sourceMappingURL=remove-trailing-slash.js.map

package/dist/node_modules/next/dist/shared/lib/router/utils/sorted-routes.js

@@ -211,7 +211,7 @@ function getSortedRoutes(normalizedPages) {
     // First the UrlNode is created, and every UrlNode can have only 1 dynamic segment
     // Eg you can't have pages/[post]/abc.js and pages/[hello]/something-else.js
     // Only 1 dynamic segment per nesting level
-    // So in the case that is test/integration/dynamic-routing it'll be this:
+    // So in the case that is test/e2e/dynamic-routing it'll be this:
     // pages/[post]/comments.js
     // pages/blog/[post]/comment/[id].js
     // Both are fine because `pages/[post]` and `pages/blog` are on the same level

package/dist/node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.js

@@ -12,20 +12,54 @@ Object.defineProperty(exports, "readVaryParams", {
         return readVaryParams;
     }
 });
-function readVaryParams(thenable) {
-    // Attach a no-op listener to force Flight to synchronously resolve the
-    // thenable. When a thenable arrives from the Flight stream, it may be in an
-    // intermediate 'resolved_model' state (data received but not unwrapped).
-    // Calling .then() triggers Flight to transition it to 'fulfilled', making
-    // the value available synchronously. React uses this same optimization
-    // internally to avoid unnecessary microtasks.
-    thenable.then(noop);
-    // If the thenable is still not 'fulfilled' after calling .then(), the server
-    // failed to resolve it before the stream ended. Treat as unknown.
-    if (thenable.status !== 'fulfilled') {
+/**
+ * Synchronously drains a vary params `AsyncIterable`, adding each yielded name
+ * to `target`.
+ *
+ * By the time this runs (on the client, or in collectSegmentData), the Flight
+ * stream has been fully buffered, so every yielded value is already
+ * materialized and can be read without awaiting. We force each iterator result
+ * to resolve synchronously using the same `.then(noop)` trick React uses
+ * internally, then read its `status`/`value` directly.
+ *
+ * We add "every param yielded up to the point the stream suspends": a
+ * normally-closed iterable drains fully, while one left hanging (a sync-I/O
+ * abort, or a `close()` whose row hasn't flushed yet) drains to the prefix
+ * already in the stream. Both are correct — a segment's param accesses are all
+ * flushed as they happen during its render, so the prefix is exactly the set
+ * the response depends on. We therefore never need the terminating `done` row
+ * to be present; it's only stream hygiene.
+ */ function drainVaryParams(iterable, target) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    while(true){
+        const chunk = iterator.next();
+        // Attach a no-op listener to force Flight to synchronously resolve the
+        // chunk. A freshly-arrived result may be in an intermediate
+        // 'resolved_model' state (data received but not unwrapped); calling
+        // .then() transitions it to 'fulfilled', making the value available
+        // synchronously. (A native Promise has no `status` and simply reads as
+        // not-fulfilled below, so this can never hang.)
+        chunk.then(noop, noop);
+        if (chunk.status !== 'fulfilled' || chunk.value === undefined) {
+            // The stream suspended here. Everything yielded before this point has
+            // already been added.
+            return;
+        }
+        const step = chunk.value;
+        if (step.done) {
+            return;
+        }
+        target.add(step.value);
+    }
+}
+function readVaryParams(iterable, rootIterable) {
+    if (iterable === null || iterable === undefined || rootIterable === null || rootIterable === undefined) {
         return null;
     }
-    return thenable.value;
+    const varyParams = new Set();
+    drainVaryParams(iterable, varyParams);
+    drainVaryParams(rootIterable, varyParams);
+    return varyParams;
 }
 const noop = ()=>{};