failproofai 1.0.11-beta.0 → 1.0.11-beta.2

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

@@ -10,11 +10,7 @@ Object.defineProperty(exports, "lazyRenderPagesPage", {
 });
 const lazyRenderPagesPage = (...args)=>{
     if (process.env.NEXT_MINIMAL) {
-        throw Object.defineProperty(new Error("Can't use lazyRenderPagesPage in minimal mode"), "__NEXT_ERROR_CODE", {
-            value: "E272",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error("Can't use lazyRenderPagesPage in minimal mode");
     } else {
         const render = require('./module.compiled').renderToHTML;
         return render(...args);

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

@@ -86,7 +86,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                 res.end('This page could not be found');
             }
         };
-        const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname, deploymentId, clientAssetToken } = prepareResult;
+        const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, previewProps, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname, deploymentId, clientAssetToken } = prepareResult;
         const isExperimentalCompile = serverFilesManifest == null ? void 0 : (_serverFilesManifest_config = serverFilesManifest.config) == null ? void 0 : (_serverFilesManifest_config_experimental = _serverFilesManifest_config.experimental) == null ? void 0 : _serverFilesManifest_config_experimental.isExperimentalCompile;
         const hasServerProps = Boolean(getServerSideProps);
         const hasStaticProps = Boolean(getStaticProps);
@@ -182,8 +182,8 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                                 buildManifest: isFallbackError ? fallbackBuildManifest : buildManifest,
                                 nextFontManifest,
                                 reactLoadableManifest,
-                                assetPrefix: nextConfig.assetPrefix,
-                                previewProps: prerenderManifest.preview,
+                                assetPrefix: routeModule.getAssetPrefixForRender(routerServerContext, nextConfig.assetPrefix),
+                                previewProps,
                                 images: nextConfig.images,
                                 nextConfigOutput: nextConfig.output,
                                 optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
@@ -295,9 +295,12 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                         isFallback: true,
                         isRoutePPREnabled: false,
                         isOnDemandRevalidate: false,
-                        incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode),
+                        incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, previewProps, prerenderManifest, isMinimalMode),
                         waitUntil: ctx.waitUntil
                     });
+                    if (fallbackResponse !== null && 'error' in fallbackResponse) {
+                        throw fallbackResponse.error;
+                    }
                     if (fallbackResponse) {
                         // Remove the cache control from the response to prevent it from being
                         // used in the surrounding cache.
@@ -346,9 +349,13 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                     revalidateOnlyGenerated,
                     waitUntil: ctx.waitUntil,
                     responseGenerator: responseGenerator,
+                    previewProps,
                     prerenderManifest,
                     isMinimalMode
                 });
+                if (result !== null && 'error' in result) {
+                    throw result.error;
+                }
                 // if we got a cache hit this wasn't an ISR fallback
                 // but it wasn't generated during build so isn't in the
                 // prerender-manifest
@@ -386,11 +393,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                     // a number, use it.
                     if (typeof result.cacheControl.revalidate === 'number') {
                         if (result.cacheControl.revalidate < 1) {
-                            throw Object.defineProperty(new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`), "__NEXT_ERROR_CODE", {
-                                value: "E22",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`);
                         }
                         cacheControl = {
                             revalidate: result.cacheControl.revalidate,
@@ -462,15 +465,16 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                     }
                 }
                 if (result.value.kind !== _responsecache.CachedRouteKind.PAGES) {
-                    throw Object.defineProperty(new Error(`Invariant: received non-pages cache entry in pages handler`), "__NEXT_ERROR_CODE", {
-                        value: "E695",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Invariant: received non-pages cache entry in pages handler`);
                 }
-                // In dev, we should not cache pages for any reason.
+                // Documents and data responses must not be stored in development.
+                // Browsers reuse a stored response for a history navigation without
+                // revalidating it, so a back navigation would restore a page from
+                // before the latest edit. Static assets never reach this code. They
+                // keep a revalidatable `Cache-Control`, so the browser caches them
+                // between page loads.
                 if (routeModule.isDev) {
-                    res.setHeader('Cache-Control', 'no-cache, must-revalidate');
+                    res.setHeader('Cache-Control', 'no-store');
                 }
                 // Draft mode should never be cached
                 if (isDraftMode) {

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

@@ -27,11 +27,7 @@ class PagesAPIRouteModule extends _routemodule.RouteModule {
     constructor(options){
         super(options);
         if (typeof options.userland.default !== 'function') {
-            throw Object.defineProperty(new Error(`Page ${options.definition.page} does not export a default function.`), "__NEXT_ERROR_CODE", {
-                value: "E379",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Page ${options.definition.page} does not export a default function.`);
         }
         this.apiResolverWrapped = (0, _apiutils.wrapApiHandler)(options.definition.page, _apiresolver.apiResolver);
     }

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

@@ -35,6 +35,8 @@ 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 _isinterceptionrouterewrite = require("../../lib/is-interception-route-rewrite");
+const _tracer = require("../lib/trace/tracer");
+const _constants1 = require("../lib/trace/constants");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -73,6 +75,14 @@ class RouteModule {
             } : {}
         };
     }
+    getAssetPrefixForRender(routerServerContext, configuredAssetPrefix) {
+        // A running NextServer owns overrides from app.setAssetPrefix().
+        if (routerServerContext && routerServerContext.getAssetPrefix) {
+            return routerServerContext.getAssetPrefix();
+        }
+        // Direct route invocations use the configured prefix.
+        return configuredAssetPrefix;
+    }
     normalizeUrl(_req, _parsedUrl) {}
     async instrumentationOnRequestError(req, ...args) {
         if (process.env.NEXT_RUNTIME === 'edge') {
@@ -107,6 +117,7 @@ class RouteModule {
                     version: 4,
                     preview: getEdgePreviewProps()
                 },
+                previewProps: getEdgePreviewProps(),
                 routesManifest: {
                     version: 4,
                     caseSensitive: Boolean(process.env.__NEXT_CASE_SENSITIVE_ROUTES),
@@ -135,16 +146,12 @@ class RouteModule {
         } else {
             var _clientReferenceManifest___RSC_MANIFEST;
             if (!projectDir) {
-                throw Object.defineProperty(new Error('Invariant: projectDir is required for node runtime'), "__NEXT_ERROR_CODE", {
-                    value: "E718",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('Invariant: projectDir is required for node runtime');
             }
-            const { loadManifestFromRelativePath } = require('../load-manifest.external');
+            const { loadManifestFromRelativePath, evalManifestFromRelativePath } = require('../load-manifest.external');
             const normalizedPagePath = (0, _normalizepagepath.normalizePagePath)(srcPage);
             const router = this.definition.kind === _routekind.RouteKind.PAGES || this.definition.kind === _routekind.RouteKind.PAGES_API ? 'pages' : 'app';
-            const [routesManifest, prerenderManifest, buildManifest, fallbackBuildManifest, reactLoadableManifest, nextFontManifest, clientReferenceManifest, serverActionsManifest, subresourceIntegrityManifest, serverFilesManifest, buildId, dynamicCssManifest, prefetchHintsManifest] = [
+            const [routesManifest, prerenderManifest, previewProps, buildManifest, fallbackBuildManifest, reactLoadableManifest, nextFontManifest, clientReferenceManifest, serverActionsManifest, subresourceIntegrityManifest, serverFilesManifest, buildId, dynamicCssManifest, prefetchHintsManifest] = [
                 loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
@@ -157,6 +164,12 @@ class RouteModule {
                     manifest: _constants.PRERENDER_MANIFEST,
                     shouldCache: !this.isDev
                 }),
+                loadManifestFromRelativePath({
+                    projectDir,
+                    distDir: this.distDir,
+                    manifest: `server/${_constants.PREVIEW_PROPS_MANIFEST}`,
+                    shouldCache: !this.isDev
+                }),
                 loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
@@ -169,24 +182,23 @@ class RouteModule {
                     manifest: `fallback-${_constants.BUILD_MANIFEST}`,
                     shouldCache: !this.isDev,
                     handleMissing: true
-                }) : {},
+                }) ?? {} : {},
                 loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
                     manifest: process.env.TURBOPACK ? `server/${router === 'app' ? 'app' : 'pages'}${normalizedPagePath}/${_constants.REACT_LOADABLE_MANIFEST}` : _constants.REACT_LOADABLE_MANIFEST,
                     handleMissing: true,
                     shouldCache: !this.isDev
-                }),
+                }) ?? {},
                 loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
                     manifest: `server/${_constants.NEXT_FONT_MANIFEST}.json`,
                     shouldCache: !this.isDev
                 }),
-                router === 'app' && !(0, _ismetadataroute.isStaticMetadataRoute)(srcPage) ? loadManifestFromRelativePath({
+                router === 'app' && !(0, _ismetadataroute.isStaticMetadataRoute)(srcPage) ? evalManifestFromRelativePath({
                     distDir: this.distDir,
                     projectDir,
-                    useEval: true,
                     handleMissing: true,
                     manifest: `server/app${srcPage.replace(/%5F/g, '_') + '_' + _constants.CLIENT_REFERENCE_MANIFEST}.js`,
                     shouldCache: !this.isDev
@@ -240,6 +252,7 @@ class RouteModule {
                 routesManifest,
                 nextFontManifest,
                 prerenderManifest,
+                previewProps,
                 serverFilesManifest,
                 reactLoadableManifest,
                 clientReferenceManifest: clientReferenceManifest == null ? void 0 : (_clientReferenceManifest___RSC_MANIFEST = clientReferenceManifest.__RSC_MANIFEST) == null ? void 0 : _clientReferenceManifest___RSC_MANIFEST[srcPage.replace(/%5F/g, '_')],
@@ -256,19 +269,19 @@ class RouteModule {
         if (process.env.NEXT_RUNTIME !== 'edge') {
             const { cacheMaxMemorySize, cacheHandlers } = nextConfig;
             if (!cacheHandlers) return;
-            // If we've already initialized the cache handlers interface, don't do it
-            // again.
-            if (!(0, _handlers.initializeCacheHandlers)(cacheMaxMemorySize)) return;
-            for (const [kind, handler] of Object.entries(cacheHandlers)){
-                if (!handler) continue;
-                const { formatDynamicImportPath } = require('../../lib/format-dynamic-import-path');
-                const { join } = require('node:path');
-                const absoluteProjectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
-                (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault(formatDynamicImportPath(`${absoluteProjectDir}/${this.distDir}`, handler))));
-            }
+            (0, _handlers.initializeCacheHandlers)(cacheMaxMemorySize);
+            await (0, _handlers.registerCustomCacheHandlers)(async ()=>{
+                for (const [kind, handler] of Object.entries(cacheHandlers)){
+                    if (!handler) continue;
+                    const { formatDynamicImportPath } = require('../../lib/format-dynamic-import-path');
+                    const { join } = require('node:path');
+                    const absoluteProjectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
+                    (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault(formatDynamicImportPath(`${absoluteProjectDir}/${this.distDir}`, handler))));
+                }
+            });
         }
     }
-    async getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode) {
+    async getIncrementalCache(req, nextConfig, previewProps, prerenderManifest, isMinimalMode) {
         if (process.env.NEXT_RUNTIME === 'edge') {
             return globalThis.__incrementalCache;
         } else {
@@ -295,7 +308,8 @@ class RouteModule {
                 fetchCacheKeyPrefix: nextConfig.experimental.fetchCacheKeyPrefix,
                 maxMemoryCacheSize: nextConfig.cacheMaxMemorySize,
                 flushToDisk: !isMinimalMode && nextConfig.experimental.isrFlushToDisk,
-                getPrerenderManifest: ()=>prerenderManifest,
+                previewProps,
+                prerenderManifest,
                 CurCacheHandler: CacheHandler,
                 locales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.locales
             });
@@ -320,30 +334,18 @@ class RouteModule {
     /** A more lightweight version of `prepare()` for only retrieving the config on edge */ getNextConfigEdge(req) {
         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",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Invariant: getNextConfigEdge must only be called in edge runtime');
         }
         let serverFilesManifest = self.__SERVER_FILES_MANIFEST;
         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", {
-                value: "E969",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error("Invariant: nextConfig couldn't be loaded");
         }
         let deploymentId;
         if ((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.runtimeServerDeploymentId) {
             if (!process.env.NEXT_DEPLOYMENT_ID) {
-                throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
-                    value: "E970",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled');
             }
             deploymentId = process.env.NEXT_DEPLOYMENT_ID;
         } else {
@@ -354,7 +356,12 @@ class RouteModule {
             deploymentId
         };
     }
-    async prepare(req, res, { srcPage, multiZoneDraftMode }) {
+    prepare(req, res, options) {
+        return (0, _tracer.getTracer)().trace(_constants1.RouteModuleSpan.prepare, {
+            spanName: 'prepare route module'
+        }, ()=>this.prepareImpl(req, res, options));
+    }
+    async prepareImpl(req, res, { srcPage, multiZoneDraftMode }) {
         var _req_headers_xforwardedproto, _nextConfig_experimental;
         let absoluteProjectDir;
         // edge runtime handles loading instrumentation at the edge adapter level
@@ -376,8 +383,10 @@ class RouteModule {
             // before the userland route handler runs.
             await ensureInstrumentationRegistered(absoluteProjectDir, this.distDir);
         }
-        const manifests = this.loadManifests(srcPage, absoluteProjectDir);
-        const { routesManifest, prerenderManifest, serverFilesManifest } = manifests;
+        const manifests = (0, _tracer.getTracer)().trace(_constants1.RouteModuleSpan.loadManifests, {
+            spanName: 'load route manifests'
+        }, ()=>this.loadManifests(srcPage, absoluteProjectDir));
+        const { routesManifest, previewProps, 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);
@@ -575,21 +584,17 @@ class RouteModule {
                 query[key] = originalQuery[key];
             }
         }
-        const { isOnDemandRevalidate, revalidateOnlyGenerated } = (0, _apiutils.checkIsOnDemandRevalidate)(req.headers, prerenderManifest.preview);
+        const { isOnDemandRevalidate, revalidateOnlyGenerated } = (0, _apiutils.checkIsOnDemandRevalidate)(req.headers, previewProps);
         let isDraftMode = false;
         let previewData;
         // preview data relies on non-edge utils
         if (process.env.NEXT_RUNTIME !== 'edge' && res) {
             const { tryGetPreviewData } = require('../api-utils/node/try-get-preview-data');
-            previewData = tryGetPreviewData(req, res, prerenderManifest.preview, Boolean(multiZoneDraftMode));
+            previewData = tryGetPreviewData(req, res, previewProps, Boolean(multiZoneDraftMode));
             isDraftMode = previewData !== false;
         }
         if (!nextConfig) {
-            throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
-                value: "E969",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error("Invariant: nextConfig couldn't be loaded");
         }
         if (process.env.NEXT_RUNTIME !== 'edge') {
             const { installProcessErrorHandlers } = require('../node-environment-extensions/process-error-handlers');
@@ -612,15 +617,10 @@ 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) {
-                throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
-                    value: "E970",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled');
             }
             deploymentId = process.env.NEXT_DEPLOYMENT_ID;
         } else {
@@ -662,7 +662,7 @@ class RouteModule {
         }
         return this.responseCache;
     }
-    async handleResponse({ req, nextConfig, cacheKey, routeKind, isFallback, prerenderManifest, isRoutePPREnabled, isOnDemandRevalidate, revalidateOnlyGenerated, responseGenerator, waitUntil, isMinimalMode }) {
+    async handleResponse({ req, nextConfig, cacheKey, routeKind, isFallback, previewProps, prerenderManifest, isRoutePPREnabled, isOnDemandRevalidate, revalidateOnlyGenerated, responseGenerator, waitUntil, isMinimalMode }) {
         const responseCache = this.getResponseCache(req);
         const cacheEntry = await responseCache.get(cacheKey, responseGenerator, {
             routeKind,
@@ -679,7 +679,7 @@ class RouteModule {
             // Use x-invocation-id header to scope the in-memory cache to a single
             // revalidation request in minimal mode.
             invocationID: req.headers['x-invocation-id'],
-            incrementalCache: await this.getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode),
+            incrementalCache: await this.getIncrementalCache(req, nextConfig, previewProps, prerenderManifest, isMinimalMode),
             waitUntil
         });
         if (!cacheEntry) {
@@ -690,11 +690,7 @@ class RouteModule {
                 // have a cache key. If we do have a cache key but we don't end up
                 // with a cache entry, then either Next.js or the application has a
                 // bug that needs fixing.
-                throw Object.defineProperty(new Error('invariant: cache entry required but not generated'), "__NEXT_ERROR_CODE", {
-                    value: "E62",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('invariant: cache entry required but not generated');
             }
         }
         return cacheEntry;

package/.next/standalone/node_modules/next/dist/server/serve-static.js

@@ -50,11 +50,7 @@ function serveStatic(req, res, path, opts) {
     return new Promise((resolve, reject)=>{
         (0, _send.default)(req, path, opts).on('directory', ()=>{
             // We don't allow directories to be read.
-            const err = Object.defineProperty(new Error('No directory access'), "__NEXT_ERROR_CODE", {
-                value: "E340",
-                enumerable: false,
-                configurable: true
-            });
+            const err = new Error('No directory access');
             err.code = 'ENOENT';
             reject(err);
         }).on('error', reject).pipe(res).on('finish', resolve);

package/.next/standalone/node_modules/next/dist/server/setup-http-agent-env.js

@@ -17,11 +17,7 @@ function setHttpClientAndAgentOptions(config) {
         return;
     }
     if (!config) {
-        throw Object.defineProperty(new Error('Expected config.httpAgentOptions to be an object'), "__NEXT_ERROR_CODE", {
-            value: "E204",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Expected config.httpAgentOptions to be an object');
     }
     globalThis.__NEXT_HTTP_AGENT_OPTIONS = config.httpAgentOptions;
     globalThis.__NEXT_HTTP_AGENT = new _http.Agent(config.httpAgentOptions);

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

@@ -86,7 +86,7 @@ const ENCODED_TAGS = {
         ])
     },
     META: {
-        // Only the match the prefix cause the suffix can be different wether it's xml compatible or not ">" or "/>"
+        // Only the match the prefix cause the suffix can be different whether it's xml compatible or not ">" or "/>"
         // <meta name="«nxt-icon»"
         // This is a special mark that will be replaced by the icon insertion script tag.
         ICON_MARK: new Uint8Array([

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

@@ -118,7 +118,7 @@ _export(exports, {
 });
 const _tracer = require("../lib/trace/tracer");
 const _constants = require("../lib/trace/constants");
-const _detachedpromise = require("../../lib/detached-promise");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 const _scheduler = require("../../lib/scheduler");
 const _encodedtags = require("./encoded-tags");
 const _uint8arrayhelpers = require("./uint8array-helpers");
@@ -213,11 +213,7 @@ async function webstreamToUint8Array(stream) {
 }
 function webToReadable(stream) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new Error('webToReadable cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E1148",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('webToReadable cannot be used in the edge runtime');
     } else {
         let Readable;
         if (process.env.TURBOPACK) {
@@ -310,7 +306,7 @@ function createBufferedTransformStream(options = {}) {
         if (pending) {
             return;
         }
-        const detached = new _detachedpromise.DetachedPromise();
+        const detached = (0, _promisewithresolvers.createPromiseWithResolvers)();
         pending = detached;
         (0, _scheduler.scheduleImmediate)(()=>{
             try {
@@ -530,7 +526,7 @@ function createDeferredSuffixStream(suffix) {
     let flushed = false;
     let pending;
     const flush = (controller)=>{
-        const detached = new _detachedpromise.DetachedPromise();
+        const detached = (0, _promisewithresolvers.createPromiseWithResolvers)();
         pending = detached;
         (0, _scheduler.scheduleImmediate)(()=>{
             try {
@@ -751,11 +747,11 @@ function chainTransformers(readable, transformers) {
     }
     return stream;
 }
-async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
+async function continueFizzStream(renderStream, { suffix, inlinedDataStream, waitForAllReady, 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) {
-        // If we're generating static HTML we need to wait for it to resolve before continuing.
+    if (waitForAllReady) {
+        // Wait for all Suspense boundaries to resolve before continuing.
         await renderStream.allReady;
     } else {
         // Otherwise, we want to make sure Fizz is done with all microtasky work

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

@@ -56,6 +56,8 @@ const NEXT_TS_ERRORS = {
 const ALLOWED_EXPORTS = [
     'config',
     'generateStaticParams',
+    'unstable_paramMatching',
+    'unstable_generateParamMatching',
     'metadata',
     'generateMetadata',
     'viewport',

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

@@ -122,15 +122,35 @@ const API_DOCS = {
     prefetch: {
         description: `Controls prefetching behavior for this segment. Some options are experimental and may change.`,
         link: '(docs coming soon)',
-        type: `"auto" | "partial" | "unstable_eager" | "force-disabled"`,
+        type: `"auto" | "partial" | "force-disabled"`,
         options: {
             auto: 'Default. Framework decides based on instant validation and segment configuration. You do not need to set this explicitly.',
             partial: 'Enables Partial Prefetching for this segment. When a static prefetch is insufficient, Next.js may prefetch the segment with a runtime server request so it can access session data, such as cookies.',
-            unstable_eager: 'Like "partial", but adds an implied prop of prefetch={true} to ' + 'every Link. This option only exists to aid migration of apps that ' + 'adopted Partial Prefetching in canary before the behavior changed to ' + 'only fetch the shell by default.',
             'force-disabled': 'Never prefetch this segment.'
         },
         insertText: `prefetch = 'partial';`
     },
+    ensureStatic: {
+        description: `Controls which rendering phases require static output for this segment. This option is experimental and may change.`,
+        link: '(docs coming soon)',
+        type: `"auto" | "shell" | "prefetch" | "navigation" | false`,
+        options: {
+            '"auto"': 'Default. The shell, prefetch, or entire page will automatically be prerendered statically if possible.',
+            '"shell"': 'Force the shell for the route to be prerendered statically.',
+            '"prefetch"': 'Force both the shell and the prefetch (`<Link prefetch={true}>`) for the route to be prerendered statically.',
+            '"navigation"': 'Require the route to be fully static.',
+            false: 'Indicate that this segment must use the default behavior and should not have `ensureStatic = "shell" | "prefetch" | "navigation"` applied to it by another segment. Errors if another segment on the route uses `ensureStatic` with those values.'
+        },
+        insertText: `ensureStatic = 'shell';`,
+        isValid: (value)=>{
+            try {
+                const parsed = JSON.parse(value);
+                return VALID_ENSURE_STATIC_VALUES.includes(parsed);
+            } catch  {
+                return false;
+            }
+        }
+    },
     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 \`instant\`.`,
         link: '(docs coming soon)',
@@ -143,6 +163,13 @@ const API_DOCS = {
         }
     }
 };
+const VALID_ENSURE_STATIC_VALUES = [
+    'auto',
+    'shell',
+    'prefetch',
+    'navigation',
+    false
+];
 function visitEntryConfig(fileName, position, callback) {
     const source = (0, _utils.getSource)(fileName);
     if (source) {

package/.next/standalone/node_modules/next/dist/server/use-cache/cache-life-profile.js

@@ -15,31 +15,15 @@ function normalizeCacheLifeValue(key, value, context) {
     }
     if (value === false) {
         if (key === 'stale') {
-            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you want to cache on the client forever ' + 'without checking with the server.'), "__NEXT_ERROR_CODE", {
-                value: "E407",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Pass `Infinity` instead of `false` if you want to cache on the client forever ' + 'without checking with the server.');
         } else if (key === 'revalidate') {
-            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you do not want to revalidate by time.'), "__NEXT_ERROR_CODE", {
-                value: "E104",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Pass `Infinity` instead of `false` if you do not want to revalidate by time.');
         } else {
-            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you want to cache on the server forever ' + 'without checking with the origin.'), "__NEXT_ERROR_CODE", {
-                value: "E658",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Pass `Infinity` instead of `false` if you want to cache on the server forever ' + 'without checking with the origin.');
         }
     }
     if (typeof value !== 'number') {
-        throw Object.defineProperty(new Error(`The ${key} option must be a number of seconds.`), "__NEXT_ERROR_CODE", {
-            value: "E1414",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`The ${key} option must be a number of seconds.`);
     }
     if (value === Infinity) {
         // Infinity means "never", but turns into null when serialized as JSON
@@ -47,11 +31,7 @@ function normalizeCacheLifeValue(key, value, context) {
         return _constants.INFINITE_CACHE;
     }
     if (!Number.isFinite(value)) {
-        throw Object.defineProperty(new Error(context.kind === 'config' ? `Invalid "cacheLife.${context.profileName}.${key}" provided, expected a finite number of seconds or Infinity, received ${value}` : `Invalid \`cacheLife()\` option "${key}" provided, expected a finite number of seconds or Infinity, received ${value}.`), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(context.kind === 'config' ? `Invalid "cacheLife.${context.profileName}.${key}" provided, expected a finite number of seconds or Infinity, received ${value}` : `Invalid \`cacheLife()\` option "${key}" provided, expected a finite number of seconds or Infinity, received ${value}.`);
     }
     return value;
 }
@@ -72,11 +52,7 @@ function validateAndNormalizeCacheLifeProfile(profile, context) {
         }
     }
     if (normalizedProfile.revalidate !== undefined && normalizedProfile.expire !== undefined && normalizedProfile.revalidate > normalizedProfile.expire) {
-        throw Object.defineProperty(new Error('If providing both the revalidate and expire options, ' + 'the expire option must be greater than the revalidate option. ' + 'The expire option indicates how many seconds from the start ' + 'until it can no longer be used.'), "__NEXT_ERROR_CODE", {
-            value: "E656",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('If providing both the revalidate and expire options, ' + 'the expire option must be greater than the revalidate option. ' + 'The expire option indicates how many seconds from the start ' + 'until it can no longer be used.');
     }
     return normalizedProfile;
 }