@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/server/route-modules/route-module.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "RouteModule", {
         return RouteModule;
     }
 });
+require("../../build/adapter/setup-node-env.external");
 const _constants = require("../../shared/lib/constants");
 const _url = require("../../lib/url");
 const _normalizelocalepath = require("../../shared/lib/i18n/normalize-locale-path");
@@ -31,7 +32,7 @@ const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _routerservercontext = require("../lib/router-utils/router-server-context");
 const _decodepathparams = require("../lib/router-utils/decode-path-params");
 const _removetrailingslash = require("../../shared/lib/router/utils/remove-trailing-slash");
-const _generateinterceptionroutesrewrites = require("../../lib/generate-interception-routes-rewrites");
+const _isinterceptionrouterewrite = require("../../lib/is-interception-route-rewrite");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -42,10 +43,31 @@ class RouteModule {
     constructor({ userland, definition, distDir, relativeProjectDir }){
         this.userland = userland;
         this.definition = definition;
-        this.isDev = process.env.NODE_ENV === 'development';
+        this.isDev = !!process.env.__NEXT_DEV_SERVER;
         this.distDir = distDir;
         this.relativeProjectDir = relativeProjectDir;
     }
+    getRouterServerContext(req) {
+        var _routerServerGlobal_RouterServerContextSymbol;
+        const hostname = (0, _requestmeta.getRequestMeta)(req, 'hostname');
+        const revalidate = (0, _requestmeta.getRequestMeta)(req, 'revalidate');
+        const render404 = (0, _requestmeta.getRequestMeta)(req, 'render404');
+        const relativeProjectDir = (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir;
+        const routerServerContext = (_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir];
+        return {
+            ...routerServerContext,
+            ...hostname !== undefined ? {
+                hostname
+            } : {},
+            ...revalidate !== undefined ? {
+                revalidate
+            } : {},
+            ...render404 !== undefined ? {
+                render404
+            } : {}
+        };
+    }
+    normalizeUrl(_req, _parsedUrl) {}
     async instrumentationOnRequestError(req, ...args) {
         if (process.env.NEXT_RUNTIME === 'edge') {
             const { getEdgeInstrumentationModule } = await import('../web/globals');
@@ -90,6 +112,7 @@ class RouteModule {
                     },
                     redirects: [],
                     headers: [],
+                    onMatchHeaders: [],
                     i18n: process.env.__NEXT_I18N_CONFIG || undefined,
                     skipProxyUrlNormalize: Boolean(process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE)
                 },
@@ -176,18 +199,21 @@ class RouteModule {
                 this.isDev ? undefined : loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
+                    shouldCache: true,
                     manifest: `${_constants.SERVER_FILES_MANIFEST}.json`
                 }),
                 this.isDev ? 'development' : loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
                     manifest: _constants.BUILD_ID_FILE,
-                    skipParse: true
+                    skipParse: true,
+                    shouldCache: true
                 }),
                 loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
                     manifest: _constants.DYNAMIC_CSS_MANIFEST,
+                    shouldCache: !this.isDev,
                     handleMissing: true
                 })
             ];
@@ -204,7 +230,7 @@ class RouteModule {
                 serverActionsManifest,
                 subresourceIntegrityManifest,
                 dynamicCssManifest,
-                interceptionRoutePatterns: routesManifest.rewrites.beforeFiles.filter(_generateinterceptionroutesrewrites.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))
+                interceptionRoutePatterns: routesManifest.rewrites.beforeFiles.filter(_isinterceptionrouterewrite.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))
             };
         }
         return result;
@@ -273,7 +299,7 @@ class RouteModule {
         }, errorContext);
     }
     /** A more lightweight version of `prepare()` for only retrieving the config on edge */ getNextConfigEdge(req) {
-        var _routerServerGlobal_RouterServerContextSymbol, _nextConfig_experimental;
+        var _nextConfig_experimental;
         if (process.env.NEXT_RUNTIME !== 'edge') {
             throw Object.defineProperty(new Error('Invariant: getNextConfigEdge must only be called in edge runtime'), "__NEXT_ERROR_CODE", {
                 value: "E968",
@@ -282,8 +308,7 @@ class RouteModule {
             });
         }
         let serverFilesManifest = self.__SERVER_FILES_MANIFEST;
-        const relativeProjectDir = (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir;
-        const routerServerContext = (_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir];
+        const routerServerContext = this.getRouterServerContext(req);
         const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
         if (!nextConfig) {
             throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
@@ -311,7 +336,7 @@ class RouteModule {
         };
     }
     async prepare(req, res, { srcPage, multiZoneDraftMode }) {
-        var _routerServerGlobal_RouterServerContextSymbol, _nextConfig_experimental;
+        var _req_headers_xforwardedproto, _nextConfig_experimental;
         let absoluteProjectDir;
         // edge runtime handles loading instrumentation at the edge adapter level
         if (process.env.NEXT_RUNTIME !== 'edge') {
@@ -326,13 +351,26 @@ class RouteModule {
             // onRequestError below
             ensureInstrumentationRegistered(absoluteProjectDir, this.distDir);
         }
-        const manifests = await this.loadManifests(srcPage, absoluteProjectDir);
+        const manifests = this.loadManifests(srcPage, absoluteProjectDir);
         const { routesManifest, prerenderManifest, serverFilesManifest } = manifests;
         const { basePath, i18n, rewrites } = routesManifest;
+        const routerServerContext = this.getRouterServerContext(req);
+        const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
+        // Injected in base-server.ts
+        const protocol = ((_req_headers_xforwardedproto = req.headers['x-forwarded-proto']) == null ? void 0 : _req_headers_xforwardedproto.includes('https')) ? 'https' : 'http';
+        // When there are hostname and port we build an absolute URL
+        if (!(0, _requestmeta.getRequestMeta)(req, 'initURL')) {
+            const initUrl = (serverFilesManifest == null ? void 0 : serverFilesManifest.config.experimental.trustHostHeader) ? `${protocol}://${req.headers.host || 'localhost'}${req.url}` : `${protocol}://${(routerServerContext == null ? void 0 : routerServerContext.hostname) || 'localhost'}${req.url}`;
+            (0, _requestmeta.addRequestMeta)(req, 'initURL', initUrl);
+            (0, _requestmeta.addRequestMeta)(req, 'initProtocol', protocol);
+        }
         if (basePath) {
             req.url = (0, _removepathprefix.removePathPrefix)(req.url || '/', basePath);
         }
         const parsedUrl = (0, _url.parseReqUrl)(req.url || '/');
+        (0, _requestmeta.addRequestMeta)(req, 'initQuery', {
+            ...parsedUrl == null ? void 0 : parsedUrl.query
+        });
         // if we couldn't parse the URL we can't continue
         if (!parsedUrl) {
             return;
@@ -342,6 +380,7 @@ class RouteModule {
             isNextDataRequest = true;
             parsedUrl.pathname = (0, _normalizedatapath.normalizeDataPath)(parsedUrl.pathname || '/');
         }
+        this.normalizeUrl(req, parsedUrl);
         let originalPathname = parsedUrl.pathname || '/';
         const originalQuery = {
             ...parsedUrl.query
@@ -373,8 +412,10 @@ class RouteModule {
             caseSensitive: Boolean(routesManifest.caseSensitive)
         });
         const domainLocale = (0, _detectdomainlocale.detectDomainLocale)(i18n == null ? void 0 : i18n.domains, (0, _gethostname.getHostname)(parsedUrl, req.headers), detectedLocale);
-        (0, _requestmeta.addRequestMeta)(req, 'isLocaleDomain', Boolean(domainLocale));
-        const defaultLocale = (domainLocale == null ? void 0 : domainLocale.defaultLocale) || (i18n == null ? void 0 : i18n.defaultLocale);
+        if (Boolean(domainLocale)) {
+            (0, _requestmeta.addRequestMeta)(req, 'isLocaleDomain', Boolean(domainLocale));
+        }
+        const defaultLocale = (0, _requestmeta.getRequestMeta)(req, 'defaultLocale') || (domainLocale == null ? void 0 : domainLocale.defaultLocale) || (i18n == null ? void 0 : i18n.defaultLocale);
         // Ensure parsedUrl.pathname includes locale before processing
         // rewrites or they won't match correctly.
         if (defaultLocale && !detectedLocale) {
@@ -444,8 +485,9 @@ class RouteModule {
             const paramsResult = serverUtils.normalizeDynamicRouteParams(params || {}, true);
             let paramsToInterpolate;
             if (// if both query and params are valid but one
-            // provided more information rely on that one
-            query && params && paramsResult.hasValidParams && queryResult.hasValidParams && Object.keys(paramsResult.params).length < Object.keys(queryResult.params).length) {
+            // provided more information and the query params
+            // were nxtP prefixed rely on that one
+            query && params && paramsResult.hasValidParams && queryResult.hasValidParams && routeParamKeys.size > 0 && Object.keys(paramsResult.params).length <= Object.keys(queryResult.params).length) {
                 paramsToInterpolate = queryResult.params;
                 params = Object.assign(queryResult.params);
             } else {
@@ -481,6 +523,11 @@ class RouteModule {
         for (const key of routeParamKeys){
             if (!(key in originalQuery)) {
                 delete query[key];
+            // handle the case where there's collision and we
+            // normalized nxtPid=123 -> id=123 but user also
+            // sends id=456 as separate key
+            } else if (originalQuery[key] && query[key] && originalQuery[key] !== query[key]) {
+                query[key] = originalQuery[key];
             }
         }
         const { isOnDemandRevalidate, revalidateOnlyGenerated } = (0, _apiutils.checkIsOnDemandRevalidate)(req, prerenderManifest.preview);
@@ -492,9 +539,6 @@ class RouteModule {
             previewData = tryGetPreviewData(req, res, prerenderManifest.preview, Boolean(multiZoneDraftMode));
             isDraftMode = previewData !== false;
         }
-        const relativeProjectDir = (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir;
-        const routerServerContext = (_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir];
-        const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
         if (!nextConfig) {
             throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
                 value: "E969",
@@ -502,6 +546,10 @@ class RouteModule {
                 configurable: true
             });
         }
+        if (process.env.NEXT_RUNTIME !== 'edge') {
+            const { installProcessErrorHandlers } = require('../node-environment-extensions/process-error-handlers');
+            installProcessErrorHandlers(Boolean(nextConfig.experimental.removeUncaughtErrorAndRejectionListeners));
+        }
         let resolvedPathname = normalizedSrcPage;
         if ((0, _utils.isDynamicRoute)(resolvedPathname) && params) {
             resolvedPathname = serverUtils.interpolateDynamicPath(resolvedPathname, params);
@@ -509,6 +557,9 @@ class RouteModule {
         if (resolvedPathname === '/index') {
             resolvedPathname = '/';
         }
+        if (res && Boolean(req.headers['x-nextjs-data']) && (!res.statusCode || res.statusCode === 200)) {
+            res.setHeader('x-nextjs-matched-path', (0, _removetrailingslash.removeTrailingSlash)(`${locale ? `/${locale}` : ''}${normalizedSrcPage}`));
+        }
         const encodedResolvedPathname = resolvedPathname;
         // we decode for cache key/manifest usage encoded is
         // for URL building
@@ -516,6 +567,7 @@ class RouteModule {
             resolvedPathname = (0, _decodepathparams.decodePathParams)(resolvedPathname);
         } catch (_) {}
         resolvedPathname = (0, _removetrailingslash.removeTrailingSlash)(resolvedPathname);
+        (0, _requestmeta.addRequestMeta)(req, 'resolvedPathname', resolvedPathname);
         let deploymentId;
         if ((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.runtimeServerDeploymentId) {
             if (!process.env.NEXT_DEPLOYMENT_ID) {
@@ -551,12 +603,13 @@ class RouteModule {
             // whole codebase (for now)
             nextConfig: nextConfig,
             routerServerContext,
-            deploymentId
+            deploymentId,
+            clientAssetToken: nextConfig.experimental.immutableAssetToken || deploymentId
         };
     }
     getResponseCache(req) {
         if (!this.responseCache) {
-            const minimalMode = (Boolean(process.env.MINIMAL_MODE) || (0, _requestmeta.getRequestMeta)(req, 'minimalMode')) ?? false;
+            const minimalMode = (0, _requestmeta.getRequestMeta)(req, 'minimalMode') ?? false;
             this.responseCache = new _responsecache.default(minimalMode);
         }
         return this.responseCache;

package/standalone/node_modules/next/dist/server/stream-utils/encoded-tags.js

@@ -19,6 +19,14 @@ const ENCODED_TAGS = {
             109,
             108
         ]),
+        // <head
+        HEAD: new Uint8Array([
+            60,
+            104,
+            101,
+            97,
+            100
+        ]),
         // <body
         BODY: new Uint8Array([
             60,

package/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/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;