@sifxprime/krouter 0.5.166 → 0.5.167

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

package/app/node_modules/next/dist/server/use-cache/constants.js

@@ -33,11 +33,7 @@ const MIN_SHELL_STALE = 300 // 5 minutes
 ;
 if (process.env.NODE_ENV !== 'production') {
     if (MIN_PREFETCHABLE_STALE > MIN_SHELL_STALE) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('MIN_PREFETCHABLE_STALE must not exceed MIN_SHELL_STALE.'), "__NEXT_ERROR_CODE", {
-            value: "E1422",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('MIN_PREFETCHABLE_STALE must not exceed MIN_SHELL_STALE.');
     }
 }
 

package/app/node_modules/next/dist/server/use-cache/handlers.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", {
     isBuiltInCacheHandler: null,
     isCustomCacheHandler: null,
     isMemoryCacheDisabled: null,
+    registerCustomCacheHandlers: null,
     setCacheHandler: null
 });
 function _export(target, all) {
@@ -48,6 +49,9 @@ _export(exports, {
     isMemoryCacheDisabled: function() {
         return isMemoryCacheDisabled;
     },
+    registerCustomCacheHandlers: function() {
+        return registerCustomCacheHandlers;
+    },
     setCacheHandler: function() {
         return setCacheHandler;
     }
@@ -60,6 +64,7 @@ const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? (message, ...args)=>{
 const handlersSymbol = Symbol.for('@next/cache-handlers');
 const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
 const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+const customCacheHandlersRegistrationSymbol = Symbol.for('@next/custom-cache-handlers-registration');
 const privateHandlerSymbol = Symbol.for('@next/cache-handlers-private');
 const builtInHandlersSymbol = Symbol.for('@next/cache-handlers-built-in');
 const devFrontHandlersSymbol = Symbol.for('@next/cache-handlers-dev-fronts');
@@ -80,7 +85,7 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
     // If the cache handlers have already been initialized, don't do it again.
     if (reference[handlersMapSymbol]) {
         debug == null ? void 0 : debug('cache handlers already initialized');
-        return false;
+        return;
     }
     debug == null ? void 0 : debug('initializing cache handlers');
     const handlersMap = new Map();
@@ -141,27 +146,26 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         reference[devFrontHandlersSymbol] = new Map();
         reference[devTieredHandlersSymbol] = new Map();
     }
-    return true;
+}
+function registerCustomCacheHandlers(register) {
+    let pendingPromise = reference[customCacheHandlersRegistrationSymbol];
+    if (!pendingPromise) {
+        pendingPromise = register();
+        reference[customCacheHandlersRegistrationSymbol] = pendingPromise;
+    }
+    return pendingPromise;
 }
 function getCacheHandler(kind) {
     // This should never be called before initializeCacheHandlers.
     if (!reference[handlersMapSymbol]) {
-        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
-            value: "E649",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Cache handlers not initialized');
     }
     return reference[handlersMapSymbol].get(kind);
 }
 function getPrivateCacheHandler() {
     // This should never be called before initializeCacheHandlers.
     if (!reference[handlersMapSymbol]) {
-        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
-            value: "E649",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Cache handlers not initialized');
     }
     return reference[privateHandlerSymbol];
 }
@@ -192,27 +196,18 @@ function getCacheHandlers() {
     if (!handlersSet) {
         return undefined;
     }
+    const handlers = Array.from(handlersSet);
     if (process.env.__NEXT_DEV_SERVER) {
-        return iterateCacheHandlersWithDevBuiltIns(handlersSet);
-    }
-    return handlersSet.values();
-}
-/**
- * Yields the registered handlers plus the dev-only built-in handlers (the
- * private handler and the per-kind front handlers). The built-in handlers are
- * not part of the registered set, but tag operations must still reach them:
- * their `updateTags` writes the shared tags manifest that their `get` consults,
- * so `revalidateTag` can invalidate their entries.
- */ function* iterateCacheHandlersWithDevBuiltIns(handlersSet) {
-    yield* handlersSet;
-    const privateHandler = reference[privateHandlerSymbol];
-    if (privateHandler) {
-        yield privateHandler;
-    }
-    const devFrontHandlers = reference[devFrontHandlersSymbol];
-    if (devFrontHandlers) {
-        yield* devFrontHandlers.values();
+        const privateHandler = reference[privateHandlerSymbol];
+        if (privateHandler) {
+            handlers.push(privateHandler);
+        }
+        const devFrontHandlers = reference[devFrontHandlersSymbol];
+        if (devFrontHandlers) {
+            handlers.push(...devFrontHandlers.values());
+        }
     }
+    return handlers;
 }
 function getCacheHandlerEntries() {
     const handlersMap = reference[handlersMapSymbol];
@@ -245,11 +240,7 @@ function getCacheHandlerEntries() {
 function setCacheHandler(kind, cacheHandler) {
     // This should never be called before initializeCacheHandlers.
     if (!reference[handlersMapSymbol] || !reference[handlersSetSymbol]) {
-        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
-            value: "E649",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Cache handlers not initialized');
     }
     debug == null ? void 0 : debug('setting cache handler for "%s"', kind);
     reference[handlersMapSymbol].set(kind, cacheHandler);

package/app/node_modules/next/dist/server/use-cache/tiered-cache-handler.js

@@ -101,10 +101,12 @@ function createTieredCacheHandler(front, backing) {
         if (backingEntry.timestamp > frontEntry.timestamp) {
             await front.set(cacheKey, Promise.resolve(backingEntry));
         } else {
-            // The front is already up to date, so the backing entry goes unused.
-            // Release its stream without awaiting: a teed stream's `cancel()` only
-            // settles once the sibling branch (retained by the backing handler) is
-            // also cancelled, so awaiting it here would hang the reconcile.
+            // The front is already up to date, so the backing entry goes unused. This
+            // code releases its stream and does not await the result. The backing
+            // handler is user-configured, and it can return one branch of a teed
+            // stream. `cancel()` on such a branch settles only after the sibling
+            // branch is cancelled too, and the handler retains that sibling, so an
+            // await here would hang the reconcile.
             void backingEntry.value.cancel();
         }
     } catch  {