gsd-pi 2.67.0-dev.43b0159 → 2.67.0-dev.a5b1d8f

package/dist/web/standalone/node_modules/next/dist/server/stream-utils/node-web-streams-helper.js

@@ -11,7 +11,9 @@ Object.defineProperty(exports, "__esModule", {
     continueStaticPrerender: null,
     createBufferedTransformStream: null,
     createDocumentClosingStream: null,
+    createInstantTestScriptInsertionTransformStream: null,
     createRootLayoutValidatorStream: null,
+    createRuntimePrefetchTransformStream: null,
     renderToInitialFizzStream: null,
     streamFromBuffer: null,
     streamFromString: null,
@@ -50,9 +52,15 @@ _export(exports, {
     createDocumentClosingStream: function() {
         return createDocumentClosingStream;
     },
+    createInstantTestScriptInsertionTransformStream: function() {
+        return createInstantTestScriptInsertionTransformStream;
+    },
     createRootLayoutValidatorStream: function() {
         return createRootLayoutValidatorStream;
     },
+    createRuntimePrefetchTransformStream: function() {
+        return createRuntimePrefetchTransformStream;
+    },
     renderToInitialFizzStream: function() {
         return renderToInitialFizzStream;
     },
@@ -79,7 +87,6 @@ const _scheduler = require("../../lib/scheduler");
 const _encodedtags = require("./encoded-tags");
 const _uint8arrayhelpers = require("./uint8array-helpers");
 const _constants1 = require("../../shared/lib/errors/constants");
-const _outputexportprefetchencoding = require("../../shared/lib/segment-cache/output-export-prefetch-encoding");
 const _approuterheaders = require("../../client/components/app-router-headers");
 const _cachebustingsearchparam = require("../../shared/lib/router/utils/cache-busting-search-param");
 function voidCatch() {
@@ -246,31 +253,6 @@ function createBufferedTransformStream(options = {}) {
         }
     });
 }
-function createPrefetchCommentStream(isBuildTimePrerendering, buildId) {
-    // Insert an extra comment at the beginning of the HTML document. This must
-    // come after the DOCTYPE, which is inserted by React.
-    //
-    // The first chunk sent by React will contain the doctype. After that, we can
-    // pass through the rest of the chunks as-is.
-    let didTransformFirstChunk = false;
-    return new TransformStream({
-        transform (chunk, controller) {
-            if (isBuildTimePrerendering && !didTransformFirstChunk) {
-                didTransformFirstChunk = true;
-                const decoder = new TextDecoder('utf-8', {
-                    fatal: true
-                });
-                const chunkStr = decoder.decode(chunk, {
-                    stream: true
-                });
-                const updatedChunkStr = (0, _outputexportprefetchencoding.insertBuildIdComment)(chunkStr, buildId);
-                controller.enqueue(encoder.encode(updatedChunkStr));
-                return;
-            }
-            controller.enqueue(chunk);
-        }
-    });
-}
 function renderToInitialFizzStream({ ReactDOMServer, element, streamOptions }) {
     return (0, _tracer.getTracer)().trace(_constants.AppRenderSpan.renderToReadableStream, async ()=>ReactDOMServer.renderToReadableStream(element, streamOptions));
 }
@@ -460,6 +442,63 @@ function createClientResumeScriptInsertionTransformStream() {
         }
     });
 }
+function createInstantTestScriptInsertionTransformStream(requestId) {
+    // Kick off a fetch for the static RSC payload. This is the hydration
+    // source for the locked static shell — same as the __NEXT_CLIENT_RESUME
+    // fetch used for fallback routes, but with NEXT_INSTANT_PREFETCH_HEADER
+    // so the server returns static-only data.
+    //
+    // The fetch promise is stored as self.__next_instant_test, which doubles
+    // as the feature flag (truthy = instant test mode). The client processes
+    // this as a fallback prerender payload for hydration.
+    const segmentPath = '/_full';
+    const cacheBustingHeader = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
+    const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
+    // In dev mode, inject self.__next_r (request ID) so that HMR WebSocket
+    // and debug channel initialization don't crash. The static shell
+    // bypasses renderToFizzStream which normally injects this via
+    // bootstrapScriptContent.
+    const requestIdScript = requestId !== null ? `self.__next_r=${JSON.stringify(requestId)};` : '';
+    const INSTANT_TEST_SCRIPT = `<script>${requestIdScript}self.__next_instant_test=fetch(location.pathname+'?${searchStr}',{credentials:'same-origin',headers:{'${_approuterheaders.RSC_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}':'${segmentPath}','${_approuterheaders.NEXT_INSTANT_PREFETCH_HEADER}':'1'}})</script>`;
+    let didAlreadyInsert = false;
+    return new TransformStream({
+        transform (chunk, controller) {
+            if (didAlreadyInsert) {
+                // Already inserted the script into the head. Pass through.
+                controller.enqueue(chunk);
+                return;
+            }
+            // Find the opening <head tag (may have attributes like <head class="...">)
+            const headOpenIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HEAD);
+            if (headOpenIndex === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            // Find the closing > of the <head ...> tag
+            const headCloseAngle = chunk.indexOf(62, headOpenIndex + _encodedtags.ENCODED_TAGS.OPENING.HEAD.length);
+            if (headCloseAngle === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const encodedInsertion = encoder.encode(INSTANT_TEST_SCRIPT);
+            const insertionPoint = headCloseAngle + 1;
+            // e.g.
+            // chunk = <!DOCTYPE html><html><head><meta charset="utf-8">...
+            // insertion = <script>self.__next_instant_test=fetch(...)</script>
+            // output = <!DOCTYPE html><html><head> [ <script>...</script> ] <meta charset="utf-8">...
+            const insertedHeadContent = new Uint8Array(chunk.length + encodedInsertion.length);
+            insertedHeadContent.set(chunk.slice(0, insertionPoint));
+            insertedHeadContent.set(encodedInsertion, insertionPoint);
+            insertedHeadContent.set(chunk.slice(insertionPoint), insertionPoint + encodedInsertion.length);
+            controller.enqueue(insertedHeadContent);
+            didAlreadyInsert = true;
+        },
+        flush (controller) {
+            // Append closing tags so the browser can parse the full document.
+            controller.enqueue(_encodedtags.ENCODED_TAGS.CLOSED.BODY_AND_HTML);
+        }
+    });
+}
 // Suffix after main body content - scripts before </body>,
 // but wait for the major chunks to be enqueued.
 function createDeferredSuffixStream(suffix) {
@@ -625,6 +664,35 @@ function createStripDocumentClosingTagsTransform() {
         }
     });
 }
+function createHtmlDataDplIdTransformStream(dplId) {
+    let didTransform = false;
+    return new TransformStream({
+        transform (chunk, controller) {
+            if (didTransform) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const htmlTagIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HTML);
+            if (htmlTagIndex === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            // Insert the data-dpl-id attribute right after "<html "
+            const insertionPoint = htmlTagIndex + _encodedtags.ENCODED_TAGS.OPENING.HTML.length;
+            const attribute = ` data-dpl-id="${dplId}"`;
+            const encodedAttribute = encoder.encode(attribute);
+            const modifiedChunk = new Uint8Array(chunk.length + encodedAttribute.length);
+            // Copy everything before the insertion point
+            modifiedChunk.set(chunk.subarray(0, insertionPoint));
+            // Insert the attribute
+            modifiedChunk.set(encodedAttribute, insertionPoint);
+            // Copy everything after
+            modifiedChunk.set(chunk.subarray(insertionPoint), insertionPoint + encodedAttribute.length);
+            controller.enqueue(modifiedChunk);
+            didTransform = true;
+        }
+    });
+}
 function createRootLayoutValidatorStream() {
     let foundHtml = false;
     let foundBody = false;
@@ -662,7 +730,7 @@ function chainTransformers(readable, transformers) {
     }
     return stream;
 }
-async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, isBuildTimePrerendering, buildId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
+async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
     // Suffix itself might contain close tags at the end, so we need to split it.
     const suffixUnclosed = suffix ? suffix.split(CLOSE_TAG, 1)[0] : null;
     if (isStaticGeneration) {
@@ -676,8 +744,8 @@ async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isS
     return chainTransformers(renderStream, [
         // Buffer everything to avoid flushing too frequently
         createBufferedTransformStream(),
-        // Add build id comment to start of the HTML document (in export mode)
-        createPrefetchCommentStream(isBuildTimePrerendering, buildId),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
         // Transform metadata
         createMetadataTransformStream(getServerInsertedMetadata),
         // Insert suffix content
@@ -694,44 +762,157 @@ async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isS
         createHeadInsertionTransformStream(getServerInsertedHTML)
     ]);
 }
-async function continueDynamicPrerender(prerenderStream, { getServerInsertedHTML, getServerInsertedMetadata }) {
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream()).pipeThrough(createStripDocumentClosingTagsTransform())// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata));
+async function continueDynamicPrerender(prerenderStream, { getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        createStripDocumentClosingTagsTransform(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata)
+    ]);
 }
-async function continueStaticPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, isBuildTimePrerendering, buildId }) {
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Add build id comment to start of the HTML document (in export mode)
-    .pipeThrough(createPrefetchCommentStream(isBuildTimePrerendering, buildId))// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, true))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+async function continueStaticPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Add build id comment to start of the HTML document (in export mode)
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, true),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
-async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, isBuildTimePrerendering, buildId }) {
+async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
     // Same as `continueStaticPrerender`, but also inserts an additional script
     // to instruct the client to start fetching the hydration data as early
     // as possible.
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Add build id comment to start of the HTML document (in export mode)
-    .pipeThrough(createPrefetchCommentStream(isBuildTimePrerendering, buildId))// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Insert the client resume script into the head
-    .pipeThrough(createClientResumeScriptInsertionTransformStream())// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, true))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Insert the client resume script into the head
+        createClientResumeScriptInsertionTransformStream(),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, true),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
-async function continueDynamicHTMLResume(renderStream, { delayDataUntilFirstHtmlChunk, inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata }) {
-    return renderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, delayDataUntilFirstHtmlChunk))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+async function continueDynamicHTMLResume(renderStream, { delayDataUntilFirstHtmlChunk, inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(renderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, delayDataUntilFirstHtmlChunk),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
 function createDocumentClosingStream() {
     return streamFromString(CLOSE_TAG);
 }
+function createRuntimePrefetchTransformStream(sentinel, isPartial, staleTime) {
+    const enc = new TextEncoder();
+    // Search for: [<sentinel>]
+    // Replace with: [<isPartial>,<staleTime>]
+    const search = enc.encode(`[${sentinel}]`);
+    const first = search[0];
+    const replace = enc.encode(`[${isPartial},${staleTime}]`);
+    const searchLen = search.length;
+    let currentChunk = null;
+    let found = false;
+    function processChunk(controller, nextChunk) {
+        if (found) {
+            if (nextChunk) {
+                controller.enqueue(nextChunk);
+            }
+            return;
+        }
+        if (currentChunk) {
+            // We can't search past the index that can contain a full match
+            let exclusiveUpperBound = currentChunk.length - (searchLen - 1);
+            if (nextChunk) {
+                // If we have any overflow bytes we can search up to the chunk's final byte
+                exclusiveUpperBound += Math.min(nextChunk.length, searchLen - 1);
+            }
+            if (exclusiveUpperBound < 1) {
+                // we can't match the current chunk.
+                controller.enqueue(currentChunk);
+                currentChunk = nextChunk // advance so we don't process this chunk again
+                ;
+                return;
+            }
+            let currentIndex = currentChunk.indexOf(first);
+            // check the current candidate match if it is within the bounds of our search space for the currentChunk
+            candidateLoop: while(-1 < currentIndex && currentIndex < exclusiveUpperBound){
+                // We already know index 0 matches because we used indexOf to find the candidateIndex so we start at index 1
+                let matchIndex = 1;
+                while(matchIndex < searchLen){
+                    const candidateIndex = currentIndex + matchIndex;
+                    const candidateValue = candidateIndex < currentChunk.length ? currentChunk[candidateIndex] : nextChunk[candidateIndex - currentChunk.length];
+                    if (candidateValue !== search[matchIndex]) {
+                        // No match, reset and continue the search from the next position
+                        currentIndex = currentChunk.indexOf(first, currentIndex + 1);
+                        continue candidateLoop;
+                    }
+                    matchIndex++;
+                }
+                // We found a complete match. currentIndex is our starting point to replace the value.
+                found = true;
+                // enqueue everything up to the match
+                controller.enqueue(currentChunk.subarray(0, currentIndex));
+                // enqueue the replacement value
+                controller.enqueue(replace);
+                // If there are bytes in the currentChunk after the match enqueue them
+                if (currentIndex + searchLen < currentChunk.length) {
+                    controller.enqueue(currentChunk.slice(currentIndex + searchLen));
+                }
+                // If we have a next chunk we enqueue it now
+                if (nextChunk) {
+                    // if replacement spills over to the next chunk we first exclude the replaced bytes
+                    const overflowBytes = currentIndex + searchLen - currentChunk.length;
+                    const truncatedChunk = overflowBytes > 0 ? nextChunk.subarray(overflowBytes) : nextChunk;
+                    controller.enqueue(truncatedChunk);
+                }
+                // We are now in found mode and don't need to track currentChunk anymore
+                currentChunk = null;
+                return;
+            }
+            // No match found in this chunk, emit it and wait for the next one
+            controller.enqueue(currentChunk);
+        }
+        // Advance to the next chunk
+        currentChunk = nextChunk;
+    }
+    return new TransformStream({
+        transform (chunk, controller) {
+            processChunk(controller, chunk);
+        },
+        flush (controller) {
+            processChunk(controller, null);
+        }
+    });
+}
 
 //# sourceMappingURL=node-web-streams-helper.js.map

package/dist/web/standalone/node_modules/next/dist/server/stream-utils/uint8array-helpers.js

@@ -29,6 +29,11 @@ _export(exports, {
 function indexOfUint8Array(a, b) {
     if (b.length === 0) return 0;
     if (a.length === 0 || b.length > a.length) return -1;
+    // Use Node's native implementation when available.
+    if (typeof Buffer !== 'undefined') {
+        const haystack = Buffer.isBuffer(a) ? a : Buffer.from(a.buffer, a.byteOffset, a.byteLength);
+        return haystack.indexOf(b);
+    }
     // start iterating through `a`
     for(let i = 0; i <= a.length - b.length; i++){
         let completeMatch = true;
@@ -58,8 +63,8 @@ function removeFromUint8Array(a, b) {
     if (tagIndex === 0) return a.subarray(b.length);
     if (tagIndex > -1) {
         const removed = new Uint8Array(a.length - b.length);
-        removed.set(a.slice(0, tagIndex));
-        removed.set(a.slice(tagIndex + b.length), tagIndex);
+        removed.set(a.subarray(0, tagIndex));
+        removed.set(a.subarray(tagIndex + b.length), tagIndex);
         return removed;
     } else {
         return a;

package/dist/web/standalone/node_modules/next/dist/server/typescript/constant.js

@@ -65,6 +65,7 @@ const LEGACY_CONFIG_EXPORT = 'config';
 const DISALLOWED_SERVER_REACT_APIS = [
     'useState',
     'useEffect',
+    'useEffectEvent',
     'useLayoutEffect',
     'useDeferredValue',
     'useImperativeHandle',

package/dist/web/standalone/node_modules/next/dist/server/typescript/rules/config.js

@@ -109,15 +109,26 @@ const API_DOCS = {
         description: '`maxDuration` allows you to set max default execution time for your function. If it is not specified, the default value is dependent on your deployment platform and plan.',
         link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#maxduration'
     },
-    unstable_prefetch: {
+    unstable_instant: {
         description: `Specifies the default prefetching behavior for this segment. This configuration is currently under development and will change.`,
         link: '(docs coming soon)',
-        type: 'object',
+        type: 'object | false',
         // TODO: ideally, we'd validate the config object somehow, but this is difficult to do
         // with the way this plugin is currently structured.
         // For now, since we don't provide an `options` here, we won't do any validation in
         // `getSemanticDiagnosticsForExportVariableStatement` below, and only provide hover a tooltip + autocomplete.
-        insertText: 'unstable_prefetch = { mode: "static" };'
+        insertText: 'unstable_instant = { prefetch: "static" };'
+    },
+    unstable_dynamicStaleTime: {
+        description: `Controls how long the client-side router cache retains dynamic page data (in seconds). Pages only — not allowed in layouts. Cannot be combined with \`unstable_instant\`.`,
+        link: '(docs coming soon)',
+        type: 'number',
+        isValid: (value)=>{
+            return Number(value.replace(/_/g, '')) >= 0;
+        },
+        getHint: (value)=>{
+            return `Set the dynamic stale time to \`${value}\` seconds.`;
+        }
     }
 };
 function visitEntryConfig(fileName, position, callback) {

package/dist/web/standalone/node_modules/next/dist/server/web/adapter.js

@@ -41,6 +41,7 @@ const _webonclose = require("./web-on-close");
 const _getedgepreviewprops = require("./get-edge-preview-props");
 const _builtinrequestcontext = require("../after/builtin-request-context");
 const _implicittags = require("../lib/implicit-tags");
+const _requestmeta = require("../request-meta");
 class NextRequestHint extends _request.NextRequest {
     constructor(params){
         super(params.input, params.init);
@@ -135,7 +136,7 @@ async function adapter(params) {
     }
     const flightHeaders = new Map();
     // Headers should only be stripped for middleware
-    if (!isEdgeRendering) {
+    if (!isEdgeRendering && !process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
         for (const header of _approuterheaders.FLIGHT_HEADERS){
             const value = requestHeaders.get(header);
             if (value !== null) {
@@ -149,7 +150,7 @@ async function adapter(params) {
     const request = new NextRequestHint({
         page: params.page,
         // Strip internal query parameters off the request.
-        input: (0, _internalutils.stripInternalSearchParams)(normalizeURL).toString(),
+        input: process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? normalizeURL.toString() : (0, _internalutils.stripInternalSearchParams)(normalizeURL).toString(),
         init: {
             body: params.request.body,
             headers: requestHeaders,
@@ -158,6 +159,9 @@ async function adapter(params) {
             signal: params.request.signal
         }
     });
+    if (params.request.requestMeta) {
+        (0, _requestmeta.setRequestMeta)(request, params.request.requestMeta);
+    }
     /**
    * This allows to identify the request as a data request. The user doesn't
    * need to know about this property neither use it. We add it for testing
@@ -227,7 +231,7 @@ async function adapter(params) {
                     const page = '/' // Fake Work
                     ;
                     const fallbackRouteParams = null;
-                    const implicitTags = await (0, _implicittags.getImplicitTags)(page, request.nextUrl, fallbackRouteParams);
+                    const implicitTags = await (0, _implicittags.getImplicitTags)(page, request.nextUrl.pathname, fallbackRouteParams);
                     const requestStore = (0, _requeststore.createRequestStoreForAPI)(request, request.nextUrl, implicitTags, onUpdateCookies, previewProps);
                     const workStore = (0, _workstore.createWorkStore)({
                         page,

package/dist/web/standalone/node_modules/next/dist/server/web/next-url.js

@@ -12,9 +12,13 @@ const _detectdomainlocale = require("../../shared/lib/i18n/detect-domain-locale"
 const _formatnextpathnameinfo = require("../../shared/lib/router/utils/format-next-pathname-info");
 const _gethostname = require("../../shared/lib/get-hostname");
 const _getnextpathnameinfo = require("../../shared/lib/router/utils/get-next-pathname-info");
-const REGEX_LOCALHOST_HOSTNAME = /(?!^https?:\/\/)(127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|\[::1\]|localhost)/;
+const REGEX_LOCALHOST_HOSTNAME = /^(?:127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|\[::1\]|localhost)$/;
 function parseURL(url, base) {
-    return new URL(String(url).replace(REGEX_LOCALHOST_HOSTNAME, 'localhost'), base && String(base).replace(REGEX_LOCALHOST_HOSTNAME, 'localhost'));
+    const parsed = new URL(String(url), base && String(base));
+    if (REGEX_LOCALHOST_HOSTNAME.test(parsed.hostname)) {
+        parsed.hostname = 'localhost';
+    }
+    return parsed;
 }
 const Internal = Symbol('NextURLInternal');
 class NextURL {

package/dist/web/standalone/node_modules/next/dist/server/web/sandbox/sandbox.js

@@ -76,6 +76,9 @@ async function getRuntimeContext(params) {
     if (params.serverComponentsHmrCache) {
         runtime.context.globalThis.__serverComponentsHmrCache = params.serverComponentsHmrCache;
     }
+    if (params.clientAssetToken) {
+        runtime.context.globalThis.NEXT_CLIENT_ASSET_SUFFIX = params.clientAssetToken ? `?dpl=${params.clientAssetToken}` : '';
+    }
     for (const paramPath of params.paths){
         evaluateInContext(paramPath);
     }

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

@@ -7,21 +7,40 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "HasLoadingBoundary", {
+Object.defineProperty(exports, "PrefetchHint", {
     enumerable: true,
     get: function() {
-        return HasLoadingBoundary;
+        return PrefetchHint;
     }
 });
-var HasLoadingBoundary = /*#__PURE__*/ function(HasLoadingBoundary) {
-    // There is a loading boundary in this particular segment
-    HasLoadingBoundary[HasLoadingBoundary["SegmentHasLoadingBoundary"] = 1] = "SegmentHasLoadingBoundary";
-    // There is a loading boundary somewhere in the subtree (but not in
-    // this segment)
-    HasLoadingBoundary[HasLoadingBoundary["SubtreeHasLoadingBoundary"] = 2] = "SubtreeHasLoadingBoundary";
-    // There is no loading boundary in this segment or any of its descendants
-    HasLoadingBoundary[HasLoadingBoundary["SubtreeHasNoLoadingBoundary"] = 3] = "SubtreeHasNoLoadingBoundary";
-    return HasLoadingBoundary;
+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";
+    // 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'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";
+    // This segment's data is inlined into one of its children — don't fetch
+    // it separately. Set at build time by the segment size measurement pass.
+    PrefetchHint[PrefetchHint["InlinedIntoChild"] = 64] = "InlinedIntoChild";
+    // On a __PAGE__: this page's response includes the head (metadata/viewport)
+    // at the end of its SegmentPrefetch[] array.
+    PrefetchHint[PrefetchHint["HeadInlinedIntoSelf"] = 128] = "HeadInlinedIntoSelf";
+    // 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";
+    return PrefetchHint;
 }({});
 
 //# sourceMappingURL=app-router-types.js.map

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

@@ -50,6 +50,7 @@ Object.defineProperty(exports, "__esModule", {
     PHASE_PRODUCTION_BUILD: null,
     PHASE_PRODUCTION_SERVER: null,
     PHASE_TEST: null,
+    PREFETCH_HINTS: null,
     PRERENDER_MANIFEST: null,
     REACT_LOADABLE_MANIFEST: null,
     ROUTES_MANIFEST: null,
@@ -70,8 +71,7 @@ Object.defineProperty(exports, "__esModule", {
     UNDERSCORE_GLOBAL_ERROR_ROUTE: null,
     UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY: null,
     UNDERSCORE_NOT_FOUND_ROUTE: null,
-    UNDERSCORE_NOT_FOUND_ROUTE_ENTRY: null,
-    WEBPACK_STATS: null
+    UNDERSCORE_NOT_FOUND_ROUTE_ENTRY: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -221,6 +221,9 @@ _export(exports, {
     PHASE_TEST: function() {
         return PHASE_TEST;
     },
+    PREFETCH_HINTS: function() {
+        return PREFETCH_HINTS;
+    },
     PRERENDER_MANIFEST: function() {
         return PRERENDER_MANIFEST;
     },
@@ -283,9 +286,6 @@ _export(exports, {
     },
     UNDERSCORE_NOT_FOUND_ROUTE_ENTRY: function() {
         return _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
-    },
-    WEBPACK_STATS: function() {
-        return WEBPACK_STATS;
     }
 });
 const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
@@ -336,7 +336,6 @@ const PHASE_DEVELOPMENT_SERVER = 'phase-development-server';
 const PHASE_TEST = 'phase-test';
 const PHASE_INFO = 'phase-info';
 const PAGES_MANIFEST = 'pages-manifest.json';
-const WEBPACK_STATS = 'webpack-stats.json';
 const APP_PATHS_MANIFEST = 'app-paths-manifest.json';
 const APP_PATH_ROUTES_MANIFEST = 'app-path-routes-manifest.json';
 const BUILD_MANIFEST = 'build-manifest.json';
@@ -346,12 +345,13 @@ const NEXT_FONT_MANIFEST = 'next-font-manifest';
 const EXPORT_MARKER = 'export-marker.json';
 const EXPORT_DETAIL = 'export-detail.json';
 const PRERENDER_MANIFEST = 'prerender-manifest.json';
+const PREFETCH_HINTS = 'prefetch-hints.json';
 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 MIDDLEWARE_MANIFEST = 'middleware-manifest.json';
-const TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST = '_clientMiddlewareManifest.json';
+const TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST = '_clientMiddlewareManifest.js';
 const TURBOPACK_CLIENT_BUILD_MANIFEST = 'client-build-manifest.json';
 const DEV_CLIENT_MIDDLEWARE_MANIFEST = '_devMiddlewareManifest.json';
 const REACT_LOADABLE_MANIFEST = 'react-loadable-manifest.json';