failproofai 1.0.11-beta.1 → 1.0.11-beta.2

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

@@ -27,10 +27,13 @@ const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compile
 const _lrucache = require("../lru-cache");
 const _loadcustomroutes = /*#__PURE__*/ _interop_require_default(require("../../../lib/load-custom-routes"));
 const _redirectstatus = require("../../../lib/redirect-status");
+const _isapiroute = require("../../../lib/is-api-route");
+const _isapppageroute = require("../../../lib/is-app-page-route");
+const _isapprouteroute = require("../../../lib/is-app-route-route");
 const _fileexists = require("../../../lib/file-exists");
 const _recursivereaddir = require("../../../lib/recursive-readdir");
+const _builddataroute = require("./build-data-route");
 const _utils = require("../../../shared/lib/router/utils");
-const _escaperegexp = require("../../../shared/lib/escape-regexp");
 const _pathmatch = require("../../../shared/lib/router/utils/path-match");
 const _routeregex = require("../../../shared/lib/router/utils/route-regex");
 const _routematcher = require("../../../shared/lib/router/utils/route-matcher");
@@ -38,12 +41,19 @@ const _pathhasprefix = require("../../../shared/lib/router/utils/path-has-prefix
 const _normalizelocalepath = require("../../../shared/lib/i18n/normalize-locale-path");
 const _removepathprefix = require("../../../shared/lib/router/utils/remove-path-prefix");
 const _middlewareroutematcher = require("../../../shared/lib/router/utils/middleware-route-matcher");
+const _utils1 = require("../../../shared/lib/utils");
 const _constants = require("../../../shared/lib/constants");
 const _normalizepathsep = require("../../../shared/lib/page-path/normalize-path-sep");
 const _getmetadataroute = require("../../../lib/metadata/get-metadata-route");
 const _rsc = require("../../normalizers/request/rsc");
 const _encodeuripath = require("../../../shared/lib/encode-uri-path");
 const _ismetadataroute = require("../../../lib/metadata/is-metadata-route");
+const _pages = require("../../normalizers/built/pages");
+const _app = require("../../normalizers/built/app");
+const _routekind = require("../../route-kind");
+const _apppageroutedefinition = require("../../route-definitions/app-page-route-definition");
+const _apppaths = require("../../../shared/lib/router/utils/app-paths");
+const _normalizecatchallroutes = require("./normalize-catchall-routes");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -91,6 +101,36 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 const debug = (0, _debug.default)('next:router-server:filesystem');
+const buildFilesystemDynamicRoute = (page)=>{
+    const routeRegex = (0, _routeregex.getNamedRouteRegex)(page, {
+        prefixRouteKeys: true,
+        includePrefix: true,
+        includeSuffix: true
+    });
+    return {
+        regex: routeRegex.re.toString(),
+        namedRegex: routeRegex.namedRegex,
+        routeKeys: routeRegex.routeKeys,
+        match: (0, _routematcher.getRouteMatcher)(routeRegex),
+        page
+    };
+};
+const sortDynamicRoutes = (routes)=>{
+    const references = new Map();
+    const pages = [];
+    for (const route of routes){
+        const existing = references.get(route.page);
+        if (existing) {
+            existing.push(route);
+        } else {
+            references.set(route.page, [
+                route
+            ]);
+            pages.push(route.page);
+        }
+    }
+    return (0, _utils.getSortedRoutes)(pages).flatMap((page)=>references.get(page));
+};
 const buildCustomRoute = (type, item, basePath, caseSensitive)=>{
     const restrictedRedirectPaths = [
         '/_next'
@@ -161,6 +201,12 @@ async function setupFsCheck(opts) {
     // /icon.png -> .../app/icon.png
     const staticMetadataFiles = new Map();
     let dynamicRoutes = [];
+    // Page and app outputs need route metadata for compilation and rendering.
+    // Static assets remain plain filesystem matches.
+    const routeDefinitions = {
+        appFile: new Map(),
+        pageFile: new Map()
+    };
     let middlewareMatcher = ()=>false;
     const distDir = _path.default.join(opts.dir, opts.config.distDir);
     const publicFolderPath = _path.default.join(opts.dir, 'public');
@@ -178,6 +224,32 @@ async function setupFsCheck(opts) {
     };
     let buildId = 'development';
     let previewProps;
+    const setRouteDefinition = (type, pathname, definition)=>{
+        const definitions = routeDefinitions[type].get(pathname);
+        if (definitions) {
+            definitions.push(definition);
+        } else {
+            routeDefinitions[type].set(pathname, [
+                definition
+            ]);
+        }
+    };
+    const getRouteDefinition = (type, itemPath, locale)=>{
+        const definitions = routeDefinitions[type].get(itemPath);
+        if (!(definitions == null ? void 0 : definitions.length)) return undefined;
+        if (type === 'pageFile') {
+            return definitions.find((definition)=>{
+                var _definition_i18n;
+                return ((_definition_i18n = definition.i18n) == null ? void 0 : _definition_i18n.locale) === locale;
+            }) ?? definitions.find((definition)=>{
+                var _definition_i18n;
+                return !((_definition_i18n = definition.i18n) == null ? void 0 : _definition_i18n.locale);
+            }) ?? definitions[0];
+        }
+        return definitions[0];
+    };
+    const pagesNormalizers = new _pages.PagesNormalizers(distDir);
+    const appNormalizers = new _app.AppNormalizers(distDir);
     if (!opts.dev) {
         var _middlewareManifest_middleware_, _middlewareManifest_middleware;
         const buildIdPath = _path.default.join(opts.dir, opts.config.distDir, _constants.BUILD_ID_FILE);
@@ -185,11 +257,7 @@ async function setupFsCheck(opts) {
             buildId = await _promises.default.readFile(buildIdPath, 'utf8');
         } catch (err) {
             if (err.code !== 'ENOENT') throw err;
-            throw Object.defineProperty(new Error(`Could not find a production build in the '${opts.config.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id`), "__NEXT_ERROR_CODE", {
-                value: "E427",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Could not find a production build in the '${opts.config.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id`);
         }
         try {
             for (const file of (await (0, _recursivereaddir.recursiveReadDir)(publicFolderPath))){
@@ -221,29 +289,93 @@ async function setupFsCheck(opts) {
             if (opts.config.output !== 'standalone') throw err;
         }
         const routesManifestPath = _path.default.join(distDir, _constants.ROUTES_MANIFEST);
-        const prerenderManifestPath = _path.default.join(distDir, _constants.PRERENDER_MANIFEST);
+        const previewPropsManifestPath = _path.default.join(distDir, 'server', _constants.PREVIEW_PROPS_MANIFEST);
         const middlewareManifestPath = _path.default.join(distDir, 'server', _constants.MIDDLEWARE_MANIFEST);
         const functionsConfigManifestPath = _path.default.join(distDir, 'server', _constants.FUNCTIONS_CONFIG_MANIFEST);
         const pagesManifestPath = _path.default.join(distDir, 'server', _constants.PAGES_MANIFEST);
+        const appPathsManifestPath = _path.default.join(distDir, 'server', _constants.APP_PATHS_MANIFEST);
         const appRoutesManifestPath = _path.default.join(distDir, _constants.APP_PATH_ROUTES_MANIFEST);
         const routesManifest = JSON.parse(await _promises.default.readFile(routesManifestPath, 'utf8'));
-        previewProps = JSON.parse(await _promises.default.readFile(prerenderManifestPath, 'utf8')).preview;
+        previewProps = JSON.parse(await _promises.default.readFile(previewPropsManifestPath, 'utf8'));
         const middlewareManifest = JSON.parse(await _promises.default.readFile(middlewareManifestPath, 'utf8').catch(()=>'{}'));
         const functionsConfigManifest = JSON.parse(await _promises.default.readFile(functionsConfigManifestPath, 'utf8').catch(()=>'{}'));
         const pagesManifest = JSON.parse(await _promises.default.readFile(pagesManifestPath, 'utf8'));
+        const appPathsManifest = JSON.parse(await _promises.default.readFile(appPathsManifestPath, 'utf8').catch(()=>'{}'));
         const appRoutesManifest = JSON.parse(await _promises.default.readFile(appRoutesManifestPath, 'utf8').catch(()=>'{}'));
+        const appDynamicRoutes = [];
+        const appDynamicRoutePathnames = new Set();
+        const addAppDynamicRoute = (pathname)=>{
+            if (!(0, _utils.isDynamicRoute)(pathname) || appDynamicRoutePathnames.has(pathname)) {
+                return;
+            }
+            appDynamicRoutePathnames.add(pathname);
+            appDynamicRoutes.push(buildFilesystemDynamicRoute(pathname));
+        };
         for (const key of Object.keys(pagesManifest)){
+            const localeResult = opts.config.i18n ? (0, _normalizelocalepath.normalizeLocalePath)(key, opts.config.i18n.locales) : {
+                pathname: key,
+                detectedLocale: undefined
+            };
             // ensure the non-locale version is in the set
             if (opts.config.i18n) {
-                pageFiles.add((0, _normalizelocalepath.normalizeLocalePath)(key, opts.config.i18n.locales).pathname);
+                pageFiles.add(localeResult.pathname);
             } else {
                 pageFiles.add(key);
             }
+            if (!(0, _isapiroute.isAPIRoute)(key) && _constants.BLOCKED_PAGES.includes(localeResult.pathname)) {
+                continue;
+            }
+            setRouteDefinition('pageFile', localeResult.pathname, {
+                kind: (0, _isapiroute.isAPIRoute)(key) ? _routekind.RouteKind.PAGES_API : _routekind.RouteKind.PAGES,
+                pathname: localeResult.pathname,
+                page: key,
+                bundlePath: pagesNormalizers.bundlePath.normalize(key),
+                filename: pagesNormalizers.filename.normalize(pagesManifest[key]),
+                ...opts.config.i18n ? {
+                    i18n: {
+                        locale: localeResult.detectedLocale
+                    }
+                } : undefined
+            });
         }
         for (const key of Object.keys(appRoutesManifest)){
             appFiles.add(appRoutesManifest[key]);
         }
-        const escapedBuildId = (0, _escaperegexp.escapeStringRegexp)(buildId);
+        const appPages = Object.keys(appPathsManifest).filter((page)=>(0, _isapppageroute.isAppPageRoute)(page));
+        const allAppPaths = {};
+        for (const page of appPages){
+            const pathname = appNormalizers.pathname.normalize(page);
+            if (pathname in allAppPaths) allAppPaths[pathname].push(page);
+            else allAppPaths[pathname] = [
+                page
+            ];
+        }
+        (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(allAppPaths, appNormalizers.pathname);
+        for (const [pathname, appPaths] of Object.entries(allAppPaths)){
+            // Keep manifest order aligned with the module packaged for this route.
+            const page = (0, _apppaths.selectAppPageEntry)(pathname, appPaths, (appPath)=>appNormalizers.pathname.normalize(appPath));
+            setRouteDefinition('appFile', pathname, {
+                kind: _routekind.RouteKind.APP_PAGE,
+                pathname,
+                page,
+                bundlePath: appNormalizers.bundlePath.normalize(page),
+                filename: appNormalizers.filename.normalize(appPathsManifest[page]),
+                appPaths
+            });
+            addAppDynamicRoute(pathname);
+        }
+        const appRouteHandlers = Object.keys(appPathsManifest).filter((page)=>(0, _isapprouteroute.isAppRouteRoute)(page));
+        for (const page of appRouteHandlers){
+            const pathname = appNormalizers.pathname.normalize(page);
+            setRouteDefinition('appFile', pathname, {
+                kind: _routekind.RouteKind.APP_ROUTE,
+                pathname,
+                page,
+                bundlePath: appNormalizers.bundlePath.normalize(page),
+                filename: appNormalizers.filename.normalize(appPathsManifest[page])
+            });
+            addAppDynamicRoute(pathname);
+        }
         for (const route of routesManifest.dataRoutes){
             if ((0, _utils.isDynamicRoute)(route.page)) {
                 const routeRegex = (0, _routeregex.getNamedRouteRegex)(route.page, {
@@ -257,24 +389,28 @@ async function setupFsCheck(opts) {
                     match: (0, _routematcher.getRouteMatcher)({
                         // TODO: fix this in the manifest itself, must also be fixed in
                         // upstream builder that relies on this
-                        re: opts.config.i18n ? new RegExp(route.dataRouteRegex.replace(`/${escapedBuildId}/`, `/${escapedBuildId}/(?<nextLocale>[^/]+?)/`)) : new RegExp(route.dataRouteRegex),
+                        re: opts.config.i18n ? new RegExp((0, _builddataroute.addLocalePrefixToDataRouteRegex)(route.dataRouteRegex, buildId)) : new RegExp(route.dataRouteRegex),
                         groups: routeRegex.groups
                     })
                 });
             }
             nextDataRoutes.add(route.page);
         }
+        const filesystemDynamicRoutes = [
+            ...appDynamicRoutes
+        ];
         for (const route of routesManifest.dynamicRoutes){
             // If a route is marked as skipInternalRouting, it's not for the internal
             // router, and instead has been added to support external routers.
             if (route.skipInternalRouting) {
                 continue;
             }
-            dynamicRoutes.push({
+            filesystemDynamicRoutes.push({
                 ...route,
-                match: (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(route.page))
+                ...buildFilesystemDynamicRoute(route.page)
             });
         }
+        dynamicRoutes.push(...sortDynamicRoutes(filesystemDynamicRoutes));
         if ((_middlewareManifest_middleware = middlewareManifest.middleware) == null ? void 0 : (_middlewareManifest_middleware_ = _middlewareManifest_middleware['/']) == null ? void 0 : _middlewareManifest_middleware_.matchers) {
             var _middlewareManifest_middleware_1, _middlewareManifest_middleware1;
             middlewareMatcher = (0, _middlewareroutematcher.getMiddlewareRouteMatcher)((_middlewareManifest_middleware1 = middlewareManifest.middleware) == null ? void 0 : (_middlewareManifest_middleware_1 = _middlewareManifest_middleware1['/']) == null ? void 0 : _middlewareManifest_middleware_1.matchers);
@@ -355,6 +491,13 @@ async function setupFsCheck(opts) {
         staticMetadataFiles,
         dynamicRoutes,
         nextDataRoutes,
+        setRouteDefinitions (type, definitions) {
+            routeDefinitions[type].clear();
+            for (const definition of definitions){
+                setRouteDefinition(type, definition.pathname, definition);
+            }
+        },
+        getRouteDefinition,
         exportPathMapRoutes: undefined,
         devVirtualFsItems: new Set(),
         previewProps,
@@ -362,7 +505,7 @@ async function setupFsCheck(opts) {
         ensureCallback (fn) {
             ensureFn = fn;
         },
-        async getItem (itemPath) {
+        async getItem (itemPath, requestPath) {
             const originalItemPath = itemPath;
             const itemKey = originalItemPath;
             const lruResult = getItemsLru == null ? void 0 : getItemsLru.get(itemKey);
@@ -403,7 +546,8 @@ async function setupFsCheck(opts) {
                 const fsPath = staticMetadataFiles.get(itemPath);
                 if (fsPath) {
                     return {
-                        // "nextStaticFolder" sets Cache-Control "no-store" on dev.
+                        // "nextStaticFolder" sets Cache-Control
+                        // "no-cache, must-revalidate" on dev.
                         type: 'nextStaticFolder',
                         fsPath,
                         itemPath: fsPath
@@ -440,12 +584,12 @@ async function setupFsCheck(opts) {
                 let locale;
                 let curItemPath = itemPath;
                 let curDecodedItemPath = decodedItemPath;
-                const isDynamicOutput = type === 'pageFile' || type === 'appFile';
+                const isPageOrAppFile = type === 'pageFile' || type === 'appFile';
                 if (i18n) {
                     var _i18n_domains;
                     const localeResult = handleLocale(itemPath, // legacy behavior allows visiting static assets under
                     // default locale but no other locale
-                    isDynamicOutput ? undefined : [
+                    isPageOrAppFile ? undefined : [
                         i18n == null ? void 0 : i18n.defaultLocale,
                         // default locales from domains need to be matched too
                         ...((_i18n_domains = i18n.domains) == null ? void 0 : _i18n_domains.map((item)=>item.defaultLocale)) || []
@@ -484,6 +628,9 @@ async function setupFsCheck(opts) {
                         curDecodedItemPath = decodeURIComponent(curItemPath);
                     } catch  {}
                 }
+                // Only page and app outputs participate in route rendering. Public,
+                // static, image, and virtual outputs are served as filesystem assets.
+                const route = isPageOrAppFile ? getRouteDefinition(type, curItemPath, locale) : undefined;
                 let matchedItem = items.has(curItemPath);
                 // check decoded variant as well
                 if (!matchedItem && !opts.dev) {
@@ -561,28 +708,59 @@ async function setupFsCheck(opts) {
                                     continue;
                                 }
                             }
-                        } else if (type === 'pageFile' || type === 'appFile') {
-                            const isAppFile = type === 'appFile';
-                            // Attempt to ensure the page/app file is compiled and ready
-                            if (ensureFn) {
-                                const ensureItemPath = isAppFile ? (0, _getmetadataroute.normalizeMetadataRoute)(curItemPath) : curItemPath;
-                                try {
-                                    await ensureFn({
-                                        type,
-                                        itemPath: ensureItemPath
-                                    });
-                                } catch (error) {
+                        } else if (!isPageOrAppFile) {
+                            continue;
+                        }
+                    }
+                    let error;
+                    if (opts.dev && isPageOrAppFile) {
+                        if (!route) {
+                            continue;
+                        }
+                        const isAppFile = type === 'appFile';
+                        // Attempt to ensure the page/app file is compiled and ready.
+                        if (ensureFn) {
+                            const ensureItemPath = isAppFile ? (0, _getmetadataroute.normalizeMetadataRoute)(curItemPath) : curItemPath;
+                            try {
+                                await ensureFn({
+                                    type,
+                                    itemPath: ensureItemPath,
+                                    route,
+                                    requestPath
+                                });
+                            } catch (err) {
+                                // A disappeared route is not a match. Compilation errors still
+                                // belong to this route and must render as a 500 downstream.
+                                if (err instanceof _utils1.PageNotFoundError) {
                                     continue;
                                 }
+                                error = err instanceof Error ? err : new Error(String(err));
                             }
-                        } else {
-                            continue;
                         }
                     }
                     // i18n locales aren't matched for app dir
                     if (type === 'appFile' && locale && locale !== (i18n == null ? void 0 : i18n.defaultLocale)) {
                         continue;
                     }
+                    if (isPageOrAppFile && !route && !matchedItem) {
+                        continue;
+                    }
+                    let params;
+                    if (route && (0, _apppageroutedefinition.isAppPageRouteDefinition)(route)) {
+                        // Parallel app routes can contribute multiple dynamic app paths
+                        // to one pathname. Preserve the params from the matching path.
+                        for (const appPath of route.appPaths){
+                            const routePathname = appNormalizers.pathname.normalize(appPath);
+                            if (!(0, _utils.isDynamicRoute)(routePathname)) {
+                                continue;
+                            }
+                            const routeParams = (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(routePathname))(curItemPath);
+                            if (routeParams) {
+                                params = routeParams;
+                                break;
+                            }
+                        }
+                    }
                     const itemResult = {
                         type,
                         fsPath,
@@ -590,7 +768,10 @@ async function setupFsCheck(opts) {
                         itemsRoot,
                         // itemPath is usually a slice of the request URL too; keep a
                         // flat copy so the cached value doesn't retain the full URL.
-                        itemPath: flatKeyCopy(curItemPath)
+                        itemPath: flatKeyCopy(curItemPath),
+                        route,
+                        params,
+                        error
                     };
                     getItemsLru == null ? void 0 : getItemsLru.set(flatKeyCopy(itemKey), itemResult);
                     return itemResult;

package/.next/standalone/node_modules/next/dist/server/lib/router-utils/instrumentation-globals.external.js

@@ -29,23 +29,61 @@ const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../lib/is
 const _constants = require("../../../lib/constants");
 const _interopdefault = require("../../../lib/interop-default");
 const _instrumentationnodeextensions = require("./instrumentation-node-extensions");
+const _tracer = require("../trace/tracer");
+const _constants1 = require("../trace/constants");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let cachedInstrumentationModule;
+let instrumentationModuleLoadTiming;
+function getInstrumentationTimestamp() {
+    // Date.now() is treated as synchronous I/O while Cache Components render.
+    return performance.timeOrigin + performance.now();
+}
+function traceBackdatedInstrumentationSpan(type, spanName, { startTime, endTime, error }) {
+    (0, _tracer.getTracer)().trace(type, {
+        spanName,
+        startTime,
+        endTime
+    }, error === undefined ? ()=>undefined : (span)=>{
+        span == null ? void 0 : span.recordException(error);
+        if ((0, _iserror.default)(error)) {
+            span == null ? void 0 : span.setAttribute('error.type', error.name);
+        }
+        span == null ? void 0 : span.setStatus({
+            code: _tracer.SpanStatusCode.ERROR,
+            message: (0, _iserror.default)(error) ? error.message : undefined
+        });
+    });
+}
+function traceInstrumentationModuleLoad() {
+    if (!instrumentationModuleLoadTiming) return;
+    const timing = instrumentationModuleLoadTiming;
+    instrumentationModuleLoadTiming = undefined;
+    traceBackdatedInstrumentationSpan(_constants1.InstrumentationSpan.loadModule, 'load instrumentation module', timing);
+}
 async function getInstrumentationModule(projectDir, distDir) {
     if (cachedInstrumentationModule) {
         return cachedInstrumentationModule;
     }
+    const startTime = getInstrumentationTimestamp();
+    let error;
     try {
         cachedInstrumentationModule = (0, _interopdefault.interopDefault)(await require(_nodepath.default.join(projectDir, distDir, 'server', `${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`)));
         return cachedInstrumentationModule;
     } catch (err) {
         if ((0, _iserror.default)(err) && err.code !== 'ENOENT' && err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+            error = err;
             throw err;
         }
+    } finally{
+        instrumentationModuleLoadTiming ??= {
+            startTime,
+            endTime: getInstrumentationTimestamp(),
+            error
+        };
     }
 }
 let instrumentationModulePromise = null;
@@ -57,15 +95,37 @@ async function registerInstrumentation(projectDir, distDir) {
     if (!instrumentationModulePromise) {
         instrumentationModulePromise = getInstrumentationModule(projectDir, distDir);
     }
-    const instrumentation = await instrumentationModulePromise;
+    let instrumentation;
+    try {
+        instrumentation = await instrumentationModulePromise;
+    } catch (err) {
+        // A load error is only exportable when a provider was already installed.
+        traceInstrumentationModuleLoad();
+        throw err;
+    }
     if (instrumentation == null ? void 0 : instrumentation.register) {
+        const startTime = getInstrumentationTimestamp();
+        let error;
         try {
             await instrumentation.register();
             (0, _instrumentationnodeextensions.afterRegistration)();
         } catch (err) {
+            error = err;
             err.message = `An error occurred while loading instrumentation hook: ${err.message}`;
             throw err;
+        } finally{
+            const endTime = getInstrumentationTimestamp();
+            // register() commonly installs the provider, so emit both lifecycle
+            // spans afterward with their original timestamps.
+            traceInstrumentationModuleLoad();
+            traceBackdatedInstrumentationSpan(_constants1.InstrumentationSpan.register, 'register instrumentation', {
+                startTime,
+                endTime,
+                error
+            });
         }
+    } else {
+        traceInstrumentationModuleLoad();
     }
 }
 async function instrumentationOnRequestError(projectDir, distDir, ...args) {

package/.next/standalone/node_modules/next/dist/server/lib/router-utils/instrumentation-node-extensions.js

@@ -16,11 +16,7 @@ const _invarianterror = require("../../../shared/lib/invariant-error");
 const _clientandserverreferences = require("../../../lib/client-and-server-references");
 function afterRegistration() {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Node.js instrumentation extensions should not be loaded in the Edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E775",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Node.js instrumentation extensions should not be loaded in the Edge runtime.');
     }
     extendTracerProviderForCacheComponents();
 }