@vectorize-io/hindsight-control-plane 0.6.1 → 0.6.2

package/standalone/node_modules/next/dist/lib/metadata/resolve-metadata.js

@@ -38,7 +38,6 @@ const _resolveopengraph = require("./resolvers/resolve-opengraph");
 const _resolvetitle = require("./resolvers/resolve-title");
 const _utils = require("./generate/utils");
 const _appdirmodule = require("../../server/lib/app-dir-module");
-const _interopdefault = require("../interop-default");
 const _resolvebasics = require("./resolvers/resolve-basics");
 const _resolveicons = require("./resolvers/resolve-icons");
 const _tracer = require("../../server/lib/trace/tracer");
@@ -390,10 +389,9 @@ function getDefinedMetadata(mod, props, tracingProps) {
     } : props;
 }
 async function collectStaticImagesFiles(metadata, props, type) {
-    var _this;
     if (!(metadata == null ? void 0 : metadata[type])) return undefined;
-    const iconPromises = metadata[type].map(async (imageModule)=>await (0, _interopdefault.interopDefault)(imageModule)(props));
-    return (iconPromises == null ? void 0 : iconPromises.length) > 0 ? (_this = await Promise.all(iconPromises)) == null ? void 0 : _this.flat() : undefined;
+    const iconPromises = metadata[type].map(async (imageModule)=>await imageModule(props));
+    return (iconPromises == null ? void 0 : iconPromises.length) > 0 ? (await Promise.all(iconPromises)).flat() : undefined;
 }
 async function resolveStaticMetadata(modules, props) {
     const { metadata } = modules;

package/standalone/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -72,7 +72,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions["16.2.0"];
+    const versionData = data.versions["16.2.6"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -100,7 +100,7 @@ async function patchIncorrectLockfile(dir) {
     const expectedSwcPkgs = Object.keys(_packagejson.optionalDependencies || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: "16.2.0",
+            version: "16.2.6",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -108,7 +108,7 @@ async function patchIncorrectLockfile(dir) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: "16.2.0",
+            version: "16.2.6",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,

package/standalone/node_modules/next/dist/lib/typescript/getTypeScriptConfiguration.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "getTypeScriptConfiguration", {
 const _picocolors = require("../picocolors");
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _semver = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/semver"));
 const _fatalerror = require("../fatal-error");
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../is-error"));
 function _interop_require_default(obj) {
@@ -18,6 +19,41 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+function resolvePathAliasTarget(baseUrl, target) {
+    if (_path.default.isAbsolute(target) || target.startsWith('./') || target.startsWith('../')) {
+        return target;
+    }
+    if (baseUrl === '.' || baseUrl === './') {
+        return `./${target}`;
+    }
+    const resolvedTarget = _path.default.join(baseUrl, target);
+    if (_path.default.isAbsolute(resolvedTarget) || resolvedTarget.startsWith('./') || resolvedTarget.startsWith('../')) {
+        return resolvedTarget;
+    }
+    return `./${resolvedTarget}`;
+}
+function rewritePathAliasesWithoutBaseUrl(baseUrl, originalPaths) {
+    const rewrittenPaths = originalPaths && typeof originalPaths === 'object' ? Object.fromEntries(Object.entries(originalPaths).map(([key, values])=>[
+            key,
+            Array.isArray(values) ? values.map((value)=>typeof value === 'string' ? resolvePathAliasTarget(baseUrl, value) : value) : values
+        ])) : {
+        '*': [
+            resolvePathAliasTarget(baseUrl, '*')
+        ]
+    };
+    if (!Object.prototype.hasOwnProperty.call(rewrittenPaths, '*')) {
+        rewrittenPaths['*'] = [
+            resolvePathAliasTarget(baseUrl, '*')
+        ];
+    }
+    return rewrittenPaths;
+}
+function getNormalizedBaseUrlForPaths(baseUrl, tsConfigPath) {
+    const tsConfigDir = _path.default.resolve(_path.default.dirname(tsConfigPath));
+    const absoluteBaseUrl = _path.default.isAbsolute(baseUrl) ? baseUrl : baseUrl.startsWith('./') || baseUrl.startsWith('../') ? _path.default.resolve(tsConfigDir, baseUrl) : _path.default.resolve(baseUrl);
+    const relativeBaseUrl = _path.default.relative(tsConfigDir, absoluteBaseUrl);
+    return relativeBaseUrl || '.';
+}
 async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
     try {
         var _result_errors;
@@ -35,6 +71,39 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
             });
         }
         let configToParse = config;
+        if (_semver.default.gte(typescript.version, '6.0.0')) {
+            var _configToParse_compilerOptions, _configToParse_compilerOptions1;
+            const target = (_configToParse_compilerOptions = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions.target;
+            if (typeof target === 'string' && (target.toLowerCase() === 'es3' || target.toLowerCase() === 'es5')) {
+                const { target: _target, ...restCompilerOptions } = configToParse.compilerOptions ?? {};
+                // TypeScript 6 deprecates ES3/ES5 targets. Rewrite deprecated
+                // targets in-memory to keep typechecking working without requiring
+                // `ignoreDeprecations`.
+                configToParse = {
+                    ...configToParse,
+                    compilerOptions: {
+                        ...restCompilerOptions,
+                        target: 'es2015'
+                    }
+                };
+            }
+            const baseUrl = (_configToParse_compilerOptions1 = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions1.baseUrl;
+            const hasBaseUrl = typeof baseUrl === 'string' && baseUrl.length > 0;
+            if (hasBaseUrl) {
+                var _configToParse_compilerOptions2;
+                const rewrittenPaths = rewritePathAliasesWithoutBaseUrl(baseUrl, (_configToParse_compilerOptions2 = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions2.paths);
+                const { baseUrl: _baseUrl, ...restCompilerOptions } = configToParse.compilerOptions ?? {};
+                // TypeScript 6 deprecates `baseUrl`; rewrite aliases to explicit
+                // relative paths so path mapping still works without this option.
+                configToParse = {
+                    ...configToParse,
+                    compilerOptions: {
+                        ...restCompilerOptions,
+                        paths: rewrittenPaths
+                    }
+                };
+            }
+        }
         const result = typescript.parseJsonConfigFileContent(configToParse, // When only interested in meta info,
         // avoid enumerating all files (for performance reasons)
         metaOnly ? {
@@ -45,6 +114,17 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
                 ];
             }
         } : typescript.sys, _path.default.dirname(tsConfigPath));
+        if (_semver.default.gte(typescript.version, '6.0.0')) {
+            const parsedBaseUrl = result.options.baseUrl;
+            if (typeof parsedBaseUrl === 'string' && parsedBaseUrl.length > 0) {
+                const normalizedBaseUrl = getNormalizedBaseUrlForPaths(parsedBaseUrl, tsConfigPath);
+                // `baseUrl` can come from extended tsconfigs. Rewrite paths from the
+                // fully-resolved baseUrl and remove it so TS6 deprecation checks do not
+                // fail type checking.
+                result.options.paths = rewritePathAliasesWithoutBaseUrl(normalizedBaseUrl, result.options.paths);
+                delete result.options.baseUrl;
+            }
+        }
         if (result.errors) {
             result.errors = result.errors.filter(({ code })=>// No inputs were found in config file
                 code !== 18003);

package/standalone/node_modules/next/dist/lib/typescript/writeConfigurationDefaults.js

@@ -74,7 +74,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 function getDesiredCompilerOptions(typescriptVersion, userTsConfig) {
-    var _userTsConfig_compilerOptions_module, _userTsConfig_compilerOptions, _userTsConfig_compilerOptions1;
+    var _userTsConfig_compilerOptions, _userTsConfig_compilerOptions_module, _userTsConfig_compilerOptions1, _userTsConfig_compilerOptions2;
     // ModuleKind
     const moduleKindESNext = 'esnext';
     const moduleKindES2020 = 'es2020';
@@ -85,9 +85,12 @@ function getDesiredCompilerOptions(typescriptVersion, userTsConfig) {
     const moduleKindAMD = 'amd';
     // ModuleResolutionKind
     const moduleResolutionKindBundler = 'bundler';
-    const moduleResolutionKindNode10 = 'node10';
+    const moduleResolutionKindNode16 = 'node16';
+    const moduleResolutionKindNodeNext = 'nodenext';
     const moduleResolutionKindNode12 = 'node12';
-    const moduleResolutionKindNodeJs = 'node';
+    const moduleResolutionKindNode = 'node';
+    const configuredModule = typeof (userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions.module) === 'string' ? userTsConfig.compilerOptions.module.toLowerCase() : undefined;
+    const preferBundlerResolution = _semver.default.gte(typescriptVersion, '5.0.0') && configuredModule !== moduleKindCommonJS && configuredModule !== moduleKindAMD;
     // Jsx
     const jsxEmitReactJSX = 'react-jsx';
     return {
@@ -138,35 +141,35 @@ function getDesiredCompilerOptions(typescriptVersion, userTsConfig) {
             reason: 'for dynamic import() support'
         },
         // TODO: Semver check not needed once Next.js repo uses 5.4.
-        ..._semver.default.gte(typescriptVersion, '5.4.0') && (userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions = userTsConfig.compilerOptions) == null ? void 0 : (_userTsConfig_compilerOptions_module = _userTsConfig_compilerOptions.module) == null ? void 0 : _userTsConfig_compilerOptions_module.toLowerCase()) === moduleKindPreserve ? {
+        ..._semver.default.gte(typescriptVersion, '5.4.0') && (userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions1 = userTsConfig.compilerOptions) == null ? void 0 : (_userTsConfig_compilerOptions_module = _userTsConfig_compilerOptions1.module) == null ? void 0 : _userTsConfig_compilerOptions_module.toLowerCase()) === moduleKindPreserve ? {
         } : {
             esModuleInterop: {
                 value: true,
                 reason: 'requirement for SWC / babel'
             },
             moduleResolution: {
-                // In TypeScript 5.0, `NodeJs` has renamed to `Node10`
-                parsedValue: moduleResolutionKindBundler,
+                parsedValue: preferBundlerResolution ? moduleResolutionKindBundler : moduleResolutionKindNode,
                 // All of these values work:
-                parsedValues: [
-                    moduleResolutionKindNode10,
-                    moduleResolutionKindNodeJs,
-                    // only newer TypeScript versions have this field, it
-                    // will be filtered for new versions of TypeScript
-                    moduleResolutionKindNode12,
-                    moduleKindNode16,
-                    moduleKindNodeNext,
+                parsedValues: preferBundlerResolution ? [
+                    moduleResolutionKindNode16,
+                    moduleResolutionKindNodeNext,
                     moduleResolutionKindBundler
-                ].filter((val)=>typeof val !== 'undefined'),
-                value: 'node',
-                reason: 'to match webpack resolution'
+                ] : [
+                    moduleResolutionKindNode,
+                    // only older TypeScript versions have this field
+                    moduleResolutionKindNode12,
+                    moduleResolutionKindNode16,
+                    moduleResolutionKindNodeNext
+                ],
+                value: preferBundlerResolution ? moduleResolutionKindBundler : moduleResolutionKindNode,
+                reason: preferBundlerResolution ? 'to match modern bundler resolution' : 'to match webpack resolution'
             },
             resolveJsonModule: {
                 value: true,
                 reason: 'to match webpack resolution'
             }
         },
-        ...(userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions1 = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions1.verbatimModuleSyntax) === true ? undefined : {
+        ...(userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions2 = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions2.verbatimModuleSyntax) === true ? undefined : {
             isolatedModules: {
                 value: true,
                 reason: 'requirement for SWC / Babel'
@@ -206,9 +209,10 @@ function getRequiredConfiguration(typescript) {
         } else if (optionKey === 'moduleResolution' && typeof value === 'string') {
             const moduleResolutionMap = {
                 bundler: typescript.ModuleResolutionKind.Bundler,
-                node10: typescript.ModuleResolutionKind.Node10,
+                node16: typescript.ModuleResolutionKind.Node16,
+                nodenext: typescript.ModuleResolutionKind.NodeNext,
                 node12: typescript.ModuleResolutionKind.Node12,
-                node: typescript.ModuleResolutionKind.NodeJs
+                node: typescript.ModuleResolutionKind.Node10 ?? typescript.ModuleResolutionKind.NodeJs
             };
             res[optionKey] = moduleResolutionMap[value.toLowerCase()] ?? value;
         } else if (optionKey === 'jsx' && typeof value === 'string') {

package/standalone/node_modules/next/dist/server/app-render/action-handler.js

@@ -47,6 +47,7 @@ const _revalidationutils = require("../revalidation-utils");
 const _requestmeta = require("../request-meta");
 const _setcachebustingsearchparam = require("../../client/components/router-reducer/set-cache-busting-search-param");
 const _actionrevalidationkind = require("../../shared/lib/action-revalidation-kind");
+const _cachebustingsearchparam = require("../../shared/lib/router/utils/cache-busting-search-param");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -265,12 +266,8 @@ async function createRedirectRenderResult(req, res, originalHost, redirectUrl, r
         forwardedHeaders.delete(_approuterheaders.ACTION_HEADER);
         try {
             var _response_headers_get;
-            (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, {
-                [_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER]: forwardedHeaders.get(_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER) ? '1' : undefined,
-                [_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER]: forwardedHeaders.get(_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER) ?? undefined,
-                [_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]: forwardedHeaders.get(_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER) ?? undefined,
-                [_approuterheaders.NEXT_URL]: forwardedHeaders.get(_approuterheaders.NEXT_URL) ?? undefined
-            });
+            const cacheBustingSearchParam = await (0, _cachebustingsearchparam.computeCacheBustingSearchParam)(forwardedHeaders.get(_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER) ? '1' : undefined, forwardedHeaders.get(_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER) ?? undefined, forwardedHeaders.get(_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER) ?? undefined, forwardedHeaders.get(_approuterheaders.NEXT_URL) ?? undefined);
+            (0, _setcachebustingsearchparam.setCacheBustingSearchParamWithHash)(fetchUrl, cacheBustingSearchParam);
             const response = await fetch(fetchUrl, {
                 method: 'GET',
                 headers: forwardedHeaders,

package/standalone/node_modules/next/dist/server/app-render/app-render.js

@@ -17,6 +17,7 @@ const _internalutils = require("../internal-utils");
 const _approuterheaders = require("../../client/components/app-router-headers");
 const _metadatacontext = require("../../lib/metadata/metadata-context");
 const _requeststore = require("../async-storage/request-store");
+const _isrscrequest = require("../lib/is-rsc-request");
 const _workstore = require("../async-storage/work-store");
 const _httpaccessfallback = require("../../client/components/http-access-fallback/http-access-fallback");
 const _redirect = require("../../client/components/redirect");
@@ -158,7 +159,7 @@ function parseRequestHeaders(headers, options) {
     const isPrefetchRequest = headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '1';
     const isRuntimePrefetchRequest = headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '2';
     const isHmrRefresh = headers[_approuterheaders.NEXT_HMR_REFRESH_HEADER] !== undefined;
-    const isRSCRequest = headers[_approuterheaders.RSC_HEADER] !== undefined;
+    const isRSCRequest = (0, _isrscrequest.isRSCRequestHeader)(headers[_approuterheaders.RSC_HEADER]);
     const shouldProvideFlightRouterState = isRSCRequest && (!isPrefetchRequest || !options.isRoutePPREnabled);
     const flightRouterState = shouldProvideFlightRouterState ? (0, _parseandvalidateflightrouterstate.parseAndValidateFlightRouterState)(headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]) : undefined;
     // Checks if this is a prefetch of the Route Tree by the Segment Cache
@@ -252,6 +253,29 @@ function createNotFoundLoaderTree(loaderTree) {
         null
     ];
 }
+function hasPrerenderHTTPErrorBoundary(loaderTree, triggeredStatus, authInterrupts) {
+    switch(triggeredStatus){
+        case 404:
+            return !!loaderTree[2]['not-found'];
+        case 403:
+            return authInterrupts && !!loaderTree[2].forbidden;
+        case 401:
+            return authInterrupts && !!loaderTree[2].unauthorized;
+        default:
+            return false;
+    }
+}
+function findPrerenderHTTPErrorBoundaryTree(loaderTree, triggeredStatus, authInterrupts) {
+    let boundaryTree = hasPrerenderHTTPErrorBoundary(loaderTree, triggeredStatus, authInterrupts) ? loaderTree : null;
+    const childrenTree = loaderTree[1].children;
+    if (childrenTree) {
+        const deeperBoundaryTree = findPrerenderHTTPErrorBoundaryTree(childrenTree, triggeredStatus, authInterrupts);
+        if (deeperBoundaryTree) {
+            boundaryTree = deeperBoundaryTree;
+        }
+    }
+    return boundaryTree;
+}
 /**
  * Returns a function that parses the dynamic segment and return the associated value.
  */ function makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams, optimisticRouting) {
@@ -940,7 +964,7 @@ function getRenderedSearch(query) {
 // This is the data necessary to render <AppRouter /> when no SSR errors are encountered
 async function getRSCPayload(tree, ctx, options) {
     var _ctx_renderOpts_prefetchHints;
-    const { is404, staleTimeIterable, staticStageByteLengthPromise, runtimePrefetchStream } = options;
+    const { is404, prerenderHTTPError, staleTimeIterable, staticStageByteLengthPromise, runtimePrefetchStream } = options;
     const injectedCSS = new Set();
     const injectedJS = new Set();
     const injectedFontPreloadTags = new Set();
@@ -984,7 +1008,8 @@ async function getRSCPayload(tree, ctx, options) {
         missingSlots,
         preloadCallbacks,
         authInterrupts: ctx.renderOpts.experimental.authInterrupts,
-        MetadataOutlet
+        MetadataOutlet,
+        prerenderHTTPError
     });
     // When the `vary` response header is present with `Next-URL`, that means there's a chance
     // it could respond differently if there's an interception route. We provide this information
@@ -1589,6 +1614,7 @@ const renderToHTMLOrFlight = (req, res, pagePath, query, fallbackRouteParams, re
         // @TODO move to workUnitStore of type Request
         isPrefetchRequest,
         buildId: sharedContext.buildId,
+        deploymentId: sharedContext.deploymentId,
         previouslyRevalidatedTags,
         nonce
     });
@@ -3199,6 +3225,7 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
         isDraftMode: false,
         isPrefetchRequest: false,
         buildId: outerWorkStore.buildId,
+        deploymentId: outerWorkStore.deploymentId,
         reactLoadableManifest: outerWorkStore.reactLoadableManifest,
         assetPrefix: outerWorkStore.assetPrefix,
         nonce: outerWorkStore.nonce,
@@ -4285,11 +4312,35 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ...(prerenderStore == null ? void 0 : prerenderStore.tags) || implicitTags.tags
             ]
         };
-        const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? undefined : err, errorType);
-        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFlightStream, ComponentMod, errorRSCPayload, clientModules, {
+        let prerenderHTTPError;
+        if (cacheComponents && (0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+            const triggeredStatus = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+            const boundaryTree = findPrerenderHTTPErrorBoundaryTree(tree, triggeredStatus, ctx.renderOpts.experimental.authInterrupts);
+            if (boundaryTree) {
+                prerenderHTTPError = {
+                    boundaryTree,
+                    triggeredStatus
+                };
+            }
+        }
+        const errorRSCPayload = prerenderHTTPError ? await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getRSCPayload, tree, ctx, {
+            is404: errorType === 'not-found',
+            prerenderHTTPError
+        }) : await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? undefined : err, errorType);
+        const errorServerStreamRaw = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFlightStream, ComponentMod, errorRSCPayload, clientModules, {
             filterStackFrame,
             onError: serverComponentsErrorHandler
         });
+        let errorServerStream = errorServerStreamRaw;
+        const errorFlightResultPromise = prerenderHTTPError ? (()=>{
+            // Fizz still needs to read the Flight stream to render ErrorApp, but
+            // the prerender path also needs a buffered Flight result for the HTML
+            // prelude and segment data collectors. Tee the stream so each consumer
+            // gets its own copy.
+            const [appStream, flightStream] = errorServerStreamRaw.tee();
+            errorServerStream = appStream;
+            return (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(flightStream);
+        })() : null;
         try {
             const { stream: errorHtmlStream } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFizzStream, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
             /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
@@ -4305,14 +4356,16 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 formState
             });
+            const resolvedFlightResult = errorFlightResultPromise ? await errorFlightResultPromise : reactServerPrerenderResult;
+            if (errorFlightResultPromise) {
+                reactServerPrerenderResult.consume();
+            }
             if (shouldGenerateStaticFlightData(workStore)) {
-                const flightData = await (0, _streamops.streamToBuffer)(reactServerPrerenderResult.asStream());
+                const flightData = await (0, _streamops.streamToBuffer)(resolvedFlightResult.asStream());
                 metadata.flightData = flightData;
                 await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             }
-            // This is intentionally using the readable datastream from the main
-            // render rather than the flight data from the error page render
-            const flightStream = reactServerPrerenderResult.consumeAsStream();
+            const flightStream = resolvedFlightResult.consumeAsStream();
             return {
                 digestErrorsMap: reactServerErrorsByDigest,
                 ssrErrors: allCapturedErrors,

package/standalone/node_modules/next/dist/server/app-render/collect-segment-data.js

@@ -121,8 +121,24 @@ async function collectSegmentData(isCacheComponentsEnabled, fullPageDataBuffer,
     // Now that we've finished rendering the route tree, all the segment tasks
     // should have been spawned. Await them in parallel and write the segment
     // prefetches to the result map.
+    let hasPageSegment = false;
     for (const [segmentPath, buffer] of (await Promise.all(segmentTasks))){
         resultMap.set(segmentPath, buffer);
+        if (segmentPath.endsWith('__PAGE__')) {
+            hasPageSegment = true;
+        }
+    }
+    if (!hasPageSegment) {
+        // The build requires at least one segment path ending with __PAGE__ to
+        // register the catch-all segment data route. When all page segments are
+        // disabled (e.g. every leaf has runtime prefetching), no __PAGE__ entry
+        // is emitted. Write a dummy entry with a path that doesn't match any
+        // real route segment so the client will never request it.
+        //
+        // TODO: Remove the __PAGE__ requirement from the build instead of
+        // working around it here. The invariant is outdated now that segments
+        // can be disabled.
+        resultMap.set('/todo-remove-fake-segment/__PAGE__', Buffer.alloc(0));
     }
     return resultMap;
 }

package/standalone/node_modules/next/dist/server/app-render/create-component-tree.js

@@ -51,7 +51,7 @@ function errorMissingDefaultExport(pagePath, convention) {
     });
 }
 const cacheNodeKey = 'c';
-async function createComponentTreeInternal({ loaderTree: tree, parentParams, parentOptionalCatchAllParamName, parentRuntimePrefetchable, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, missingSlots, preloadCallbacks, authInterrupts, MetadataOutlet }, isRoot) {
+async function createComponentTreeInternal({ loaderTree: tree, parentParams, parentOptionalCatchAllParamName, parentRuntimePrefetchable, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, missingSlots, preloadCallbacks, authInterrupts, MetadataOutlet, prerenderHTTPError }, isRoot) {
     const { renderOpts: { nextConfigOutput, experimental, cacheComponents }, workStore, componentMod: { createElement, Fragment, SegmentViewNode, HTTPAccessFallbackBoundary, LayoutRouter, RenderFromTemplateContext, ClientPageRoot, ClientSegmentRoot, createServerSearchParamsForServerPage, createPrerenderSearchParamsForClientPage, createServerParamsForServerSegment, createPrerenderParamsForClientSegment, serverHooks: { DynamicServerError }, Postpone }, pagePath, getDynamicParamFromSegment, isPrefetch, query } = ctx;
     const { page, conventionPath, segment, modules, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
     const { layout, template, error, loading, 'not-found': notFound, forbidden, unauthorized } = modules;
@@ -382,24 +382,54 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
                     missingSlots.add(parallelRouteKey);
                 }
             }
-            const seedData = await createComponentTreeInternal({
-                loaderTree: parallelRoute,
-                parentParams: currentParams,
-                parentOptionalCatchAllParamName: optionalCatchAllParamName,
-                parentRuntimePrefetchable: isRuntimePrefetchable,
-                rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove,
-                injectedCSS: injectedCSSWithCurrentLayout,
-                injectedJS: injectedJSWithCurrentLayout,
-                injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout,
-                ctx,
-                missingSlots,
-                preloadCallbacks,
-                authInterrupts,
-                // `StreamingMetadataOutlet` is used to conditionally throw. In the case of parallel routes we will have more than one page
-                // but we only want to throw on the first one.
-                MetadataOutlet: isChildrenRouteKey ? MetadataOutlet : null
-            }, false);
-            childCacheNodeSeedData = seedData;
+            // The outer prerender catch already found the deepest segment whose
+            // HTTP fallback should replace the throwing page. When we reach that
+            // segment's `children` slot, render the fallback directly instead of
+            // descending back into the subtree that threw during deserialization.
+            // Like the other segment-level boundary props below, HTTP access
+            // fallbacks are attached to the default `children` slot, not to named
+            // parallel routes.
+            const shouldRenderPrerenderHTTPFallback = (prerenderHTTPError == null ? void 0 : prerenderHTTPError.boundaryTree) === tree && isChildrenRouteKey;
+            if (shouldRenderPrerenderHTTPFallback) {
+                let fallbackElement;
+                switch(prerenderHTTPError.triggeredStatus){
+                    case 404:
+                        fallbackElement = notFoundElement;
+                        break;
+                    case 403:
+                        fallbackElement = forbiddenElement;
+                        break;
+                    case 401:
+                        fallbackElement = unauthorizedElement;
+                        break;
+                    default:
+                        break;
+                }
+                if (fallbackElement) {
+                    childCacheNodeSeedData = createSeedData(ctx, fallbackElement, {}, null, isPossiblyPartialResponse, false, _varyparams.emptyVaryParamsAccumulator);
+                }
+            }
+            if (childCacheNodeSeedData === null) {
+                const seedData = await createComponentTreeInternal({
+                    loaderTree: parallelRoute,
+                    parentParams: currentParams,
+                    parentOptionalCatchAllParamName: optionalCatchAllParamName,
+                    parentRuntimePrefetchable: isRuntimePrefetchable,
+                    rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove,
+                    injectedCSS: injectedCSSWithCurrentLayout,
+                    injectedJS: injectedJSWithCurrentLayout,
+                    injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout,
+                    ctx,
+                    missingSlots,
+                    preloadCallbacks,
+                    authInterrupts,
+                    // `StreamingMetadataOutlet` is used to conditionally throw. In the case of parallel routes we will have more than one page
+                    // but we only want to throw on the first one.
+                    MetadataOutlet: isChildrenRouteKey ? MetadataOutlet : null,
+                    prerenderHTTPError
+                }, false);
+                childCacheNodeSeedData = seedData;
+            }
         }
         const templateNode = createElement(Template, null, createElement(RenderFromTemplateContext, null));
         const templateFilePath = (0, _segmentexplorerpath.getConventionPathByType)(tree, dir, 'template');

package/standalone/node_modules/next/dist/server/app-render/get-script-nonce-from-header.js

@@ -8,9 +8,8 @@ Object.defineProperty(exports, "getScriptNonceFromHeader", {
         return getScriptNonceFromHeader;
     }
 });
-const _htmlescape = require("../htmlescape");
+const CSP_NONCE_SOURCE_REGEX = /^'nonce-([A-Za-z0-9+/_-]+={0,2})'$/;
 function getScriptNonceFromHeader(cspHeaderValue) {
-    var _directive_split_slice_map_find;
     const directives = cspHeaderValue// Directives are split by ';'.
     .split(';').map((directive)=>directive.trim());
     // First try to find the directive for the 'script-src', otherwise try to
@@ -20,25 +19,14 @@ function getScriptNonceFromHeader(cspHeaderValue) {
     if (!directive) {
         return;
     }
-    // Extract the nonce from the directive
-    const nonce = (_directive_split_slice_map_find = directive.split(' ')// Remove the 'strict-src'/'default-src' string, this can't be the nonce.
-    .slice(1).map((source)=>source.trim())// Find the first source with the 'nonce-' prefix.
-    .find((source)=>source.startsWith("'nonce-") && source.length > 8 && source.endsWith("'"))) == null ? void 0 : _directive_split_slice_map_find.slice(7, -1);
-    // If we could't find the nonce, then we're done.
-    if (!nonce) {
-        return;
-    }
-    // Don't accept the nonce value if it contains HTML escape characters.
-    // Technically, the spec requires a base64'd value, but this is just an
-    // extra layer.
-    if (_htmlescape.ESCAPE_REGEX.test(nonce)) {
-        throw Object.defineProperty(new Error('Nonce value from Content-Security-Policy contained HTML escape characters.\nLearn more: https://nextjs.org/docs/messages/nonce-contained-invalid-characters'), "__NEXT_ERROR_CODE", {
-            value: "E440",
-            enumerable: false,
-            configurable: true
-        });
+    // Extract the first valid nonce from the directive. Malformed nonces are
+    // ignored so the request can continue without a nonce instead of failing.
+    for (const source of directive.split(/\s+/).slice(1)){
+        const match = source.trim().match(CSP_NONCE_SOURCE_REGEX);
+        if (match) {
+            return match[1];
+        }
     }
-    return nonce;
 }
 
 //# sourceMappingURL=get-script-nonce-from-header.js.map

package/standalone/node_modules/next/dist/server/app-render/metadata-insertion/create-server-inserted-metadata.js

@@ -1,8 +1,4 @@
-/**
- * For chromium based browsers (Chrome, Edge, etc.) and Safari,
- * icons need to stay under <head> to be picked up by the browser.
- *
- */ "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -12,7 +8,12 @@ Object.defineProperty(exports, "createServerInsertedMetadata", {
         return createServerInsertedMetadata;
     }
 });
-const REINSERT_ICON_SCRIPT = `\
+const _htmlescape = require("../../../shared/lib/htmlescape");
+/**
+ * For chromium based browsers (Chrome, Edge, etc.) and Safari,
+ * icons need to stay under <head> to be picked up by the browser.
+ *
+ */ const REINSERT_ICON_SCRIPT = `\
 document.querySelectorAll('body link[rel="icon"], body link[rel="apple-touch-icon"]').forEach(el => document.head.appendChild(el))`;
 function createServerInsertedMetadata(nonce) {
     let inserted = false;
@@ -21,7 +22,7 @@ function createServerInsertedMetadata(nonce) {
             return '';
         }
         inserted = true;
-        return `<script ${nonce ? `nonce="${nonce}"` : ''}>${REINSERT_ICON_SCRIPT}</script>`;
+        return `<script${nonce ? ` nonce="${(0, _htmlescape.htmlEscapeAttributeString)(nonce)}"` : ''}>${REINSERT_ICON_SCRIPT}</script>`;
     };
 }
 

package/standalone/node_modules/next/dist/server/app-render/use-flight-response.js

@@ -20,7 +20,7 @@ _export(exports, {
         return getFlightStream;
     }
 });
-const _htmlescape = require("../htmlescape");
+const _htmlescape = require("../../shared/lib/htmlescape");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _manifestssingleton = require("./manifests-singleton");
@@ -135,7 +135,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
     return newResponse;
 }
 function createInlinedDataReadableStream(flightStream, nonce, formState) {
-    const startScriptTag = nonce ? `<script nonce=${JSON.stringify(nonce)}>` : '<script>';
+    const startScriptTag = nonce ? `<script nonce="${(0, _htmlescape.htmlEscapeAttributeString)(nonce)}">` : '<script>';
     const flightReader = flightStream.getReader();
     const decoder = new TextDecoder('utf-8', {
         fatal: true

package/standalone/node_modules/next/dist/server/async-storage/work-store.js

@@ -13,7 +13,7 @@ const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _lazyresult = require("../lib/lazy-result");
 const _handlers = require("../use-cache/handlers");
 const _asynclocalstorage = require("../app-render/async-local-storage");
-function createWorkStore({ page, renderOpts, isPrefetchRequest, buildId, previouslyRevalidatedTags, nonce }) {
+function createWorkStore({ page, renderOpts, isPrefetchRequest, buildId, deploymentId, previouslyRevalidatedTags, nonce }) {
     /**
    * Rules of Static & Dynamic HTML:
    *
@@ -49,6 +49,7 @@ function createWorkStore({ page, renderOpts, isPrefetchRequest, buildId, previou
         isDraftMode: renderOpts.isDraftMode,
         isPrefetchRequest,
         buildId,
+        deploymentId,
         reactLoadableManifest: (renderOpts == null ? void 0 : renderOpts.reactLoadableManifest) || {},
         assetPrefix: (renderOpts == null ? void 0 : renderOpts.assetPrefix) || '',
         nonce,