inital commit

node_modules/next/dist/shared/lib/turbopack/entry-key.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `app` -> app dir
+ * `pages` -> pages dir
+ * `root` -> middleware / instrumentation
+ * `assets` -> assets
+ */
+export type EntryKeyType = 'app' | 'pages' | 'root' | 'assets';
+export type EntryKeySide = 'client' | 'server';
+export type EntryKey = `{"type":"${EntryKeyType}","side":"${EntryKeyType}","page":"${string}"}`;
+/**
+ * Get a key that's unique across all entrypoints.
+ */
+export declare function getEntryKey(type: EntryKeyType, side: EntryKeySide, page: string): EntryKey;
+/**
+ * Split an `EntryKey` up into its components.
+ */
+export declare function splitEntryKey(key: EntryKey): {
+    type: EntryKeyType;
+    side: EntryKeySide;
+    page: string;
+};

node_modules/next/dist/shared/lib/turbopack/entry-key.js

@@ -0,0 +1,39 @@
+/**
+ * `app` -> app dir
+ * `pages` -> pages dir
+ * `root` -> middleware / instrumentation
+ * `assets` -> assets
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getEntryKey: null,
+    splitEntryKey: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getEntryKey: function() {
+        return getEntryKey;
+    },
+    splitEntryKey: function() {
+        return splitEntryKey;
+    }
+});
+function getEntryKey(type, side, page) {
+    return JSON.stringify({
+        type,
+        side,
+        page
+    });
+}
+function splitEntryKey(key) {
+    return JSON.parse(key);
+}
+
+//# sourceMappingURL=entry-key.js.map

node_modules/next/dist/shared/lib/turbopack/entry-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/turbopack/entry-key.ts"],"sourcesContent":["/**\n * `app` -> app dir\n * `pages` -> pages dir\n * `root` -> middleware / instrumentation\n * `assets` -> assets\n */\nexport type EntryKeyType = 'app' | 'pages' | 'root' | 'assets'\nexport type EntryKeySide = 'client' | 'server'\n\n// custom type to make sure you can't accidentally use a \"generic\" string\nexport type EntryKey =\n  `{\"type\":\"${EntryKeyType}\",\"side\":\"${EntryKeyType}\",\"page\":\"${string}\"}`\n\n/**\n * Get a key that's unique across all entrypoints.\n */\nexport function getEntryKey(\n  type: EntryKeyType,\n  side: EntryKeySide,\n  page: string\n): EntryKey {\n  return JSON.stringify({ type, side, page }) as EntryKey\n}\n\n/**\n * Split an `EntryKey` up into its components.\n */\nexport function splitEntryKey(key: EntryKey): {\n  type: EntryKeyType\n  side: EntryKeySide\n  page: string\n} {\n  return JSON.parse(key)\n}\n"],"names":["getEntryKey","splitEntryKey","type","side","page","JSON","stringify","key","parse"],"mappings":"AAAA;;;;;CAKC;;;;;;;;;;;;;;;IAWeA,WAAW;eAAXA;;IAWAC,aAAa;eAAbA;;;AAXT,SAASD,YACdE,IAAkB,EAClBC,IAAkB,EAClBC,IAAY;IAEZ,OAAOC,KAAKC,SAAS,CAAC;QAAEJ;QAAMC;QAAMC;IAAK;AAC3C;AAKO,SAASH,cAAcM,GAAa;IAKzC,OAAOF,KAAKG,KAAK,CAACD;AACpB"}

node_modules/next/dist/shared/lib/turbopack/manifest-loader.d.ts

@@ -0,0 +1,64 @@
+import type { MiddlewareManifest } from '../../../build/webpack/plugins/middleware-plugin';
+import type { SetupOpts } from '../../../server/lib/router-utils/setup-dev-bundler';
+import { type EntryKey } from './entry-key';
+import type { CustomRoutes } from '../../../lib/load-custom-routes';
+import type { Entrypoints } from '../../../build/swc/types';
+interface InstrumentationDefinition {
+    files: string[];
+    name: 'instrumentation';
+}
+type TurbopackMiddlewareManifest = MiddlewareManifest & {
+    instrumentation?: InstrumentationDefinition;
+};
+export declare class TurbopackManifestLoader {
+    private actionManifests;
+    private appBuildManifests;
+    private appPathsManifests;
+    private buildManifests;
+    private fontManifests;
+    private middlewareManifests;
+    private pagesManifests;
+    private webpackStats;
+    private encryptionKey;
+    private readonly distDir;
+    private readonly buildId;
+    constructor({ distDir, buildId, encryptionKey, }: {
+        buildId: string;
+        distDir: string;
+        encryptionKey: string;
+    });
+    delete(key: EntryKey): void;
+    loadActionManifest(pageName: string): Promise<void>;
+    private mergeActionManifests;
+    private writeActionManifest;
+    loadAppBuildManifest(pageName: string): Promise<void>;
+    private mergeAppBuildManifests;
+    private writeAppBuildManifest;
+    loadAppPathsManifest(pageName: string): Promise<void>;
+    private writeAppPathsManifest;
+    private writeWebpackStats;
+    loadBuildManifest(pageName: string, type?: 'app' | 'pages'): Promise<void>;
+    loadWebpackStats(pageName: string, type?: 'app' | 'pages'): Promise<void>;
+    private mergeWebpackStats;
+    private mergeBuildManifests;
+    private writeBuildManifest;
+    private writeClientMiddlewareManifest;
+    private writeFallbackBuildManifest;
+    loadFontManifest(pageName: string, type?: 'app' | 'pages'): Promise<void>;
+    private mergeFontManifests;
+    private writeNextFontManifest;
+    loadMiddlewareManifest(pageName: string, type: 'pages' | 'app' | 'middleware' | 'instrumentation'): Promise<void>;
+    getMiddlewareManifest(key: EntryKey): TurbopackMiddlewareManifest | undefined;
+    deleteMiddlewareManifest(key: EntryKey): boolean;
+    private mergeMiddlewareManifests;
+    private writeMiddlewareManifest;
+    loadPagesManifest(pageName: string): Promise<void>;
+    private mergePagesManifests;
+    private writePagesManifest;
+    writeManifests({ devRewrites, productionRewrites, entrypoints, }: {
+        devRewrites: SetupOpts['fsChecker']['rewrites'] | undefined;
+        productionRewrites: CustomRoutes['rewrites'] | undefined;
+        entrypoints: Entrypoints;
+    }): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TurbopackManifestLoader", {
+    enumerable: true,
+    get: function() {
+        return TurbopackManifestLoader;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
+const _constants = require("../constants");
+const _path = require("path");
+const _promises = require("fs/promises");
+const _requirecache = require("../../../server/dev/require-cache");
+const _writeatomic = require("../../../lib/fs/write-atomic");
+const _generateinterceptionroutesrewrites = require("../../../lib/generate-interception-routes-rewrites");
+const _buildmanifestplugin = require("../../../build/webpack/plugins/build-manifest-plugin");
+const _getassetpathfromroute = /*#__PURE__*/ _interop_require_default._(require("../router/utils/get-asset-path-from-route"));
+const _entrykey = require("./entry-key");
+const _utils = require("../router/utils");
+const _fs = require("fs");
+const _turbopackutils = require("../../../server/dev/turbopack-utils");
+const _trytoparsepath = require("../../../lib/try-to-parse-path");
+const getManifestPath = (page, distDir, name, type)=>{
+    let manifestPath = _path.posix.join(distDir, "server", type, type === 'middleware' || type === 'instrumentation' ? '' : type === 'app' ? page : (0, _getassetpathfromroute.default)(page), name);
+    return manifestPath;
+};
+async function readPartialManifest(distDir, name, pageName, type) {
+    if (type === void 0) type = 'pages';
+    const page = pageName;
+    const isSitemapRoute = /[\\/]sitemap(.xml)?\/route$/.test(page);
+    let manifestPath = getManifestPath(page, distDir, name, type);
+    // Check the ambiguity of /sitemap and /sitemap.xml
+    if (isSitemapRoute && !(0, _fs.existsSync)(manifestPath)) {
+        manifestPath = getManifestPath(pageName.replace(/\/sitemap\/route$/, '/sitemap.xml/route'), distDir, name, type);
+    }
+    // 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)));
+        manifestPath = getManifestPath(metadataPage, distDir, name, type);
+    }
+    return JSON.parse(await (0, _promises.readFile)(_path.posix.join(manifestPath), 'utf-8'));
+}
+class TurbopackManifestLoader {
+    delete(key) {
+        this.actionManifests.delete(key);
+        this.appBuildManifests.delete(key);
+        this.appPathsManifests.delete(key);
+        this.buildManifests.delete(key);
+        this.fontManifests.delete(key);
+        this.middlewareManifests.delete(key);
+        this.pagesManifests.delete(key);
+        this.webpackStats.delete(key);
+    }
+    async loadActionManifest(pageName) {
+        this.actionManifests.set((0, _entrykey.getEntryKey)('app', 'server', pageName), await readPartialManifest(this.distDir, "" + _constants.SERVER_REFERENCE_MANIFEST + ".json", pageName, 'app'));
+    }
+    async mergeActionManifests(manifests) {
+        const manifest = {
+            node: {},
+            edge: {},
+            encryptionKey: this.encryptionKey
+        };
+        function mergeActionIds(actionEntries, other) {
+            for(const key in other){
+                var _actionEntries, _key;
+                var _;
+                const action = (_ = (_actionEntries = actionEntries)[_key = key]) != null ? _ : _actionEntries[_key] = {
+                    workers: {},
+                    layer: {}
+                };
+                Object.assign(action.workers, other[key].workers);
+                Object.assign(action.layer, other[key].layer);
+            }
+        }
+        for (const m of manifests){
+            mergeActionIds(manifest.node, m.node);
+            mergeActionIds(manifest.edge, m.edge);
+        }
+        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;
+    }
+    async writeActionManifest() {
+        const actionManifest = await this.mergeActionManifests(this.actionManifests.values());
+        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);
+        await (0, _writeatomic.writeFileAtomic)(actionManifestJsonPath, json);
+        await (0, _writeatomic.writeFileAtomic)(actionManifestJsPath, "self.__RSC_SERVER_MANIFEST=" + JSON.stringify(json));
+    }
+    async loadAppBuildManifest(pageName) {
+        this.appBuildManifests.set((0, _entrykey.getEntryKey)('app', 'server', pageName), await readPartialManifest(this.distDir, _constants.APP_BUILD_MANIFEST, pageName, 'app'));
+    }
+    mergeAppBuildManifests(manifests) {
+        const manifest = {
+            pages: {}
+        };
+        for (const m of manifests){
+            Object.assign(manifest.pages, m.pages);
+        }
+        manifest.pages = sortObjectByKey(manifest.pages);
+        return manifest;
+    }
+    async writeAppBuildManifest() {
+        const appBuildManifest = this.mergeAppBuildManifests(this.appBuildManifests.values());
+        const appBuildManifestPath = (0, _path.join)(this.distDir, _constants.APP_BUILD_MANIFEST);
+        (0, _requirecache.deleteCache)(appBuildManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(appBuildManifestPath, JSON.stringify(appBuildManifest, null, 2));
+    }
+    async loadAppPathsManifest(pageName) {
+        this.appPathsManifests.set((0, _entrykey.getEntryKey)('app', 'server', pageName), await readPartialManifest(this.distDir, _constants.APP_PATHS_MANIFEST, pageName, 'app'));
+    }
+    async writeAppPathsManifest() {
+        const appPathsManifest = this.mergePagesManifests(this.appPathsManifests.values());
+        const appPathsManifestPath = (0, _path.join)(this.distDir, 'server', _constants.APP_PATHS_MANIFEST);
+        (0, _requirecache.deleteCache)(appPathsManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(appPathsManifestPath, JSON.stringify(appPathsManifest, null, 2));
+    }
+    async writeWebpackStats() {
+        const webpackStats = this.mergeWebpackStats(this.webpackStats.values());
+        const path = (0, _path.join)(this.distDir, 'server', _constants.WEBPACK_STATS);
+        (0, _requirecache.deleteCache)(path);
+        await (0, _writeatomic.writeFileAtomic)(path, JSON.stringify(webpackStats, null, 2));
+    }
+    async loadBuildManifest(pageName, type) {
+        if (type === void 0) type = 'pages';
+        this.buildManifests.set((0, _entrykey.getEntryKey)(type, 'server', pageName), await readPartialManifest(this.distDir, _constants.BUILD_MANIFEST, pageName, type));
+    }
+    async loadWebpackStats(pageName, type) {
+        if (type === void 0) type = 'pages';
+        this.webpackStats.set((0, _entrykey.getEntryKey)(type, 'client', pageName), await readPartialManifest(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.name)) {
+                        chunks.set(chunk.name, 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 {
+            entrypoints,
+            assets: [
+                ...assets.values()
+            ],
+            chunks: [
+                ...chunks.values()
+            ],
+            modules: [
+                ...modules.values()
+            ]
+        };
+    }
+    mergeBuildManifests(manifests) {
+        const manifest = {
+            pages: {
+                '/_app': []
+            },
+            // Something in next.js depends on these to exist even for app dir rendering
+            devFiles: [],
+            ampDevFiles: [],
+            polyfillFiles: [],
+            lowPriorityFiles: [
+                "static/" + this.buildId + "/_ssgManifest.js",
+                "static/" + this.buildId + "/_buildManifest.js"
+            ],
+            rootMainFiles: [],
+            ampFirstPages: []
+        };
+        for (const m of manifests){
+            Object.assign(manifest.pages, m.pages);
+            if (m.rootMainFiles.length) manifest.rootMainFiles = m.rootMainFiles;
+            // polyfillFiles should always be the same, so we can overwrite instead of actually merging
+            if (m.polyfillFiles.length) manifest.polyfillFiles = m.polyfillFiles;
+        }
+        manifest.pages = sortObjectByKey(manifest.pages);
+        return manifest;
+    }
+    async writeBuildManifest(entrypoints, devRewrites, productionRewrites) {
+        var _devRewrites_beforeFiles, _devRewrites_afterFiles, _devRewrites_fallback;
+        const rewrites = productionRewrites != null ? productionRewrites : {
+            ...devRewrites,
+            beforeFiles: ((_devRewrites_beforeFiles = devRewrites == null ? void 0 : devRewrites.beforeFiles) != null ? _devRewrites_beforeFiles : []).map(_buildmanifestplugin.processRoute),
+            afterFiles: ((_devRewrites_afterFiles = devRewrites == null ? void 0 : devRewrites.afterFiles) != null ? _devRewrites_afterFiles : []).map(_buildmanifestplugin.processRoute),
+            fallback: ((_devRewrites_fallback = devRewrites == null ? void 0 : devRewrites.fallback) != null ? _devRewrites_fallback : []).map(_buildmanifestplugin.processRoute)
+        };
+        const buildManifest = this.mergeBuildManifests(this.buildManifests.values());
+        const buildManifestPath = (0, _path.join)(this.distDir, _constants.BUILD_MANIFEST);
+        const middlewareBuildManifestPath = (0, _path.join)(this.distDir, 'server', "" + _constants.MIDDLEWARE_BUILD_MANIFEST + ".js");
+        const interceptionRewriteManifestPath = (0, _path.join)(this.distDir, 'server', "" + _constants.INTERCEPTION_ROUTE_REWRITE_MANIFEST + ".js");
+        (0, _requirecache.deleteCache)(buildManifestPath);
+        (0, _requirecache.deleteCache)(middlewareBuildManifestPath);
+        (0, _requirecache.deleteCache)(interceptionRewriteManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(buildManifestPath, JSON.stringify(buildManifest, null, 2));
+        await (0, _writeatomic.writeFileAtomic)(middlewareBuildManifestPath, // we use globalThis here because middleware can be node
+        // which doesn't have "self"
+        "globalThis.__BUILD_MANIFEST=" + JSON.stringify(buildManifest) + ";");
+        const interceptionRewrites = JSON.stringify(rewrites.beforeFiles.filter(_generateinterceptionroutesrewrites.isInterceptionRouteRewrite));
+        await (0, _writeatomic.writeFileAtomic)(interceptionRewriteManifestPath, "self.__INTERCEPTION_ROUTE_REWRITE_MANIFEST=" + JSON.stringify(interceptionRewrites) + ";");
+        const pagesKeys = [
+            ...entrypoints.page.keys()
+        ];
+        if (entrypoints.global.app) {
+            pagesKeys.push('/_app');
+        }
+        if (entrypoints.global.error) {
+            pagesKeys.push('/_error');
+        }
+        const sortedPageKeys = (0, _utils.getSortedRoutes)(pagesKeys);
+        const content = {
+            __rewrites: (0, _buildmanifestplugin.normalizeRewritesForBuildManifest)(rewrites),
+            ...Object.fromEntries(sortedPageKeys.map((pathname)=>[
+                    pathname,
+                    [
+                        "static/chunks/pages" + (pathname === '/' ? '/index' : pathname) + ".js"
+                    ]
+                ])),
+            sortedPages: sortedPageKeys
+        };
+        const buildManifestJs = "self.__BUILD_MANIFEST = " + JSON.stringify(content) + ";self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()";
+        await (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, 'static', this.buildId, '_buildManifest.js'), buildManifestJs);
+        await (0, _writeatomic.writeFileAtomic)((0, _path.join)(this.distDir, 'static', this.buildId, '_ssgManifest.js'), _buildmanifestplugin.srcEmptySsgManifest);
+    }
+    async 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 = (0, _path.join)(this.distDir, 'static', this.buildId, "" + _constants.TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST);
+        (0, _requirecache.deleteCache)(clientMiddlewareManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(clientMiddlewareManifestPath, JSON.stringify(matchers, null, 2));
+    }
+    async writeFallbackBuildManifest() {
+        const fallbackBuildManifest = this.mergeBuildManifests([
+            this.buildManifests.get((0, _entrykey.getEntryKey)('pages', 'server', '_app')),
+            this.buildManifests.get((0, _entrykey.getEntryKey)('pages', 'server', '_error'))
+        ].filter(Boolean));
+        const fallbackBuildManifestPath = (0, _path.join)(this.distDir, "fallback-" + _constants.BUILD_MANIFEST);
+        (0, _requirecache.deleteCache)(fallbackBuildManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(fallbackBuildManifestPath, JSON.stringify(fallbackBuildManifest, null, 2));
+    }
+    async loadFontManifest(pageName, type) {
+        if (type === void 0) type = 'pages';
+        this.fontManifests.set((0, _entrykey.getEntryKey)(type, 'server', pageName), await readPartialManifest(this.distDir, "" + _constants.NEXT_FONT_MANIFEST + ".json", pageName, type));
+    }
+    mergeFontManifests(manifests) {
+        const manifest = {
+            app: {},
+            appUsingSizeAdjust: false,
+            pages: {},
+            pagesUsingSizeAdjust: false
+        };
+        for (const m of manifests){
+            Object.assign(manifest.app, m.app);
+            Object.assign(manifest.pages, m.pages);
+            manifest.appUsingSizeAdjust = manifest.appUsingSizeAdjust || m.appUsingSizeAdjust;
+            manifest.pagesUsingSizeAdjust = manifest.pagesUsingSizeAdjust || m.pagesUsingSizeAdjust;
+        }
+        manifest.app = sortObjectByKey(manifest.app);
+        manifest.pages = sortObjectByKey(manifest.pages);
+        return manifest;
+    }
+    async writeNextFontManifest() {
+        const fontManifest = this.mergeFontManifests(this.fontManifests.values());
+        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);
+        await (0, _writeatomic.writeFileAtomic)(fontManifestJsonPath, json);
+        await (0, _writeatomic.writeFileAtomic)(fontManifestJsPath, "self.__NEXT_FONT_MANIFEST=" + JSON.stringify(json));
+    }
+    async loadMiddlewareManifest(pageName, type) {
+        this.middlewareManifests.set((0, _entrykey.getEntryKey)(type === 'middleware' || type === 'instrumentation' ? 'root' : type, 'server', pageName), await readPartialManifest(this.distDir, _constants.MIDDLEWARE_MANIFEST, pageName, type));
+    }
+    getMiddlewareManifest(key) {
+        return this.middlewareManifests.get(key);
+    }
+    deleteMiddlewareManifest(key) {
+        return this.middlewareManifests.delete(key);
+    }
+    mergeMiddlewareManifests(manifests) {
+        const manifest = {
+            version: 3,
+            middleware: {},
+            sortedMiddleware: [],
+            functions: {}
+        };
+        let instrumentation = undefined;
+        for (const m of manifests){
+            Object.assign(manifest.functions, m.functions);
+            Object.assign(manifest.middleware, m.middleware);
+            if (m.instrumentation) {
+                instrumentation = m.instrumentation;
+            }
+        }
+        manifest.functions = sortObjectByKey(manifest.functions);
+        manifest.middleware = sortObjectByKey(manifest.middleware);
+        const updateFunctionDefinition = (fun)=>{
+            var _instrumentation_files;
+            return {
+                ...fun,
+                files: [
+                    ...(_instrumentation_files = instrumentation == null ? void 0 : instrumentation.files) != null ? _instrumentation_files : [],
+                    ...fun.files
+                ]
+            };
+        };
+        for (const key of Object.keys(manifest.middleware)){
+            const value = manifest.middleware[key];
+            manifest.middleware[key] = updateFunctionDefinition(value);
+        }
+        for (const key of Object.keys(manifest.functions)){
+            const value = manifest.functions[key];
+            manifest.functions[key] = updateFunctionDefinition(value);
+        }
+        for (const fun of Object.values(manifest.functions).concat(Object.values(manifest.middleware))){
+            for (const matcher of fun.matchers){
+                if (!matcher.regexp) {
+                    matcher.regexp = (0, _pathtoregexp.pathToRegexp)(matcher.originalSource, [], {
+                        delimiter: '/',
+                        sensitive: false,
+                        strict: true
+                    }).source.replaceAll('\\/', '/');
+                }
+            }
+        }
+        manifest.sortedMiddleware = Object.keys(manifest.middleware);
+        return manifest;
+    }
+    async writeMiddlewareManifest() {
+        const middlewareManifest = this.mergeMiddlewareManifests(this.middlewareManifests.values());
+        // Normalize regexes as it uses path-to-regexp
+        for(const key in middlewareManifest.middleware){
+            middlewareManifest.middleware[key].matchers.forEach((matcher)=>{
+                if (!matcher.regexp.startsWith('^')) {
+                    const parsedPage = (0, _trytoparsepath.tryToParsePath)(matcher.regexp);
+                    if (parsedPage.error || !parsedPage.regexStr) {
+                        throw Object.defineProperty(new Error("Invalid source: " + matcher.regexp), "__NEXT_ERROR_CODE", {
+                            value: "E442",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    matcher.regexp = parsedPage.regexStr;
+                }
+            });
+        }
+        const middlewareManifestPath = (0, _path.join)(this.distDir, 'server', _constants.MIDDLEWARE_MANIFEST);
+        (0, _requirecache.deleteCache)(middlewareManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(middlewareManifestPath, JSON.stringify(middlewareManifest, null, 2));
+    }
+    async loadPagesManifest(pageName) {
+        this.pagesManifests.set((0, _entrykey.getEntryKey)('pages', 'server', pageName), await readPartialManifest(this.distDir, _constants.PAGES_MANIFEST, pageName));
+    }
+    mergePagesManifests(manifests) {
+        const manifest = {};
+        for (const m of manifests){
+            Object.assign(manifest, m);
+        }
+        return sortObjectByKey(manifest);
+    }
+    async writePagesManifest() {
+        const pagesManifest = this.mergePagesManifests(this.pagesManifests.values());
+        const pagesManifestPath = (0, _path.join)(this.distDir, 'server', _constants.PAGES_MANIFEST);
+        (0, _requirecache.deleteCache)(pagesManifestPath);
+        await (0, _writeatomic.writeFileAtomic)(pagesManifestPath, JSON.stringify(pagesManifest, null, 2));
+    }
+    async writeManifests(param) {
+        let { devRewrites, productionRewrites, entrypoints } = param;
+        await this.writeActionManifest();
+        await this.writeAppBuildManifest();
+        await this.writeAppPathsManifest();
+        await this.writeBuildManifest(entrypoints, devRewrites, productionRewrites);
+        await this.writeFallbackBuildManifest();
+        await this.writeMiddlewareManifest();
+        await this.writeClientMiddlewareManifest();
+        await this.writeNextFontManifest();
+        await this.writePagesManifest();
+        if (process.env.TURBOPACK_STATS != null) {
+            await this.writeWebpackStats();
+        }
+    }
+    constructor({ distDir, buildId, encryptionKey }){
+        this.actionManifests = new Map();
+        this.appBuildManifests = new Map();
+        this.appPathsManifests = new Map();
+        this.buildManifests = new Map();
+        this.fontManifests = new Map();
+        this.middlewareManifests = new Map();
+        this.pagesManifests = new Map();
+        this.webpackStats = new Map();
+        this.distDir = distDir;
+        this.buildId = buildId;
+        this.encryptionKey = encryptionKey;
+    }
+}
+function sortObjectByKey(obj) {
+    return Object.keys(obj).sort().reduce((acc, key)=>{
+        acc[key] = obj[key];
+        return acc;
+    }, {});
+}
+
+//# sourceMappingURL=manifest-loader.js.map

node_modules/next/dist/shared/lib/turbopack/utils.d.ts

@@ -0,0 +1,29 @@
+import type { Issue, StyledString, TurbopackResult } from '../../../build/swc/types';
+import type { EntryKey } from './entry-key';
+import type { NextConfigComplete } from '../../../server/config-shared';
+type IssueKey = `${Issue['severity']}-${Issue['filePath']}-${string}-${string}`;
+export type IssuesMap = Map<IssueKey, Issue>;
+export type EntryIssuesMap = Map<EntryKey, IssuesMap>;
+export type TopLevelIssuesMap = IssuesMap;
+export declare class ModuleBuildError extends Error {
+    name: string;
+}
+export declare class TurbopackInternalError extends Error {
+    name: string;
+    constructor(cause: Error);
+}
+/**
+ * Thin stopgap workaround layer to mimic existing wellknown-errors-plugin in webpack's build
+ * to emit certain type of errors into cli.
+ */
+export declare function isWellKnownError(issue: Issue): boolean;
+export declare function getIssueKey(issue: Issue): IssueKey;
+export declare function getTurbopackJsConfig(dir: string, nextConfig: NextConfigComplete): Promise<{
+    compilerOptions: Record<string, any>;
+}>;
+export declare function processIssues(currentEntryIssues: EntryIssuesMap, key: EntryKey, result: TurbopackResult, throwIssue: boolean, logErrors: boolean): void;
+export declare function formatIssue(issue: Issue): string;
+export declare function isRelevantWarning(issue: Issue): boolean;
+export declare function renderStyledStringToErrorAnsi(string: StyledString): string;
+export declare function isPersistentCachingEnabled(config: NextConfigComplete): boolean;
+export {};

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

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ModuleBuildError: null,
+    TurbopackInternalError: null,
+    formatIssue: null,
+    getIssueKey: null,
+    getTurbopackJsConfig: null,
+    isPersistentCachingEnabled: null,
+    isRelevantWarning: null,
+    isWellKnownError: null,
+    processIssues: null,
+    renderStyledStringToErrorAnsi: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ModuleBuildError: function() {
+        return ModuleBuildError;
+    },
+    TurbopackInternalError: function() {
+        return TurbopackInternalError;
+    },
+    formatIssue: function() {
+        return formatIssue;
+    },
+    getIssueKey: function() {
+        return getIssueKey;
+    },
+    getTurbopackJsConfig: function() {
+        return getTurbopackJsConfig;
+    },
+    isPersistentCachingEnabled: function() {
+        return isPersistentCachingEnabled;
+    },
+    isRelevantWarning: function() {
+        return isRelevantWarning;
+    },
+    isWellKnownError: function() {
+        return isWellKnownError;
+    },
+    processIssues: function() {
+        return processIssues;
+    },
+    renderStyledStringToErrorAnsi: function() {
+        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 _loadjsconfig = /*#__PURE__*/ _interop_require_default._(require("../../../build/load-jsconfig"));
+class ModuleBuildError extends Error {
+    constructor(...args){
+        super(...args), this.name = 'ModuleBuildError';
+    }
+}
+class TurbopackInternalError extends Error {
+    constructor(cause){
+        super(cause.message), this.name = 'TurbopackInternalError';
+        this.stack = cause.stack;
+    }
+}
+function isWellKnownError(issue) {
+    const { title } = issue;
+    const formattedTitle = renderStyledStringToErrorAnsi(title);
+    // TODO: add more well known errors
+    if (formattedTitle.includes('Module not found') || formattedTitle.includes('Unknown module type')) {
+        return true;
+    }
+    return false;
+}
+function getIssueKey(issue) {
+    return issue.severity + "-" + issue.filePath + "-" + JSON.stringify(issue.title) + "-" + JSON.stringify(issue.description);
+}
+async function getTurbopackJsConfig(dir, nextConfig) {
+    const { jsConfig } = await (0, _loadjsconfig.default)(dir, nextConfig);
+    return jsConfig != null ? jsConfig : {
+        compilerOptions: {}
+    };
+}
+function processIssues(currentEntryIssues, key, result, throwIssue, logErrors) {
+    const newIssues = new Map();
+    currentEntryIssues.set(key, newIssues);
+    const relevantIssues = new Set();
+    for (const issue of result.issues){
+        if (issue.severity !== 'error' && issue.severity !== 'fatal' && issue.severity !== 'warning') continue;
+        const issueKey = getIssueKey(issue);
+        newIssues.set(issueKey, issue);
+        if (issue.severity !== 'warning') {
+            if (throwIssue) {
+                const formatted = formatIssue(issue);
+                relevantIssues.add(formatted);
+            } else if (logErrors && isWellKnownError(issue)) {
+                const formatted = formatIssue(issue);
+                _log.error(formatted);
+            }
+        }
+    }
+    if (relevantIssues.size && throwIssue) {
+        throw Object.defineProperty(new ModuleBuildError([
+            ...relevantIssues
+        ].join('\n\n')), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+function formatIssue(issue) {
+    const { filePath, title, description, source } = issue;
+    let { documentationLink } = issue;
+    let formattedTitle = renderStyledStringToErrorAnsi(title).replace(/\n/g, '\n    ');
+    // TODO: Use error codes to identify these
+    // TODO: Generalize adapting Turbopack errors to Next.js errors
+    if (formattedTitle.includes('Module not found')) {
+        // For compatiblity with webpack
+        // TODO: include columns in webpack errors.
+        documentationLink = 'https://nextjs.org/docs/messages/module-not-found';
+    }
+    let formattedFilePath = filePath.replace('[project]/', './').replaceAll('/./', '/').replace('\\\\?\\', '');
+    let message = '';
+    if (source && source.range) {
+        const { start } = source.range;
+        message = formattedFilePath + ":" + (start.line + 1) + ":" + (start.column + 1) + "\n" + formattedTitle;
+    } else if (formattedFilePath) {
+        message = formattedFilePath + "\n" + formattedTitle;
+    } else {
+        message = formattedTitle;
+    }
+    message += '\n';
+    if ((source == null ? void 0 : 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 (description) {
+        message += renderStyledStringToErrorAnsi(description) + '\n\n';
+    }
+    // TODO: make it possible to enable this for debugging, but not in tests.
+    // if (detail) {
+    //   message += renderStyledStringToErrorAnsi(detail) + '\n\n'
+    // }
+    // TODO: Include a trace from the issue.
+    if (documentationLink) {
+        message += documentationLink + '\n\n';
+    }
+    return message;
+}
+function isRelevantWarning(issue) {
+    return issue.severity === 'warning' && !isNodeModulesIssue(issue);
+}
+function isNodeModulesIssue(issue) {
+    if (issue.severity === 'warning' && issue.stage === 'config') {
+        // Override for the externalize issue
+        // `Package foo (serverExternalPackages or default list) can't be external`
+        if (renderStyledStringToErrorAnsi(issue.title).includes("can't be external")) {
+            return false;
+        }
+    }
+    return issue.severity === 'warning' && (issue.filePath.match(/^(?:.*[\\/])?node_modules(?:[\\/].*)?$/) !== null || // Ignore Next.js itself when running next directly in the monorepo where it is not inside
+    // node_modules anyway.
+    // TODO(mischnic) prevent matches when this is published to npm
+    issue.filePath.startsWith('[project]/packages/next/'));
+}
+function renderStyledStringToErrorAnsi(string) {
+    function decodeMagicIdentifiers(str) {
+        return str.replaceAll(_magicidentifier.MAGIC_IDENTIFIER_REGEX, (ident)=>{
+            try {
+                return (0, _picocolors.magenta)("{" + (0, _magicidentifier.decodeMagicIdentifier)(ident) + "}");
+            } catch (e) {
+                return (0, _picocolors.magenta)("{" + ident + " (decoding failed: " + e + ")}");
+            }
+        });
+    }
+    switch(string.type){
+        case 'text':
+            return decodeMagicIdentifiers(string.value);
+        case 'strong':
+            return (0, _picocolors.bold)((0, _picocolors.red)(decodeMagicIdentifiers(string.value)));
+        case 'code':
+            return (0, _picocolors.green)(decodeMagicIdentifiers(string.value));
+        case 'line':
+            return string.value.map(renderStyledStringToErrorAnsi).join('');
+        case 'stack':
+            return string.value.map(renderStyledStringToErrorAnsi).join('\n');
+        default:
+            throw Object.defineProperty(new Error('Unknown StyledString type', string), "__NEXT_ERROR_CODE", {
+                value: "E138",
+                enumerable: false,
+                configurable: true
+            });
+    }
+}
+function isPersistentCachingEnabled(config) {
+    var _config_experimental_turbo;
+    return ((_config_experimental_turbo = config.experimental.turbo) == null ? void 0 : _config_experimental_turbo.unstablePersistentCaching) || false;
+}
+
+//# sourceMappingURL=utils.js.map