gsd-pi 2.67.0-dev.46f9884 → 2.67.0-dev.4fb8afe

package/dist/web/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/dist/web/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

package/dist/web/standalone/node_modules/next/dist/shared/lib/utils/reflect-utils.js

@@ -0,0 +1,69 @@
+// This regex will have fast negatives meaning valid identifiers may not pass
+// this test. However this is only used during static generation to provide hints
+// about why a page bailed out of some or all prerendering and we can use bracket notation
+// for example while `ಠ_ಠ` is a valid identifier it's ok to print `searchParams['ಠ_ಠ']`
+// even if this would have been fine too `searchParams.ಠ_ಠ`
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    describeHasCheckingStringProperty: null,
+    describeStringPropertyAccess: null,
+    wellKnownProperties: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    describeHasCheckingStringProperty: function() {
+        return describeHasCheckingStringProperty;
+    },
+    describeStringPropertyAccess: function() {
+        return describeStringPropertyAccess;
+    },
+    wellKnownProperties: function() {
+        return wellKnownProperties;
+    }
+});
+const isDefinitelyAValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function describeStringPropertyAccess(target, prop) {
+    if (isDefinitelyAValidIdentifier.test(prop)) {
+        return `\`${target}.${prop}\``;
+    }
+    return `\`${target}[${JSON.stringify(prop)}]\``;
+}
+function describeHasCheckingStringProperty(target, prop) {
+    const stringifiedProp = JSON.stringify(prop);
+    return `\`Reflect.has(${target}, ${stringifiedProp})\`, \`${stringifiedProp} in ${target}\`, or similar`;
+}
+const wellKnownProperties = new Set([
+    'hasOwnProperty',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toString',
+    'valueOf',
+    'toLocaleString',
+    // Promise prototype
+    'then',
+    'catch',
+    'finally',
+    // React Promise extension
+    'status',
+    // 'value',
+    // 'error',
+    // React introspection
+    'displayName',
+    '_debugInfo',
+    // Common tested properties
+    'toJSON',
+    '$$typeof',
+    '__esModule',
+    // Tested by flight when checking for iterables
+    '@@iterator'
+]);
+
+//# sourceMappingURL=reflect-utils.js.map

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

@@ -130,7 +130,7 @@ async function loadGetInitialProps(App, ctx) {
         if (App.prototype?.getInitialProps) {
             const message = `"${getDisplayName(App)}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`;
             throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                value: "E394",
+                value: "E1035",
                 enumerable: false,
                 configurable: true
             });
@@ -154,7 +154,7 @@ async function loadGetInitialProps(App, ctx) {
     if (!props) {
         const message = `"${getDisplayName(App)}.getInitialProps()" should resolve to an object. But found "${props}" instead.`;
         throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E394",
+            value: "E1025",
             enumerable: false,
             configurable: true
         });

package/dist/web/standalone/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -81,7 +81,7 @@ function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.1.6"
+        nextVersion: "16.2.3"
     };
     return traits;
 }

package/dist/web/standalone/node_modules/next/dist/telemetry/events/swc-load-failure.js

@@ -38,7 +38,7 @@ async function eventSwcLoadFailure(event) {
     telemetry.record({
         eventName: EVENT_PLUGIN_PRESENT,
         payload: {
-            nextVersion: _packagejson.version,
+            nextVersion: "16.2.3",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/dist/web/standalone/node_modules/next/dist/telemetry/events/version.js

@@ -12,12 +12,12 @@ const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED';
 function eventCliSession(nextConfig, event) {
     var _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_reactCompiler, _nextConfig_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "16.1.6" !== 'string') {
+    if (typeof "16.2.3" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.1.6",
+        nextVersion: "16.2.3",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,

package/dist/web/standalone/node_modules/next/dist/trace/index.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", {
     exportTraceState: null,
     flushAllTraces: null,
     getTraceEvents: null,
+    hrtimeToEpochNanoseconds: null,
     initializeTraceState: null,
     recordTraceEvents: null,
     setGlobal: null,
@@ -35,6 +36,9 @@ _export(exports, {
     getTraceEvents: function() {
         return _trace.getTraceEvents;
     },
+    hrtimeToEpochNanoseconds: function() {
+        return _trace.hrtimeToEpochNanoseconds;
+    },
     initializeTraceState: function() {
         return _trace.initializeTraceState;
     },