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

package/dist/web/standalone/node_modules/next/dist/server/lib/incremental-cache/index.js

@@ -278,13 +278,32 @@ class IncrementalCache {
             if (resumeDataCache) {
                 const memoryCacheData = resumeDataCache.fetch.get(cacheKey);
                 if ((memoryCacheData == null ? void 0 : memoryCacheData.kind) === _responsecache.CachedRouteKind.FETCH) {
-                    if (IncrementalCache.debug) {
-                        console.log('IncrementalCache: rdc:hit', cacheKey);
+                    // Check if any tags were recently revalidated before returning RDC entry.
+                    // When a server action calls updateTag(), the re-render should see fresh
+                    // data instead of stale RDC data.
+                    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+                    const combinedTags = [
+                        ...ctx.tags || [],
+                        ...ctx.softTags || []
+                    ];
+                    const hasRevalidatedTag = combinedTags.some((tag)=>{
+                        var _this_revalidatedTags, _workStore_pendingRevalidatedTags;
+                        return ((_this_revalidatedTags = this.revalidatedTags) == null ? void 0 : _this_revalidatedTags.includes(tag)) || (workStore == null ? void 0 : (_workStore_pendingRevalidatedTags = workStore.pendingRevalidatedTags) == null ? void 0 : _workStore_pendingRevalidatedTags.some((item)=>item.tag === tag));
+                    });
+                    if (hasRevalidatedTag) {
+                        if (IncrementalCache.debug) {
+                            console.log('IncrementalCache: rdc:revalidated-tag', cacheKey);
+                        }
+                    // Fall through to cacheHandler lookup
+                    } else {
+                        if (IncrementalCache.debug) {
+                            console.log('IncrementalCache: rdc:hit', cacheKey);
+                        }
+                        return {
+                            isStale: false,
+                            value: memoryCacheData
+                        };
                     }
-                    return {
-                        isStale: false,
-                        value: memoryCacheData
-                    };
                 } else if (IncrementalCache.debug) {
                     console.log('IncrementalCache: rdc:miss', cacheKey);
                 }
@@ -372,12 +391,13 @@ class IncrementalCache {
             });
         }
         let entry = null;
+        const { isFallback } = ctx;
         const cacheControl = this.cacheControls.get((0, _toroute.toRoute)(cacheKey));
         let isStale;
         let revalidateAfter;
         if ((cacheData == null ? void 0 : cacheData.lastModified) === -1) {
             isStale = -1;
-            revalidateAfter = -1 * _constants.CACHE_ONE_YEAR;
+            revalidateAfter = -1 * _constants.CACHE_ONE_YEAR_SECONDS * 1000;
         } else {
             var _cacheData_value3, _cacheData_value4;
             const now = performance.timeOrigin + performance.now();
@@ -406,7 +426,8 @@ class IncrementalCache {
                 isStale,
                 cacheControl,
                 revalidateAfter,
-                value: cacheData.value
+                value: cacheData.value,
+                isFallback
             };
         }
         if (!cacheData && this.prerenderManifest.notFoundRoutes.includes(cacheKey)) {
@@ -419,7 +440,8 @@ class IncrementalCache {
                 isStale,
                 value: null,
                 cacheControl,
-                revalidateAfter
+                revalidateAfter,
+                isFallback
             };
             this.set(cacheKey, entry.value, {
                 ...ctx,
@@ -456,7 +478,7 @@ class IncrementalCache {
             const warningText = `Failed to set Next.js data cache for ${ctx.fetchUrl || pathname}, items over 2MB can not be cached (${itemSize} bytes)`;
             if (this.dev) {
                 throw Object.defineProperty(new Error(warningText), "__NEXT_ERROR_CODE", {
-                    value: "E394",
+                    value: "E1003",
                     enumerable: false,
                     configurable: true
                 });

package/dist/web/standalone/node_modules/next/dist/server/lib/incremental-cache/memory-cache.external.js

@@ -11,6 +11,19 @@ Object.defineProperty(exports, "getMemoryCache", {
 const _types = require("../../response-cache/types");
 const _lrucache = require("../lru-cache");
 let memoryCache;
+function getBufferSize(buffer) {
+    return (buffer == null ? void 0 : buffer.length) || 0;
+}
+function getSegmentDataSize(segmentData) {
+    if (!segmentData) {
+        return 0;
+    }
+    let size = 0;
+    for (const [segmentPath, buffer] of segmentData){
+        size += segmentPath.length + getBufferSize(buffer);
+    }
+    return size;
+}
 function getMemoryCache(maxMemoryCacheSize) {
     if (!memoryCache) {
         memoryCache = new _lrucache.LRUCache(maxMemoryCacheSize, function length({ value }) {
@@ -31,7 +44,11 @@ function getMemoryCache(maxMemoryCacheSize) {
                 return value.body.length;
             }
             // rough estimate of size of cache value
-            return value.html.length + (((_JSON_stringify = JSON.stringify(value.kind === _types.CachedRouteKind.APP_PAGE ? value.rscData : value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0);
+            if (value.kind === _types.CachedRouteKind.APP_PAGE) {
+                var _value_postponed;
+                return Math.max(1, value.html.length + getBufferSize(value.rscData) + (((_value_postponed = value.postponed) == null ? void 0 : _value_postponed.length) || 0) + getSegmentDataSize(value.segmentData));
+            }
+            return value.html.length + (((_JSON_stringify = JSON.stringify(value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0);
         });
     }
     return memoryCache;

package/dist/web/standalone/node_modules/next/dist/server/lib/install-code-frame.js

@@ -0,0 +1,22 @@
+/**
+ * Installs code frame rendering support by injecting the renderer into patch-error-inspect.
+ * This uses dependency injection to avoid hard dependencies on native bindings in runtime code.
+ *
+ * Should be called early in dev/build initialization, after native bindings are loaded.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installCodeFrameSupport", {
+    enumerable: true,
+    get: function() {
+        return installCodeFrameSupport;
+    }
+});
+function installCodeFrameSupport() {
+    const { setCodeFrameRenderer } = require('../patch-error-inspect');
+    const { getOriginalCodeFrame } = require('../../next-devtools/server/shared');
+    setCodeFrameRenderer(getOriginalCodeFrame);
+}
+
+//# sourceMappingURL=install-code-frame.js.map

package/dist/web/standalone/node_modules/next/dist/server/lib/lru-cache.js

@@ -90,9 +90,16 @@ class LRUCache {
    * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
    */ set(key, value) {
         const size = (this.calculateSize == null ? void 0 : this.calculateSize.call(this, value)) ?? 1;
+        if (size <= 0) {
+            throw Object.defineProperty(new Error(`LRUCache: calculateSize returned ${size}, but size must be > 0. ` + `Items with size 0 would never be evicted, causing unbounded cache growth.`), "__NEXT_ERROR_CODE", {
+                value: "E1045",
+                enumerable: false,
+                configurable: true
+            });
+        }
         if (size > this.maxSize) {
             console.warn('Single item size exceeds maxSize');
-            return;
+            return false;
         }
         const existing = this.cache.get(key);
         if (existing) {
@@ -115,6 +122,7 @@ class LRUCache {
             this.totalSize -= tail.size;
             this.onEvict == null ? void 0 : this.onEvict.call(this, tail.key, tail.data);
         }
+        return true;
     }
     /**
    * Checks if a key exists in the cache.

package/dist/web/standalone/node_modules/next/dist/server/lib/patch-fetch.js

@@ -140,7 +140,7 @@ async function createCachedPrerenderResponse(res, cacheKey, incrementalCacheCont
         statusText: res.statusText
     });
 }
-async function createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheContext, incrementalCache, serverComponentsHmrCache, revalidate, input, handleUnlock) {
+async function createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheContext, incrementalCache, serverComponentsHmrCache, revalidate, input, handleUnlock, signal) {
     // We're cloning the response using this utility because there exists a bug in
     // the undici library around response cloning. See the following pull request
     // for more details: https://github.com/vercel/next.js/pull/73274
@@ -164,7 +164,12 @@ async function createCachedDynamicResponse(workStore, res, cacheKey, incremental
                 revalidate
             }, incrementalCacheContext);
         }
-    }).catch((error)=>console.warn(`Failed to set fetch cache`, input, error)).finally(handleUnlock);
+    }).catch((error)=>{
+        // Don't warn if the request was aborted intentionally.
+        if (!(signal == null ? void 0 : signal.aborted)) {
+            console.warn(`Failed to set fetch cache`, input, error);
+        }
+    }).finally(handleUnlock);
     const pendingRevalidateKey = `cache-set-${cacheKey}`;
     const pendingRevalidates = workStore.pendingRevalidates ??= {};
     let pendingRevalidatePromise = Promise.resolve();
@@ -267,6 +272,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     case 'prerender-runtime':
                     // TODO: Stop accumulating tags in client prerender. (fallthrough)
                     case 'prerender-client':
+                    case 'validation-client':
                     case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'cache':
@@ -275,6 +281,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'request':
                     case 'unstable-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -302,12 +309,14 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'prerender':
                     case 'prerender-client':
+                    case 'validation-client':
                     case 'prerender-runtime':
                     case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'request':
                     case 'cache':
                     case 'private-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -398,6 +407,8 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             cacheSignal = null;
                         }
                         return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
+                    case 'validation-client':
+                        break;
                     case 'request':
                         if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering) {
                             if (cacheSignal) {
@@ -412,6 +423,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     case 'cache':
                     case 'private-cache':
                     case 'unstable-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -498,6 +510,12 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'prerender':
                             case 'prerender-client':
                             case 'prerender-runtime':
+                            // If we're in an instant validation, a dynamic fetch won't
+                            // have time to resolve during the validation prerender anyway,
+                            // so we leave it hanging. This can cause false negatives in shared parents,
+                            // but we accept that for now, because client data fetching is non-idiomatic.
+                            // eslint-disable-next-line no-fallthrough
+                            case 'validation-client':
                                 if (cacheSignal) {
                                     cacheSignal.endRead();
                                     cacheSignal = null;
@@ -517,6 +535,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                                 break;
                             default:
                                 workUnitStore;
@@ -546,10 +565,12 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'prerender':
                     case 'prerender-client':
+                    case 'validation-client':
                     case 'prerender-runtime':
                     case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'unstable-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -624,7 +645,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         });
                     }
                     if (res.status === 200 && incrementalCache && cacheKey && (isCacheableRevalidate || serverComponentsHmrCache)) {
-                        const normalizedRevalidate = finalRevalidate >= _constants1.INFINITE_CACHE ? _constants1.CACHE_ONE_YEAR : finalRevalidate;
+                        const normalizedRevalidate = finalRevalidate >= _constants1.INFINITE_CACHE ? _constants1.CACHE_ONE_YEAR_SECONDS : finalRevalidate;
                         const incrementalCacheConfig = isCacheableRevalidate ? {
                             fetchCache: true,
                             fetchUrl,
@@ -635,12 +656,17 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         switch(workUnitStore == null ? void 0 : workUnitStore.type){
                             case 'prerender':
                             case 'prerender-client':
+                            case 'validation-client':
                             case 'prerender-runtime':
                                 return createCachedPrerenderResponse(res, cacheKey, incrementalCacheConfig, incrementalCache, normalizedRevalidate, handleUnlock);
                             case 'request':
-                                if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering && workUnitStore.cacheSignal) {
-                                    // We're filling caches for a staged render,
-                                    // so we need to wait for the response to finish instead of streaming.
+                                if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering && workUnitStore.cacheSignal && isCacheableRevalidate) {
+                                    // We're filling caches for a staged render with an
+                                    // explicit cache config, so we need to wait for the
+                                    // response to finish instead of streaming. For HMR-only
+                                    // caching (no explicit revalidate), we fall through to
+                                    // createCachedDynamicResponse which handles streaming
+                                    // and abort gracefully.
                                     return createCachedPrerenderResponse(res, cacheKey, incrementalCacheConfig, incrementalCache, normalizedRevalidate, handleUnlock);
                                 }
                             // fallthrough
@@ -649,8 +675,9 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                             case undefined:
-                                return createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheConfig, incrementalCache, serverComponentsHmrCache, normalizedRevalidate, input, handleUnlock);
+                                return createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheConfig, incrementalCache, serverComponentsHmrCache, normalizedRevalidate, input, handleUnlock, getRequestMeta('signal'));
                             default:
                                 workUnitStore;
                         }
@@ -687,6 +714,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         switch(workUnitStore.type){
                             case 'prerender':
                             case 'prerender-client':
+                            case 'validation-client':
                             case 'prerender-runtime':
                                 // We sometimes use the cache to dedupe fetches that do not
                                 // specify a cache configuration. In these cases we want to
@@ -705,6 +733,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                                 break;
                             default:
                                 workUnitStore;
@@ -779,6 +808,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'prerender':
                             case 'prerender-client':
                             case 'prerender-runtime':
+                            case 'validation-client':
                                 if (cacheSignal) {
                                     cacheSignal.endRead();
                                     cacheSignal = null;
@@ -798,6 +828,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                                 break;
                             default:
                                 workUnitStore;
@@ -815,6 +846,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                 case 'prerender':
                                 case 'prerender-client':
                                 case 'prerender-runtime':
+                                case 'validation-client':
                                     return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
                                 case 'request':
                                     if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering) {
@@ -826,6 +858,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                 case 'unstable-cache':
                                 case 'prerender-legacy':
                                 case 'prerender-ppr':
+                                case 'generate-static-params':
                                     break;
                                 default:
                                     workUnitStore;

package/dist/web/standalone/node_modules/next/dist/server/lib/postponed-request-body.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getMaxPostponedStateSize: null,
+    getPostponedStateExceededErrorMessage: null,
+    readBodyWithSizeLimit: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getMaxPostponedStateSize: function() {
+        return getMaxPostponedStateSize;
+    },
+    getPostponedStateExceededErrorMessage: function() {
+        return getPostponedStateExceededErrorMessage;
+    },
+    readBodyWithSizeLimit: function() {
+        return readBodyWithSizeLimit;
+    }
+});
+const _sizelimit = require("../../shared/lib/size-limit");
+const INVALID_MAX_POSTPONED_STATE_SIZE_ERROR_MESSAGE = 'maxPostponedStateSize must be a valid number (bytes) or filesize format string (e.g., "5mb")';
+function getMaxPostponedStateSize(configuredMaxPostponedStateSize) {
+    const maxPostponedStateSize = configuredMaxPostponedStateSize ?? _sizelimit.DEFAULT_MAX_POSTPONED_STATE_SIZE;
+    const maxPostponedStateSizeBytes = (0, _sizelimit.parseMaxPostponedStateSize)(configuredMaxPostponedStateSize);
+    if (maxPostponedStateSizeBytes === undefined) {
+        throw Object.defineProperty(new Error(INVALID_MAX_POSTPONED_STATE_SIZE_ERROR_MESSAGE), "__NEXT_ERROR_CODE", {
+            value: "E977",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return {
+        maxPostponedStateSize,
+        maxPostponedStateSizeBytes
+    };
+}
+function getPostponedStateExceededErrorMessage(maxPostponedStateSize) {
+    return `Postponed state exceeded ${maxPostponedStateSize} limit. ` + `To configure the limit, see: https://nextjs.org/docs/app/api-reference/config/next-config-js/max-postponed-state-size`;
+}
+function toBuffer(chunk) {
+    return Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+}
+async function readBodyWithSizeLimit(body, maxBodySizeBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of body){
+        const buffer = toBuffer(chunk);
+        size += buffer.byteLength;
+        if (size > maxBodySizeBytes) {
+            return null;
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+
+//# sourceMappingURL=postponed-request-body.js.map

package/dist/web/standalone/node_modules/next/dist/server/lib/render-server.js

@@ -137,7 +137,10 @@ async function initializeImpl(opts) {
         closeUpgraded () {
             var _opts_bundlerService;
             (_opts_bundlerService = opts.bundlerService) == null ? void 0 : _opts_bundlerService.close();
-        }
+        },
+        distDir: opts.distDir,
+        experimentalFeatures: opts.experimentalFeatures,
+        cacheComponents: opts.cacheComponents
     };
 }
 async function initialize(opts) {

package/dist/web/standalone/node_modules/next/dist/server/lib/router-server.js

@@ -43,7 +43,7 @@ const _hotreloadertypes = require("../dev/hot-reloader-types");
 const _normalizedassetprefix = require("../../shared/lib/normalized-asset-prefix");
 const _patchfetch = require("./patch-fetch");
 const _utils1 = require("./server-ipc/utils");
-const _blockcrosssite = require("./router-utils/block-cross-site");
+const _blockcrosssitedev = require("./router-utils/block-cross-site-dev");
 const _shared = require("../../trace/shared");
 const _nofallbackerrorexternal = require("../../shared/lib/no-fallback-error.external");
 const _routerservercontext = require("./router-utils/router-server-context");
@@ -104,8 +104,12 @@ async function initialize(opts) {
         // @ts-ignore not readonly
         process.env.NODE_ENV = opts.dev ? 'development' : 'production';
     }
+    let experimentalFeatures = [];
     const config = await (0, _config.default)(opts.dev ? _constants.PHASE_DEVELOPMENT_SERVER : _constants.PHASE_PRODUCTION_SERVER, opts.dir, {
-        silent: false
+        silent: false,
+        reportExperimentalFeatures (features) {
+            experimentalFeatures = features.toSorted(({ key: a }, { key: b })=>a.localeCompare(b));
+        }
     });
     let compress;
     if ((config == null ? void 0 : config.compress) !== false) {
@@ -121,6 +125,7 @@ async function initialize(opts) {
     let development = undefined;
     let originalFetch = globalThis.fetch;
     if (opts.dev) {
+        var _developmentConfig_experimental;
         const { Telemetry } = require('../../telemetry/storage');
         const telemetry = new Telemetry({
             distDir: _path.default.join(opts.dir, config.distDir)
@@ -135,6 +140,18 @@ async function initialize(opts) {
         const setupDevBundlerSpan = opts.startServerSpan ? opts.startServerSpan.traceChild('setup-dev-bundler') : (0, _trace.trace)('setup-dev-bundler');
         // In development, it's always the complete config.
         let developmentConfig = config;
+        // Resolve the effective serverFastRefresh value.
+        // Both default to enabled (true). CLI takes precedence over config.
+        const cliServerFastRefresh = opts.serverFastRefresh;
+        const configServerFastRefresh = (_developmentConfig_experimental = developmentConfig.experimental) == null ? void 0 : _developmentConfig_experimental.turbopackServerFastRefresh;
+        let effectiveServerFastRefresh;
+        if (cliServerFastRefresh !== undefined && configServerFastRefresh !== undefined && cliServerFastRefresh !== configServerFastRefresh) {
+            _log.warn(`The CLI flag "${cliServerFastRefresh === false ? '--no-server-fast-refresh' : '--server-fast-refresh'}" conflicts with "experimental.turbopackServerFastRefresh: ${configServerFastRefresh}" in your Next.js config. The CLI flag will take precedence.`);
+            effectiveServerFastRefresh = cliServerFastRefresh;
+        } else {
+            // Default to true when neither CLI nor config specifies a value.
+            effectiveServerFastRefresh = cliServerFastRefresh ?? configServerFastRefresh ?? true;
+        }
         let developmentBundler = await setupDevBundlerSpan.traceAsyncFn(()=>setupDevBundler({
                 // Passed here but the initialization of this object happens below, doing the initialization before the setupDev call breaks.
                 renderServer,
@@ -148,7 +165,8 @@ async function initialize(opts) {
                 turbo: !!process.env.TURBOPACK,
                 port: opts.port,
                 onDevServerCleanup: opts.onDevServerCleanup,
-                resetFetch
+                resetFetch,
+                serverFastRefresh: effectiveServerFastRefresh
             }));
         let devBundlerService = new _devbundlerservice.DevBundlerService(developmentBundler, // The request handler is assigned below, this allows us to create a lazy
         // reference to it.
@@ -275,7 +293,7 @@ async function initialize(opts) {
             }
             // handle hot-reloader first
             if (development) {
-                if ((0, _blockcrosssite.blockCrossSite)(req, res, development.config.allowedDevOrigins, opts.hostname)) {
+                if ((0, _blockcrosssitedev.blockCrossSiteDEV)(req, res, development.config.allowedDevOrigins, opts.hostname)) {
                     return;
                 }
                 const origUrl = req.url || '/';
@@ -286,7 +304,7 @@ async function initialize(opts) {
                 } else if (config.assetPrefix && (0, _pathhasprefix.pathHasPrefix)(origUrl, config.assetPrefix)) {
                     req.url = (0, _removepathprefix.removePathPrefix)(origUrl, config.assetPrefix);
                 }
-                const parsedUrl = _url.default.parse(req.url || '/');
+                const parsedUrl = (0, _parseurl.parseUrl)(req.url || '/');
                 const hotReloaderResult = await development.bundler.hotReloader.run(req, res, parsedUrl);
                 if (hotReloaderResult.finished) {
                     return hotReloaderResult;
@@ -365,7 +383,7 @@ async function initialize(opts) {
                     await invokeRender(parsedUrl, '/_error', handleIndex, {
                         invokeStatus: 500,
                         invokeError: Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                            value: "E394",
+                            value: "E212",
                             enumerable: false,
                             configurable: true
                         })
@@ -375,7 +393,7 @@ async function initialize(opts) {
                 }
                 if (!res.getHeader('cache-control') && matchedOutput.type === 'nextStaticFolder') {
                     if (opts.dev && !isNextFont(parsedUrl.pathname)) {
-                        res.setHeader('Cache-Control', 'no-store, must-revalidate');
+                        res.setHeader('Cache-Control', 'no-cache, must-revalidate');
                     } else {
                         res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
                     }
@@ -386,7 +404,7 @@ async function initialize(opts) {
                         'HEAD'
                     ]);
                     res.statusCode = 405;
-                    return await invokeRender(_url.default.parse('/405', true), '/405', handleIndex, {
+                    return await invokeRender((0, _parseurl.parseUrl)('/405'), '/405', handleIndex, {
                         invokeStatus: 405
                     });
                 }
@@ -435,7 +453,7 @@ async function initialize(opts) {
                         const invokePath = `/${err.statusCode}`;
                         const invokeStatus = err.statusCode;
                         res.statusCode = err.statusCode;
-                        return await invokeRender(_url.default.parse(invokePath, true), invokePath, handleIndex, {
+                        return await invokeRender((0, _parseurl.parseUrl)(invokePath), invokePath, handleIndex, {
                             invokeStatus
                         });
                     }
@@ -505,7 +523,7 @@ async function initialize(opts) {
                     console.error(err);
                 }
                 res.statusCode = Number(invokeStatus);
-                return await invokeRender(_url.default.parse(invokePath, true), invokePath, 0, {
+                return await invokeRender((0, _parseurl.parseUrl)(invokePath), invokePath, 0, {
                     invokeStatus: res.statusCode
                 });
             } catch (err2) {
@@ -542,7 +560,10 @@ async function initialize(opts) {
         bundlerService: development == null ? void 0 : development.service,
         startServerSpan: opts.startServerSpan,
         quiet: opts.quiet,
-        onDevServerCleanup: opts.onDevServerCleanup
+        onDevServerCleanup: opts.onDevServerCleanup,
+        distDir: config.distDir,
+        experimentalFeatures,
+        cacheComponents: config.cacheComponents
     };
     renderServerOpts.serverFields.routerServerHandler = requestHandlerImpl;
     // pre-initialize workers
@@ -591,7 +612,7 @@ async function initialize(opts) {
             // console.error(_err);
             });
             if (opts.dev && development && req.url) {
-                if ((0, _blockcrosssite.blockCrossSite)(req, socket, development.config.allowedDevOrigins, opts.hostname)) {
+                if ((0, _blockcrosssitedev.blockCrossSiteDEV)(req, socket, development.config.allowedDevOrigins, opts.hostname)) {
                     return;
                 }
                 const { basePath, assetPrefix } = config;
@@ -665,7 +686,10 @@ async function initialize(opts) {
         closeUpgraded () {
             var _development_bundler_hotReloader, _development_bundler;
             development == null ? void 0 : (_development_bundler = development.bundler) == null ? void 0 : (_development_bundler_hotReloader = _development_bundler.hotReloader) == null ? void 0 : _development_bundler_hotReloader.close();
-        }
+        },
+        distDir: config.distDir,
+        experimentalFeatures,
+        cacheComponents: config.cacheComponents
     };
 }