@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.js

@@ -0,0 +1,32 @@
+/**
+ * Vary Params Decoding
+ *
+ * This module is shared between server and client.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "readVaryParams", {
+    enumerable: true,
+    get: function() {
+        return readVaryParams;
+    }
+});
+function readVaryParams(thenable) {
+    // Attach a no-op listener to force Flight to synchronously resolve the
+    // thenable. When a thenable arrives from the Flight stream, it may be in an
+    // intermediate 'resolved_model' state (data received but not unwrapped).
+    // Calling .then() triggers Flight to transition it to 'fulfilled', making
+    // the value available synchronously. React uses this same optimization
+    // internally to avoid unnecessary microtasks.
+    thenable.then(noop);
+    // If the thenable is still not 'fulfilled' after calling .then(), the server
+    // failed to resolve it before the stream ended. Treat as unknown.
+    if (thenable.status !== 'fulfilled') {
+        return null;
+    }
+    return thenable.value;
+}
+const noop = ()=>{};
+
+//# sourceMappingURL=vary-params-decoding.js.map

package/standalone/node_modules/next/dist/shared/lib/server-reference-info.js

@@ -39,13 +39,17 @@ function extractInfoFromServerReferenceId(id) {
 }
 function omitUnusedArgs(args, info) {
     const filteredArgs = new Array(args.length);
+    let length = 0;
     for(let index = 0; index < args.length; index++){
         if (index < 6 && info.usedArgs[index] || // This assumes that the server reference info byte has the restArgs bit
         // set to 1 if there are more than 6 args.
         index >= 6 && info.hasRestArgs) {
             filteredArgs[index] = args[index];
+            length = index + 1;
         }
     }
+    // Trim trailing unused args from the array.
+    filteredArgs.length = length;
     return filteredArgs;
 }
 

package/standalone/node_modules/next/dist/shared/lib/size-limit.js

@@ -21,6 +21,8 @@ _export(exports, {
     }
 });
 const DEFAULT_MAX_POSTPONED_STATE_SIZE = '100 MB';
+// 100MB in bytes. Not using the parseSizeLimit for performance as parseMaxPostponedStateSize is in the hot path for rendering.
+const DEFAULT_MAX_POSTPONED_STATE_SIZE_BYTES = 104857600;
 function parseSizeLimit(size) {
     const bytes = require('next/dist/compiled/bytes').parse(size);
     if (bytes === null || isNaN(bytes) || bytes < 1) {
@@ -29,7 +31,10 @@ function parseSizeLimit(size) {
     return bytes;
 }
 function parseMaxPostponedStateSize(size) {
-    return parseSizeLimit(size ?? DEFAULT_MAX_POSTPONED_STATE_SIZE);
+    if (!size) {
+        return DEFAULT_MAX_POSTPONED_STATE_SIZE_BYTES;
+    }
+    return parseSizeLimit(size);
 }
 
 //# sourceMappingURL=size-limit.js.map

package/standalone/node_modules/next/dist/shared/lib/turbopack/compilation-events.js

@@ -2,20 +2,54 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "backgroundLogCompilationEvents", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    backgroundLogCompilationEvents: null,
+    msToNs: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    backgroundLogCompilationEvents: function() {
         return backgroundLogCompilationEvents;
+    },
+    msToNs: function() {
+        return msToNs;
     }
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _log = /*#__PURE__*/ _interop_require_wildcard._(require("../../../build/output/log"));
-function backgroundLogCompilationEvents(project, { eventTypes, signal } = {}) {
-    ;
-    (async function() {
-        for await (const event of project.compilationEventsSubscribe(eventTypes)){
-            if (signal?.aborted) {
-                return;
+const _trace = require("../../../trace");
+const _trace1 = require("../../../lib/memory/trace");
+const MILLISECONDS_IN_NANOSECOND = BigInt(1000000);
+function msToNs(ms) {
+    return BigInt(Math.floor(ms)) * MILLISECONDS_IN_NANOSECOND;
+}
+function backgroundLogCompilationEvents(project, { eventTypes, signal, parentSpan } = {}) {
+    const iterator = project.compilationEventsSubscribe(eventTypes);
+    // Close the iterator as soon as the signal fires so the for-await loop
+    // exits without waiting for the next compilation event.
+    signal?.addEventListener('abort', ()=>iterator.return?.(undefined), {
+        once: true
+    });
+    const promise = async function() {
+        for await (const event of iterator){
+            // Record TraceEvent compilation events as trace spans in .next/trace.
+            if (parentSpan && event.typeName === 'TraceEvent' && event.eventJson) {
+                try {
+                    const data = JSON.parse(event.eventJson);
+                    parentSpan.manualTraceChild(data.name, msToNs(data.startTimeMs), msToNs(data.endTimeMs), Object.fromEntries(data.attributes ?? []));
+                    (0, _trace1.traceMemoryUsage)(data.name, parentSpan);
+                    // We flush after each event to make sure it makes it to disk.  These events are rare and
+                    // tend to happen at the very end of a build so to make sure they are logged we need to
+                    // flush.
+                    // NOTE: in a `next build` environment where we are reporting events to the parent thread, this is a no-op.
+                    await (0, _trace.flushAllTraces)();
+                } catch  {}
+                continue; // don't log these events, they just go to the trace file
             }
             switch(event.severity){
                 case 'EVENT':
@@ -40,7 +74,10 @@ function backgroundLogCompilationEvents(project, { eventTypes, signal } = {}) {
                     break;
             }
         }
-    })();
+    }();
+    // Prevent unhandled rejection if the subscription errors after the project shuts down.
+    promise.catch(()=>{});
+    return promise;
 }
 
 //# sourceMappingURL=compilation-events.js.map

package/standalone/node_modules/next/dist/shared/lib/turbopack/manifest-loader.js

@@ -14,7 +14,6 @@ const _path = require("path");
 const _fs = require("fs");
 const _requirecache = require("../../../server/dev/require-cache");
 const _writeatomic = require("../../../lib/fs/write-atomic");
-const _generateinterceptionroutesrewrites = require("../../../lib/generate-interception-routes-rewrites");
 const _getassetpathfromroute = /*#__PURE__*/ _interop_require_default._(require("../router/utils/get-asset-path-from-route"));
 const _entrykey = require("./entry-key");
 const _utils = require("../router/utils");
@@ -33,7 +32,14 @@ const getManifestPath = (page, distDir, name, type, firstCall)=>{
         // existsSync is faster than using the async version
         if (!(0, _fs.existsSync)(manifestPath) && page.endsWith('/route')) {
             // TODO: Improve implementation of metadata routes, currently it requires this extra check for the variants of the files that can be written.
-            let metadataPage = (0, _turbopackutils.addRouteSuffix)((0, _turbopackutils.addMetadataIdToRoute)((0, _turbopackutils.removeRouteSuffix)(page)));
+            let basePage = (0, _turbopackutils.removeRouteSuffix)(page);
+            // For sitemap.xml routes with generateSitemaps, the manifest is at
+            // /sitemap/[__metadata_id__]/route (without .xml), because the route
+            // handler serves at /sitemap/[id] not /sitemap.xml/[id]
+            if (basePage.endsWith('/sitemap.xml')) {
+                basePage = basePage.slice(0, -'.xml'.length);
+            }
+            let metadataPage = (0, _turbopackutils.addRouteSuffix)((0, _turbopackutils.addMetadataIdToRoute)(basePage));
             manifestPath = getManifestPath(metadataPage, distDir, name, type, false);
         }
     }
@@ -87,7 +93,7 @@ class ManifestsMap {
     }
 }
 class TurbopackManifestLoader {
-    constructor({ distDir, buildId, encryptionKey }){
+    constructor({ distDir, buildId, encryptionKey, dev, sriEnabled }){
         this.actionManifests = new ManifestsMap();
         this.appPathsManifests = new ManifestsMap();
         this.buildManifests = new ManifestsMap();
@@ -95,13 +101,16 @@ class TurbopackManifestLoader {
         this.fontManifests = new ManifestsMap();
         this.middlewareManifests = new ManifestsMap();
         this.pagesManifests = new ManifestsMap();
-        this.webpackStats = new ManifestsMap();
+        this.sriManifests = 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.pendingCacheDeletes = [];
         this.distDir = distDir;
         this.buildId = buildId;
         this.encryptionKey = encryptionKey;
+        this.dev = dev;
+        this.sriEnabled = sriEnabled;
     }
     delete(key) {
         this.actionManifests.delete(key);
@@ -111,7 +120,6 @@ class TurbopackManifestLoader {
         this.fontManifests.delete(key);
         this.middlewareManifests.delete(key);
         this.pagesManifests.delete(key);
-        this.webpackStats.delete(key);
     }
     loadActionManifest(pageName) {
         this.actionManifests.set((0, _entrykey.getEntryKey)('app', 'server', pageName), readPartialManifestContent(this.distDir, `${_constants.SERVER_REFERENCE_MANIFEST}.json`, pageName, 'app'));
@@ -125,13 +133,11 @@ class TurbopackManifestLoader {
         function mergeActionIds(actionEntries, other) {
             for(const key in other){
                 const action = actionEntries[key] ??= {
-                    workers: {},
-                    layer: {}
+                    workers: {}
                 };
                 action.filename = other[key].filename;
                 action.exportedName = other[key].exportedName;
                 Object.assign(action.workers, other[key].workers);
-                Object.assign(action.layer, other[key].layer);
             }
         }
         for (const m of manifests){
@@ -141,12 +147,10 @@ class TurbopackManifestLoader {
         for(const key in manifest.node){
             const entry = manifest.node[key];
             entry.workers = sortObjectByKey(entry.workers);
-            entry.layer = sortObjectByKey(entry.layer);
         }
         for(const key in manifest.edge){
             const entry = manifest.edge[key];
             entry.workers = sortObjectByKey(entry.workers);
-            entry.layer = sortObjectByKey(entry.layer);
         }
         return manifest;
     }
@@ -158,8 +162,8 @@ class TurbopackManifestLoader {
         const actionManifestJsonPath = (0, _path.join)(this.distDir, 'server', `${_constants.SERVER_REFERENCE_MANIFEST}.json`);
         const actionManifestJsPath = (0, _path.join)(this.distDir, 'server', `${_constants.SERVER_REFERENCE_MANIFEST}.js`);
         const json = JSON.stringify(actionManifest, null, 2);
-        (0, _requirecache.deleteCache)(actionManifestJsonPath);
-        (0, _requirecache.deleteCache)(actionManifestJsPath);
+        this.pendingCacheDeletes.push(actionManifestJsonPath);
+        this.pendingCacheDeletes.push(actionManifestJsPath);
         (0, _writeatomic.writeFileAtomic)(actionManifestJsonPath, json);
         (0, _writeatomic.writeFileAtomic)(actionManifestJsPath, `self.__RSC_SERVER_MANIFEST=${JSON.stringify(json)}`);
     }
@@ -172,17 +176,20 @@ class TurbopackManifestLoader {
         }
         const appPathsManifest = this.mergePagesManifests(this.appPathsManifests.values());
         const appPathsManifestPath = (0, _path.join)(this.distDir, 'server', _constants.APP_PATHS_MANIFEST);
-        (0, _requirecache.deleteCache)(appPathsManifestPath);
+        this.pendingCacheDeletes.push(appPathsManifestPath);
         (0, _writeatomic.writeFileAtomic)(appPathsManifestPath, JSON.stringify(appPathsManifest, null, 2));
     }
-    writeWebpackStats() {
-        if (!this.webpackStats.takeChanged()) {
+    writeSriManifest() {
+        if (!this.sriEnabled || !this.sriManifests.takeChanged()) {
             return;
         }
-        const webpackStats = this.mergeWebpackStats(this.webpackStats.values());
-        const path = (0, _path.join)(this.distDir, 'server', _constants.WEBPACK_STATS);
-        (0, _requirecache.deleteCache)(path);
-        (0, _writeatomic.writeFileAtomic)(path, JSON.stringify(webpackStats, null, 2));
+        const sriManifest = this.mergeSriManifests(this.sriManifests.values());
+        const pathJson = (0, _path.join)(this.distDir, 'server', `${_constants.SUBRESOURCE_INTEGRITY_MANIFEST}.json`);
+        const pathJs = (0, _path.join)(this.distDir, 'server', `${_constants.SUBRESOURCE_INTEGRITY_MANIFEST}.js`);
+        this.pendingCacheDeletes.push(pathJson);
+        this.pendingCacheDeletes.push(pathJs);
+        (0, _writeatomic.writeFileAtomic)(pathJson, JSON.stringify(sriManifest, null, 2));
+        (0, _writeatomic.writeFileAtomic)(pathJs, `self.__SUBRESOURCE_INTEGRITY_MANIFEST=${JSON.stringify(JSON.stringify(sriManifest))}`);
     }
     loadBuildManifest(pageName, type = 'pages') {
         this.buildManifests.set((0, _entrykey.getEntryKey)(type, 'server', pageName), readPartialManifestContent(this.distDir, _constants.BUILD_MANIFEST, pageName, type));
@@ -190,70 +197,11 @@ class TurbopackManifestLoader {
     loadClientBuildManifest(pageName, type = 'pages') {
         this.clientBuildManifests.set((0, _entrykey.getEntryKey)(type, 'server', pageName), readPartialManifestContent(this.distDir, _constants.TURBOPACK_CLIENT_BUILD_MANIFEST, pageName, type));
     }
-    loadWebpackStats(pageName, type = 'pages') {
-        this.webpackStats.set((0, _entrykey.getEntryKey)(type, 'client', pageName), readPartialManifestContent(this.distDir, _constants.WEBPACK_STATS, pageName, type));
-    }
-    mergeWebpackStats(statsFiles) {
-        const entrypoints = {};
-        const assets = new Map();
-        const chunks = new Map();
-        const modules = new Map();
-        for (const statsFile of statsFiles){
-            if (statsFile.entrypoints) {
-                for (const [k, v] of Object.entries(statsFile.entrypoints)){
-                    if (!entrypoints[k]) {
-                        entrypoints[k] = v;
-                    }
-                }
-            }
-            if (statsFile.assets) {
-                for (const asset of statsFile.assets){
-                    if (!assets.has(asset.name)) {
-                        assets.set(asset.name, asset);
-                    }
-                }
-            }
-            if (statsFile.chunks) {
-                for (const chunk of statsFile.chunks){
-                    if (!chunks.has(chunk.id)) {
-                        chunks.set(chunk.id, chunk);
-                    }
-                }
-            }
-            if (statsFile.modules) {
-                for (const module of statsFile.modules){
-                    const id = module.id;
-                    if (id != null) {
-                        // Merge the chunk list for the module. This can vary across endpoints.
-                        const existing = modules.get(id);
-                        if (existing == null) {
-                            modules.set(id, module);
-                        } else if (module.chunks != null && existing.chunks != null) {
-                            for (const chunk of module.chunks){
-                                if (!existing.chunks.includes(chunk)) {
-                                    existing.chunks.push(chunk);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            version: 'Turbopack',
-            entrypoints,
-            assets: [
-                ...assets.values()
-            ],
-            chunks: [
-                ...chunks.values()
-            ],
-            modules: [
-                ...modules.values()
-            ]
-        };
+    loadSriManifest(pageName, type = 'pages') {
+        if (!this.sriEnabled) return;
+        this.sriManifests.set((0, _entrykey.getEntryKey)(type, 'client', pageName), readPartialManifestContent(this.distDir, `${_constants.SUBRESOURCE_INTEGRITY_MANIFEST}.json`, pageName, type));
     }
-    mergeBuildManifests(manifests) {
+    mergeBuildManifests(manifests, lowPriorityFiles) {
         const manifest = {
             pages: {
                 '/_app': []
@@ -261,10 +209,7 @@ class TurbopackManifestLoader {
             // Something in next.js depends on these to exist even for app dir rendering
             devFiles: [],
             polyfillFiles: [],
-            lowPriorityFiles: [
-                `static/${this.buildId}/_ssgManifest.js`,
-                `static/${this.buildId}/_buildManifest.js`
-            ],
+            lowPriorityFiles,
             rootMainFiles: []
         };
         for (const m of manifests){
@@ -293,35 +238,33 @@ class TurbopackManifestLoader {
             afterFiles: (devRewrites?.afterFiles ?? []).map(_buildmanifestpluginutils.processRoute),
             fallback: (devRewrites?.fallback ?? []).map(_buildmanifestpluginutils.processRoute)
         };
-        const interceptionRewrites = JSON.stringify(rewrites.beforeFiles.filter(_generateinterceptionroutesrewrites.isInterceptionRouteRewrite));
+        const interceptionRewrites = JSON.stringify(rewrites.beforeFiles.filter(require('../../../lib/is-interception-route-rewrite').isInterceptionRouteRewrite));
         if (this.cachedInterceptionRewrites === interceptionRewrites) {
             return;
         }
         this.cachedInterceptionRewrites = interceptionRewrites;
         const interceptionRewriteManifestPath = (0, _path.join)(this.distDir, 'server', `${_constants.INTERCEPTION_ROUTE_REWRITE_MANIFEST}.js`);
-        (0, _requirecache.deleteCache)(interceptionRewriteManifestPath);
+        this.pendingCacheDeletes.push(interceptionRewriteManifestPath);
         (0, _writeatomic.writeFileAtomic)(interceptionRewriteManifestPath, `self.__INTERCEPTION_ROUTE_REWRITE_MANIFEST=${JSON.stringify(interceptionRewrites)};`);
     }
-    writeBuildManifest() {
+    writeBuildManifest(lowPriorityFiles) {
         if (!this.buildManifests.takeChanged()) {
             return;
         }
-        const buildManifest = this.mergeBuildManifests(this.buildManifests.values());
+        const buildManifest = this.mergeBuildManifests(this.buildManifests.values(), lowPriorityFiles);
         const buildManifestPath = (0, _path.join)(this.distDir, _constants.BUILD_MANIFEST);
         const middlewareBuildManifestPath = (0, _path.join)(this.distDir, 'server', `${_constants.MIDDLEWARE_BUILD_MANIFEST}.js`);
-        (0, _requirecache.deleteCache)(buildManifestPath);
-        (0, _requirecache.deleteCache)(middlewareBuildManifestPath);
+        this.pendingCacheDeletes.push(buildManifestPath);
+        this.pendingCacheDeletes.push(middlewareBuildManifestPath);
         (0, _writeatomic.writeFileAtomic)(buildManifestPath, JSON.stringify(buildManifest, null, 2));
-        (0, _writeatomic.writeFileAtomic)(middlewareBuildManifestPath, // we use globalThis here because middleware can be node
-        // which doesn't have "self"
-        (0, _buildmanifestpluginutils.createEdgeRuntimeManifest)(buildManifest));
+        (0, _writeatomic.writeFileAtomic)(middlewareBuildManifestPath, (0, _buildmanifestpluginutils.createEdgeRuntimeManifest)(buildManifest));
         // Write fallback build manifest
         const fallbackBuildManifest = this.mergeBuildManifests([
             this.buildManifests.get((0, _entrykey.getEntryKey)('pages', 'server', '_app')),
             this.buildManifests.get((0, _entrykey.getEntryKey)('pages', 'server', '_error'))
-        ].filter(Boolean));
+        ].filter(Boolean), lowPriorityFiles);
         const fallbackBuildManifestPath = (0, _path.join)(this.distDir, `fallback-${_constants.BUILD_MANIFEST}`);
-        (0, _requirecache.deleteCache)(fallbackBuildManifestPath);
+        this.pendingCacheDeletes.push(fallbackBuildManifestPath);
         (0, _writeatomic.writeFileAtomic)(fallbackBuildManifestPath, JSON.stringify(fallbackBuildManifest, null, 2));
     }
     writeClientBuildManifest(entrypoints, devRewrites, productionRewrites) {
@@ -341,16 +284,27 @@ class TurbopackManifestLoader {
             pagesKeys.push('/_error');
         }
         const sortedPageKeys = (0, _utils.getSortedRoutes)(pagesKeys);
-        if (!this.clientBuildManifests.takeChanged({
+        let buildManifestPath = _path.posix.join(_constants.CLIENT_STATIC_FILES_PATH, this.buildId, '_buildManifest.js');
+        let ssgManifestPath = _path.posix.join(_constants.CLIENT_STATIC_FILES_PATH, this.buildId, '_ssgManifest.js');
+        if (this.dev && !this.clientBuildManifests.takeChanged({
             rewrites,
             sortedPageKeys
         })) {
-            return;
+            return [
+                buildManifestPath,
+                ssgManifestPath
+            ];
         }
         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()`;
-        (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, 'static', this.buildId, '_buildManifest.js'), clientBuildManifestJs);
-        (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, 'static', this.buildId, '_ssgManifest.js'), _buildmanifestpluginutils.srcEmptySsgManifest);
+        (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, buildManifestPath), clientBuildManifestJs);
+        // This is just an empty placeholder, the actual manifest is written after prerendering in
+        // packages/next/src/build/index.ts
+        (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, ssgManifestPath), _buildmanifestpluginutils.srcEmptySsgManifest);
+        return [
+            buildManifestPath,
+            ssgManifestPath
+        ];
     }
     loadFontManifest(pageName, type = 'pages') {
         this.fontManifests.set((0, _entrykey.getEntryKey)(type, 'server', pageName), readPartialManifestContent(this.distDir, `${_constants.NEXT_FONT_MANIFEST}.json`, pageName, type));
@@ -380,8 +334,8 @@ class TurbopackManifestLoader {
         const json = JSON.stringify(fontManifest, null, 2);
         const fontManifestJsonPath = (0, _path.join)(this.distDir, 'server', `${_constants.NEXT_FONT_MANIFEST}.json`);
         const fontManifestJsPath = (0, _path.join)(this.distDir, 'server', `${_constants.NEXT_FONT_MANIFEST}.js`);
-        (0, _requirecache.deleteCache)(fontManifestJsonPath);
-        (0, _requirecache.deleteCache)(fontManifestJsPath);
+        this.pendingCacheDeletes.push(fontManifestJsonPath);
+        this.pendingCacheDeletes.push(fontManifestJsPath);
         (0, _writeatomic.writeFileAtomic)(fontManifestJsonPath, json);
         (0, _writeatomic.writeFileAtomic)(fontManifestJsPath, `self.__NEXT_FONT_MANIFEST=${JSON.stringify(json)}`);
     }
@@ -451,8 +405,11 @@ class TurbopackManifestLoader {
         return manifest;
     }
     writeMiddlewareManifest() {
-        if (!this.middlewareManifests.takeChanged()) {
-            return;
+        let clientMiddlewareManifestPath = _path.posix.join(_constants.CLIENT_STATIC_FILES_PATH, this.buildId, _constants.TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST);
+        if (this.dev && !this.middlewareManifests.takeChanged()) {
+            return {
+                clientMiddlewareManifestPath
+            };
         }
         const middlewareManifest = this.mergeMiddlewareManifests(this.middlewareManifests.values());
         // Server middleware manifest
@@ -473,13 +430,17 @@ class TurbopackManifestLoader {
             });
         }
         const middlewareManifestPath = (0, _path.join)(this.distDir, 'server', _constants.MIDDLEWARE_MANIFEST);
-        (0, _requirecache.deleteCache)(middlewareManifestPath);
+        this.pendingCacheDeletes.push(middlewareManifestPath);
         (0, _writeatomic.writeFileAtomic)(middlewareManifestPath, JSON.stringify(middlewareManifest, null, 2));
-        // Client middleware manifest
+        // Client middleware manifest This is only used in dev though, packages/next/src/build/index.ts
+        // writes the mainfest again for builds.
         const matchers = middlewareManifest?.middleware['/']?.matchers || [];
-        const clientMiddlewareManifestPath = (0, _path.join)(this.distDir, 'static', this.buildId, `${_constants.TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST}`);
-        (0, _requirecache.deleteCache)(clientMiddlewareManifestPath);
-        (0, _writeatomic.writeFileAtomic)(clientMiddlewareManifestPath, JSON.stringify(matchers, null, 2));
+        const clientMiddlewareManifestJs = `self.__MIDDLEWARE_MATCHERS = ${JSON.stringify(matchers, null, 2)};self.__MIDDLEWARE_MATCHERS_CB && self.__MIDDLEWARE_MATCHERS_CB()`;
+        this.pendingCacheDeletes.push(clientMiddlewareManifestPath);
+        (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, clientMiddlewareManifestPath), clientMiddlewareManifestJs);
+        return {
+            clientMiddlewareManifestPath
+        };
     }
     loadPagesManifest(pageName) {
         this.pagesManifests.set((0, _entrykey.getEntryKey)('pages', 'server', pageName), readPartialManifestContent(this.distDir, _constants.PAGES_MANIFEST, pageName));
@@ -491,26 +452,39 @@ class TurbopackManifestLoader {
         }
         return sortObjectByKey(manifest);
     }
+    mergeSriManifests(manifests) {
+        const manifest = {};
+        for (const m of manifests){
+            Object.assign(manifest, m);
+        }
+        return sortObjectByKey(manifest);
+    }
     writePagesManifest() {
         if (!this.pagesManifests.takeChanged()) {
             return;
         }
         const pagesManifest = this.mergePagesManifests(this.pagesManifests.values());
         const pagesManifestPath = (0, _path.join)(this.distDir, 'server', _constants.PAGES_MANIFEST);
-        (0, _requirecache.deleteCache)(pagesManifestPath);
+        this.pendingCacheDeletes.push(pagesManifestPath);
         (0, _writeatomic.writeFileAtomic)(pagesManifestPath, JSON.stringify(pagesManifest, null, 2));
     }
     writeManifests({ devRewrites, productionRewrites, entrypoints }) {
         this.writeActionManifest();
         this.writeAppPathsManifest();
-        this.writeBuildManifest();
+        const lowPriorityFiles = this.writeClientBuildManifest(entrypoints, devRewrites, productionRewrites);
+        const { clientMiddlewareManifestPath } = this.writeMiddlewareManifest();
+        this.writeBuildManifest([
+            ...lowPriorityFiles,
+            clientMiddlewareManifestPath
+        ]);
         this.writeInterceptionRouteRewriteManifest(devRewrites, productionRewrites);
-        this.writeClientBuildManifest(entrypoints, devRewrites, productionRewrites);
-        this.writeMiddlewareManifest();
         this.writeNextFontManifest();
         this.writePagesManifest();
-        if (process.env.TURBOPACK_STATS != null) {
-            this.writeWebpackStats();
+        this.writeSriManifest();
+        // Flush all queued cache deletions in a single require.cache scan
+        if (this.pendingCacheDeletes.length > 0) {
+            (0, _requirecache.deleteCache)(this.pendingCacheDeletes);
+            this.pendingCacheDeletes = [];
         }
     }
 }

package/standalone/node_modules/next/dist/shared/lib/turbopack/utils.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
     ModuleBuildError: null,
     formatIssue: null,
     getIssueKey: null,
-    isFileSystemCacheEnabledForBuild: null,
     isFileSystemCacheEnabledForDev: null,
     isRelevantWarning: null,
     isWellKnownError: null,
@@ -29,9 +28,6 @@ _export(exports, {
     getIssueKey: function() {
         return getIssueKey;
     },
-    isFileSystemCacheEnabledForBuild: function() {
-        return isFileSystemCacheEnabledForBuild;
-    },
     isFileSystemCacheEnabledForDev: function() {
         return isFileSystemCacheEnabledForDev;
     },
@@ -48,10 +44,8 @@ _export(exports, {
         return renderStyledStringToErrorAnsi;
     }
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _picocolors = require("../../../lib/picocolors");
-const _isinternal = /*#__PURE__*/ _interop_require_default._(require("../is-internal"));
 const _magicidentifier = require("../magic-identifier");
 const _log = /*#__PURE__*/ _interop_require_wildcard._(require("../../../build/output/log"));
 const VERBOSE_ISSUES = !!process.env.NEXT_TURBOPACK_VERBOSE_ISSUES;
@@ -100,6 +94,9 @@ function processIssues(currentEntryIssues, key, result, throwIssue, logErrors) {
         });
     }
 }
+function formatFilePath(filePath) {
+    return filePath.replace('[project]/', './').replaceAll('/./', '/').replace('\\\\?\\', '');
+}
 function formatIssue(issue) {
     const { filePath, title, description, detail, source, importTraces } = issue;
     let { documentationLink } = issue;
@@ -111,7 +108,7 @@ function formatIssue(issue) {
         // TODO: include columns in webpack errors.
         documentationLink = 'https://nextjs.org/docs/messages/module-not-found';
     }
-    const formattedFilePath = filePath.replace('[project]/', './').replaceAll('/./', '/').replace('\\\\?\\', '');
+    const formattedFilePath = formatFilePath(filePath);
     let message = '';
     if (source?.range) {
         const { start } = source.range;
@@ -122,22 +119,8 @@ function formatIssue(issue) {
         message = formattedTitle;
     }
     message += '\n';
-    if (source?.range && source.source.content && // ignore Next.js/React internals, as these can often be huge bundled files.
-    !(0, _isinternal.default)(filePath)) {
-        const { start, end } = source.range;
-        const { codeFrameColumns } = require('next/dist/compiled/babel/code-frame');
-        message += codeFrameColumns(source.source.content, {
-            start: {
-                line: start.line + 1,
-                column: start.column + 1
-            },
-            end: {
-                line: end.line + 1,
-                column: end.column + 1
-            }
-        }, {
-            forceColor: true
-        }).trim() + '\n\n';
+    if (issue.codeFrame) {
+        message += issue.codeFrame.trimEnd() + '\n\n';
     }
     if (description) {
         if (description.type === 'text' && description.value.includes(`Cannot find module 'sass'`)) {
@@ -152,6 +135,14 @@ function formatIssue(issue) {
     if (VERBOSE_ISSUES && detail) {
         message += renderStyledStringToErrorAnsi(detail) + '\n\n';
     }
+    // Render additional sources (e.g., generated code from a loader)
+    for (const additional of issue.additionalSources ?? []){
+        if (additional.codeFrame) {
+            const additionalFilePath = formatFilePath(additional.source.source.filePath);
+            const loc = additional.source.range ? `:${additional.source.range.start.line + 1}:${additional.source.range.start.column + 1}` : '';
+            message += `${additional.description}:\n${additionalFilePath}${loc}\n${additional.codeFrame.trimEnd()}\n\n`;
+        }
+    }
     if (importTraces?.length) {
         // This is the same logic as in turbopack/crates/turbopack-cli-utils/src/issue.rs
         // We end up with multiple traces when the file with the error is reachable from multiple
@@ -272,8 +263,5 @@ function renderStyledStringToErrorAnsi(string) {
 function isFileSystemCacheEnabledForDev(config) {
     return config.experimental?.turbopackFileSystemCacheForDev || false;
 }
-function isFileSystemCacheEnabledForBuild(config) {
-    return config.experimental?.turbopackFileSystemCacheForBuild || false;
-}
 
 //# sourceMappingURL=utils.js.map