next 15.6.0-canary.33 → 15.6.0-canary.34

package/dist/esm/build/index.js

@@ -303,7 +303,7 @@ export default async function build(dir, reactProductionProfiling = false, debug
     try {
         const nextBuildSpan = trace('next-build', undefined, {
             buildMode: experimentalBuildMode,
-            version: "15.6.0-canary.33"
+            version: "15.6.0-canary.34"
         });
         NextBuildContext.nextBuildSpan = nextBuildSpan;
         NextBuildContext.dir = dir;
@@ -785,7 +785,7 @@ export default async function build(dir, reactProductionProfiling = false, debug
             // Files outside of the distDir can be "type": "module"
             await writeFileUtf8(path.join(distDir, 'package.json'), '{"type": "commonjs"}');
             // These are written to distDir, so they need to come after creating and cleaning distDr.
-            await recordFrameworkVersion("15.6.0-canary.33");
+            await recordFrameworkVersion("15.6.0-canary.34");
             await updateBuildDiagnostics({
                 buildStage: 'start'
             });
@@ -2451,7 +2451,7 @@ export default async function build(dir, reactProductionProfiling = false, debug
                         distDir,
                         config,
                         staticPages,
-                        nextVersion: "15.6.0-canary.33",
+                        nextVersion: "15.6.0-canary.34",
                         tracingRoot: outputFileTracingRoot,
                         hasNodeMiddleware,
                         hasInstrumentationHook,

package/dist/esm/build/swc/index.js

@@ -10,7 +10,7 @@ import { downloadNativeNextSwc, downloadWasmSwc } from '../../lib/download-swc';
 import { isDeepStrictEqual } from 'util';
 import { getDefineEnv } from '../define-env';
 import { throwTurbopackInternalError } from '../../shared/lib/turbopack/internal-error';
-const nextVersion = "15.6.0-canary.33";
+const nextVersion = "15.6.0-canary.34";
 const ArchName = arch();
 const PlatformName = platform();
 function infoLog(...args) {

package/dist/esm/build/webpack-config.js

@@ -1603,7 +1603,7 @@ export default async function getBaseWebpackConfig(dir, { buildId, encryptionKey
             isClient && new CopyFilePlugin({
                 // file path to build output of `@next/polyfill-nomodule`
                 filePath: require.resolve('./polyfills/polyfill-nomodule'),
-                cacheKey: "15.6.0-canary.33",
+                cacheKey: "15.6.0-canary.34",
                 name: `static/chunks/polyfills${dev ? '' : '-[hash]'}.js`,
                 minimize: false,
                 info: {
@@ -1786,7 +1786,7 @@ export default async function getBaseWebpackConfig(dir, { buildId, encryptionKey
         //  - Next.js location on disk (some loaders use absolute paths and some resolve options depend on absolute paths)
         //  - Next.js version
         //  - next.config.js keys that affect compilation
-        version: `${__dirname}|${"15.6.0-canary.33"}|${configVars}`,
+        version: `${__dirname}|${"15.6.0-canary.34"}|${configVars}`,
         cacheDirectory: path.join(distDir, 'cache', 'webpack'),
         // For production builds, it's more efficient to compress all cache files together instead of compression each one individually.
         // So we disable compression here and allow the build runner to take care of compressing the cache as a whole.

package/dist/esm/client/app-bootstrap.js

@@ -5,7 +5,7 @@
  * - next/script with `beforeInteractive` strategy
  */ import { getAssetPrefix } from './asset-prefix';
 import { setAttributesFromProps } from './set-attributes-from-props';
-const version = "15.6.0-canary.33";
+const version = "15.6.0-canary.34";
 window.next = {
     version,
     appDir: true

package/dist/esm/client/index.js

@@ -26,7 +26,7 @@ import { SearchParamsContext, PathParamsContext } from '../shared/lib/hooks-clie
 import { onRecoverableError } from './react-client-callbacks/on-recoverable-error';
 import tracer from './tracing/tracer';
 import { isNextRouterError } from './components/is-next-router-error';
-export const version = "15.6.0-canary.33";
+export const version = "15.6.0-canary.34";
 export let router;
 export const emitter = mitt();
 const looseToArray = (input)=>[].slice.call(input);

package/dist/esm/server/dev/hot-reloader-turbopack.js

@@ -95,7 +95,7 @@ export async function createHotReloaderTurbopack(opts, serverFields, distDir, re
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = trace('hot-reloader', undefined, {
-        version: "15.6.0-canary.33"
+        version: "15.6.0-canary.34"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.

package/dist/esm/server/dev/hot-reloader-webpack.js

@@ -161,7 +161,7 @@ export default class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = trace('hot-reloader', undefined, {
-            version: "15.6.0-canary.33"
+            version: "15.6.0-canary.34"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.

package/dist/esm/server/lib/app-info-log.js

@@ -14,7 +14,7 @@ export function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures
             bundlerSuffix = ' (webpack)';
         }
     }
-    Log.bootstrap(`${bold(purple(`${Log.prefixes.ready} Next.js ${"15.6.0-canary.33"}`))}${bundlerSuffix}`);
+    Log.bootstrap(`${bold(purple(`${Log.prefixes.ready} Next.js ${"15.6.0-canary.34"}`))}${bundlerSuffix}`);
     if (appUrl) {
         Log.bootstrap(`- Local:        ${appUrl}`);
     }

package/dist/esm/server/lib/start-server.js

@@ -111,7 +111,7 @@ export async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup,
 export async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"15.6.0-canary.33"})`;
+    process.title = `next-server (v${"15.6.0-canary.34"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/dist/esm/shared/lib/canary-only.js

@@ -1,6 +1,6 @@
 export function isStableBuild() {
     var _process_env___NEXT_VERSION;
-    return !((_process_env___NEXT_VERSION = "15.6.0-canary.33") == null ? void 0 : _process_env___NEXT_VERSION.includes('canary')) && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
+    return !((_process_env___NEXT_VERSION = "15.6.0-canary.34") == null ? void 0 : _process_env___NEXT_VERSION.includes('canary')) && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
 }
 export class CanaryOnlyError extends Error {
     constructor(arg){

package/dist/esm/shared/lib/turbopack/manifest-loader.js

@@ -29,11 +29,53 @@ const getManifestPath = (page, distDir, name, type, firstCall)=>{
     }
     return manifestPath;
 };
-function readPartialManifest(distDir, name, pageName, type) {
+function readPartialManifestContent(distDir, name, pageName, type) {
     if (type === void 0) type = 'pages';
     const page = pageName;
     const manifestPath = getManifestPath(page, distDir, name, type, true);
-    return JSON.parse(readFileSync(posix.join(manifestPath), 'utf-8'));
+    return readFileSync(posix.join(manifestPath), 'utf-8');
+}
+/// Helper class that stores a map of manifests and tracks if they have changed
+/// since the last time they were written to disk. This is used to avoid
+/// unnecessary writes to disk.
+class ManifestsMap {
+    set(key, value) {
+        if (this.rawMap.get(key) === value) return;
+        this.changed = true;
+        this.rawMap.set(key, value);
+        this.map.set(key, JSON.parse(value));
+    }
+    delete(key) {
+        if (this.map.has(key)) {
+            this.changed = true;
+            this.rawMap.delete(key);
+            this.map.delete(key);
+        }
+    }
+    get(key) {
+        return this.map.get(key);
+    }
+    takeChanged(extraInvalidationKey) {
+        let changed = this.changed;
+        if (extraInvalidationKey !== undefined) {
+            const stringified = JSON.stringify(extraInvalidationKey);
+            if (this.extraInvalidationKey !== stringified) {
+                this.extraInvalidationKey = stringified;
+                changed = true;
+            }
+        }
+        this.changed = false;
+        return changed;
+    }
+    values() {
+        return this.map.values();
+    }
+    constructor(){
+        this.rawMap = new Map();
+        this.map = new Map();
+        this.extraInvalidationKey = undefined;
+        this.changed = true;
+    }
 }
 export class TurbopackManifestLoader {
     delete(key) {
@@ -47,7 +89,7 @@ export class TurbopackManifestLoader {
         this.webpackStats.delete(key);
     }
     loadActionManifest(pageName) {
-        this.actionManifests.set(getEntryKey('app', 'server', pageName), readPartialManifest(this.distDir, "" + SERVER_REFERENCE_MANIFEST + ".json", pageName, 'app'));
+        this.actionManifests.set(getEntryKey('app', 'server', pageName), readPartialManifestContent(this.distDir, "" + SERVER_REFERENCE_MANIFEST + ".json", pageName, 'app'));
     }
     mergeActionManifests(manifests) {
         const manifest = {
@@ -86,6 +128,9 @@ export class TurbopackManifestLoader {
         return manifest;
     }
     writeActionManifest() {
+        if (!this.actionManifests.takeChanged()) {
+            return;
+        }
         const actionManifest = this.mergeActionManifests(this.actionManifests.values());
         const actionManifestJsonPath = join(this.distDir, 'server', "" + SERVER_REFERENCE_MANIFEST + ".json");
         const actionManifestJsPath = join(this.distDir, 'server', "" + SERVER_REFERENCE_MANIFEST + ".js");
@@ -96,15 +141,21 @@ export class TurbopackManifestLoader {
         writeFileAtomic(actionManifestJsPath, "self.__RSC_SERVER_MANIFEST=" + JSON.stringify(json));
     }
     loadAppPathsManifest(pageName) {
-        this.appPathsManifests.set(getEntryKey('app', 'server', pageName), readPartialManifest(this.distDir, APP_PATHS_MANIFEST, pageName, 'app'));
+        this.appPathsManifests.set(getEntryKey('app', 'server', pageName), readPartialManifestContent(this.distDir, APP_PATHS_MANIFEST, pageName, 'app'));
     }
     writeAppPathsManifest() {
+        if (!this.appPathsManifests.takeChanged()) {
+            return;
+        }
         const appPathsManifest = this.mergePagesManifests(this.appPathsManifests.values());
         const appPathsManifestPath = join(this.distDir, 'server', APP_PATHS_MANIFEST);
         deleteCache(appPathsManifestPath);
         writeFileAtomic(appPathsManifestPath, JSON.stringify(appPathsManifest, null, 2));
     }
     writeWebpackStats() {
+        if (!this.webpackStats.takeChanged()) {
+            return;
+        }
         const webpackStats = this.mergeWebpackStats(this.webpackStats.values());
         const path = join(this.distDir, 'server', WEBPACK_STATS);
         deleteCache(path);
@@ -112,15 +163,15 @@ export class TurbopackManifestLoader {
     }
     loadBuildManifest(pageName, type) {
         if (type === void 0) type = 'pages';
-        this.buildManifests.set(getEntryKey(type, 'server', pageName), readPartialManifest(this.distDir, BUILD_MANIFEST, pageName, type));
+        this.buildManifests.set(getEntryKey(type, 'server', pageName), readPartialManifestContent(this.distDir, BUILD_MANIFEST, pageName, type));
     }
     loadClientBuildManifest(pageName, type) {
         if (type === void 0) type = 'pages';
-        this.clientBuildManifests.set(getEntryKey(type, 'server', pageName), readPartialManifest(this.distDir, TURBOPACK_CLIENT_BUILD_MANIFEST, pageName, type));
+        this.clientBuildManifests.set(getEntryKey(type, 'server', pageName), readPartialManifestContent(this.distDir, TURBOPACK_CLIENT_BUILD_MANIFEST, pageName, type));
     }
     loadWebpackStats(pageName, type) {
         if (type === void 0) type = 'pages';
-        this.webpackStats.set(getEntryKey(type, 'client', pageName), readPartialManifest(this.distDir, WEBPACK_STATS, pageName, type));
+        this.webpackStats.set(getEntryKey(type, 'client', pageName), readPartialManifestContent(this.distDir, WEBPACK_STATS, pageName, type));
     }
     mergeWebpackStats(statsFiles) {
         const entrypoints = {};
@@ -207,9 +258,9 @@ export class TurbopackManifestLoader {
         manifest.pages = sortObjectByKey(manifest.pages);
         return manifest;
     }
-    mergeClientBuildManifests(rewrites, manifests, sortedPageKeys) {
+    mergeClientBuildManifests(manifests, rewrites, sortedPageKeys) {
         const manifest = {
-            __rewrites: normalizeRewritesForBuildManifest(rewrites),
+            __rewrites: rewrites,
             sortedPages: sortedPageKeys
         };
         for (const m of manifests){
@@ -217,7 +268,7 @@ export class TurbopackManifestLoader {
         }
         return sortObjectByKey(manifest);
     }
-    writeBuildManifest(entrypoints, devRewrites, productionRewrites) {
+    writeInterceptionRouteRewriteManifest(devRewrites, productionRewrites) {
         var _devRewrites_beforeFiles, _devRewrites_afterFiles, _devRewrites_fallback;
         const rewrites = productionRewrites != null ? productionRewrites : {
             ...devRewrites,
@@ -225,19 +276,45 @@ export class TurbopackManifestLoader {
             afterFiles: ((_devRewrites_afterFiles = devRewrites == null ? void 0 : devRewrites.afterFiles) != null ? _devRewrites_afterFiles : []).map(processRoute),
             fallback: ((_devRewrites_fallback = devRewrites == null ? void 0 : devRewrites.fallback) != null ? _devRewrites_fallback : []).map(processRoute)
         };
+        const interceptionRewrites = JSON.stringify(rewrites.beforeFiles.filter(isInterceptionRouteRewrite));
+        if (this.cachedInterceptionRewrites === interceptionRewrites) {
+            return;
+        }
+        this.cachedInterceptionRewrites = interceptionRewrites;
+        const interceptionRewriteManifestPath = join(this.distDir, 'server', "" + INTERCEPTION_ROUTE_REWRITE_MANIFEST + ".js");
+        deleteCache(interceptionRewriteManifestPath);
+        writeFileAtomic(interceptionRewriteManifestPath, "self.__INTERCEPTION_ROUTE_REWRITE_MANIFEST=" + JSON.stringify(interceptionRewrites) + ";");
+    }
+    writeBuildManifest() {
+        if (!this.buildManifests.takeChanged()) {
+            return;
+        }
         const buildManifest = this.mergeBuildManifests(this.buildManifests.values());
         const buildManifestPath = join(this.distDir, BUILD_MANIFEST);
         const middlewareBuildManifestPath = join(this.distDir, 'server', "" + MIDDLEWARE_BUILD_MANIFEST + ".js");
-        const interceptionRewriteManifestPath = join(this.distDir, 'server', "" + INTERCEPTION_ROUTE_REWRITE_MANIFEST + ".js");
         deleteCache(buildManifestPath);
         deleteCache(middlewareBuildManifestPath);
-        deleteCache(interceptionRewriteManifestPath);
         writeFileAtomic(buildManifestPath, JSON.stringify(buildManifest, null, 2));
         writeFileAtomic(middlewareBuildManifestPath, // we use globalThis here because middleware can be node
         // which doesn't have "self"
         createEdgeRuntimeManifest(buildManifest));
-        const interceptionRewrites = JSON.stringify(rewrites.beforeFiles.filter(isInterceptionRouteRewrite));
-        writeFileAtomic(interceptionRewriteManifestPath, "self.__INTERCEPTION_ROUTE_REWRITE_MANIFEST=" + JSON.stringify(interceptionRewrites) + ";");
+        // Write fallback build manifest
+        const fallbackBuildManifest = this.mergeBuildManifests([
+            this.buildManifests.get(getEntryKey('pages', 'server', '_app')),
+            this.buildManifests.get(getEntryKey('pages', 'server', '_error'))
+        ].filter(Boolean));
+        const fallbackBuildManifestPath = join(this.distDir, "fallback-" + BUILD_MANIFEST);
+        deleteCache(fallbackBuildManifestPath);
+        writeFileAtomic(fallbackBuildManifestPath, JSON.stringify(fallbackBuildManifest, null, 2));
+    }
+    writeClientBuildManifest(entrypoints, devRewrites, productionRewrites) {
+        var _devRewrites_beforeFiles, _devRewrites_afterFiles, _devRewrites_fallback;
+        const rewrites = normalizeRewritesForBuildManifest(productionRewrites != null ? productionRewrites : {
+            ...devRewrites,
+            beforeFiles: ((_devRewrites_beforeFiles = devRewrites == null ? void 0 : devRewrites.beforeFiles) != null ? _devRewrites_beforeFiles : []).map(processRoute),
+            afterFiles: ((_devRewrites_afterFiles = devRewrites == null ? void 0 : devRewrites.afterFiles) != null ? _devRewrites_afterFiles : []).map(processRoute),
+            fallback: ((_devRewrites_fallback = devRewrites == null ? void 0 : devRewrites.fallback) != null ? _devRewrites_fallback : []).map(processRoute)
+        });
         const pagesKeys = [
             ...entrypoints.page.keys()
         ];
@@ -248,31 +325,20 @@ export class TurbopackManifestLoader {
             pagesKeys.push('/_error');
         }
         const sortedPageKeys = getSortedRoutes(pagesKeys);
-        const clientBuildManifest = this.mergeClientBuildManifests(rewrites, this.clientBuildManifests.values(), sortedPageKeys);
+        if (!this.clientBuildManifests.takeChanged({
+            rewrites,
+            sortedPageKeys
+        })) {
+            return;
+        }
+        const clientBuildManifest = this.mergeClientBuildManifests(this.clientBuildManifests.values(), rewrites, sortedPageKeys);
         const clientBuildManifestJs = "self.__BUILD_MANIFEST = " + JSON.stringify(clientBuildManifest, null, 2) + ";self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()";
         writeFileAtomic(join(this.distDir, 'static', this.buildId, '_buildManifest.js'), clientBuildManifestJs);
         writeFileAtomic(join(this.distDir, 'static', this.buildId, '_ssgManifest.js'), srcEmptySsgManifest);
     }
-    writeClientMiddlewareManifest() {
-        var _middlewareManifest_middleware_;
-        const middlewareManifest = this.mergeMiddlewareManifests(this.middlewareManifests.values());
-        const matchers = (middlewareManifest == null ? void 0 : (_middlewareManifest_middleware_ = middlewareManifest.middleware['/']) == null ? void 0 : _middlewareManifest_middleware_.matchers) || [];
-        const clientMiddlewareManifestPath = join(this.distDir, 'static', this.buildId, "" + TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST);
-        deleteCache(clientMiddlewareManifestPath);
-        writeFileAtomic(clientMiddlewareManifestPath, JSON.stringify(matchers, null, 2));
-    }
-    async writeFallbackBuildManifest() {
-        const fallbackBuildManifest = this.mergeBuildManifests([
-            this.buildManifests.get(getEntryKey('pages', 'server', '_app')),
-            this.buildManifests.get(getEntryKey('pages', 'server', '_error'))
-        ].filter(Boolean));
-        const fallbackBuildManifestPath = join(this.distDir, "fallback-" + BUILD_MANIFEST);
-        deleteCache(fallbackBuildManifestPath);
-        writeFileAtomic(fallbackBuildManifestPath, JSON.stringify(fallbackBuildManifest, null, 2));
-    }
     loadFontManifest(pageName, type) {
         if (type === void 0) type = 'pages';
-        this.fontManifests.set(getEntryKey(type, 'server', pageName), readPartialManifest(this.distDir, "" + NEXT_FONT_MANIFEST + ".json", pageName, type));
+        this.fontManifests.set(getEntryKey(type, 'server', pageName), readPartialManifestContent(this.distDir, "" + NEXT_FONT_MANIFEST + ".json", pageName, type));
     }
     mergeFontManifests(manifests) {
         const manifest = {
@@ -292,6 +358,9 @@ export class TurbopackManifestLoader {
         return manifest;
     }
     async writeNextFontManifest() {
+        if (!this.fontManifests.takeChanged()) {
+            return;
+        }
         const fontManifest = this.mergeFontManifests(this.fontManifests.values());
         const json = JSON.stringify(fontManifest, null, 2);
         const fontManifestJsonPath = join(this.distDir, 'server', "" + NEXT_FONT_MANIFEST + ".json");
@@ -309,7 +378,7 @@ export class TurbopackManifestLoader {
         if (!existsSync(middlewareManifestPath)) {
             return false;
         }
-        this.middlewareManifests.set(getEntryKey(type === 'middleware' || type === 'instrumentation' ? 'root' : type, 'server', pageName), readPartialManifest(this.distDir, MIDDLEWARE_MANIFEST, pageName, type));
+        this.middlewareManifests.set(getEntryKey(type === 'middleware' || type === 'instrumentation' ? 'root' : type, 'server', pageName), readPartialManifestContent(this.distDir, MIDDLEWARE_MANIFEST, pageName, type));
         return true;
     }
     getMiddlewareManifest(key) {
@@ -368,7 +437,12 @@ export class TurbopackManifestLoader {
         return manifest;
     }
     writeMiddlewareManifest() {
+        var _middlewareManifest_middleware_;
+        if (!this.middlewareManifests.takeChanged()) {
+            return;
+        }
         const middlewareManifest = this.mergeMiddlewareManifests(this.middlewareManifests.values());
+        // Server middleware manifest
         // Normalize regexes as it uses path-to-regexp
         for(const key in middlewareManifest.middleware){
             middlewareManifest.middleware[key].matchers.forEach((matcher)=>{
@@ -388,9 +462,14 @@ export class TurbopackManifestLoader {
         const middlewareManifestPath = join(this.distDir, 'server', MIDDLEWARE_MANIFEST);
         deleteCache(middlewareManifestPath);
         writeFileAtomic(middlewareManifestPath, JSON.stringify(middlewareManifest, null, 2));
+        // Client middleware manifest
+        const matchers = (middlewareManifest == null ? void 0 : (_middlewareManifest_middleware_ = middlewareManifest.middleware['/']) == null ? void 0 : _middlewareManifest_middleware_.matchers) || [];
+        const clientMiddlewareManifestPath = join(this.distDir, 'static', this.buildId, "" + TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST);
+        deleteCache(clientMiddlewareManifestPath);
+        writeFileAtomic(clientMiddlewareManifestPath, JSON.stringify(matchers, null, 2));
     }
     loadPagesManifest(pageName) {
-        this.pagesManifests.set(getEntryKey('pages', 'server', pageName), readPartialManifest(this.distDir, PAGES_MANIFEST, pageName));
+        this.pagesManifests.set(getEntryKey('pages', 'server', pageName), readPartialManifestContent(this.distDir, PAGES_MANIFEST, pageName));
     }
     mergePagesManifests(manifests) {
         const manifest = {};
@@ -400,6 +479,9 @@ export class TurbopackManifestLoader {
         return sortObjectByKey(manifest);
     }
     writePagesManifest() {
+        if (!this.pagesManifests.takeChanged()) {
+            return;
+        }
         const pagesManifest = this.mergePagesManifests(this.pagesManifests.values());
         const pagesManifestPath = join(this.distDir, 'server', PAGES_MANIFEST);
         deleteCache(pagesManifestPath);
@@ -409,10 +491,10 @@ export class TurbopackManifestLoader {
         let { devRewrites, productionRewrites, entrypoints } = param;
         this.writeActionManifest();
         this.writeAppPathsManifest();
-        this.writeBuildManifest(entrypoints, devRewrites, productionRewrites);
-        this.writeFallbackBuildManifest();
+        this.writeBuildManifest();
+        this.writeInterceptionRouteRewriteManifest(devRewrites, productionRewrites);
+        this.writeClientBuildManifest(entrypoints, devRewrites, productionRewrites);
         this.writeMiddlewareManifest();
-        this.writeClientMiddlewareManifest();
         this.writeNextFontManifest();
         this.writePagesManifest();
         if (process.env.TURBOPACK_STATS != null) {
@@ -420,14 +502,17 @@ export class TurbopackManifestLoader {
         }
     }
     constructor({ distDir, buildId, encryptionKey }){
-        this.actionManifests = new Map();
-        this.appPathsManifests = new Map();
-        this.buildManifests = new Map();
-        this.clientBuildManifests = new Map();
-        this.fontManifests = new Map();
-        this.middlewareManifests = new Map();
-        this.pagesManifests = new Map();
-        this.webpackStats = new Map();
+        this.actionManifests = new ManifestsMap();
+        this.appPathsManifests = new ManifestsMap();
+        this.buildManifests = new ManifestsMap();
+        this.clientBuildManifests = new ManifestsMap();
+        this.fontManifests = new ManifestsMap();
+        this.middlewareManifests = new ManifestsMap();
+        this.pagesManifests = new ManifestsMap();
+        this.webpackStats = new ManifestsMap();
+        /// interceptionRewrites that have been written to disk
+        /// This is used to avoid unnecessary writes if the rewrites haven't changed
+        this.cachedInterceptionRewrites = undefined;
         this.distDir = distDir;
         this.buildId = buildId;
         this.encryptionKey = encryptionKey;