failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/shared/lib/magic-identifier.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MAGIC_IDENTIFIER_REGEX: null,
+    decodeMagicIdentifier: null,
+    deobfuscateModuleId: null,
+    deobfuscateText: null,
+    deobfuscateTextParts: null,
+    removeFreeCallWrapper: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MAGIC_IDENTIFIER_REGEX: function() {
+        return MAGIC_IDENTIFIER_REGEX;
+    },
+    decodeMagicIdentifier: function() {
+        return decodeMagicIdentifier;
+    },
+    deobfuscateModuleId: function() {
+        return deobfuscateModuleId;
+    },
+    deobfuscateText: function() {
+        return deobfuscateText;
+    },
+    deobfuscateTextParts: function() {
+        return deobfuscateTextParts;
+    },
+    removeFreeCallWrapper: function() {
+        return removeFreeCallWrapper;
+    }
+});
+function decodeHex(hexStr) {
+    if (hexStr.trim() === '') {
+        throw new Error("can't decode empty hex");
+    }
+    const num = parseInt(hexStr, 16);
+    if (isNaN(num)) {
+        throw new Error(`invalid hex: \`${hexStr}\``);
+    }
+    return String.fromCodePoint(num);
+}
+const DECODE_REGEX = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+function decodeMagicIdentifier(identifier) {
+    const matches = identifier.match(DECODE_REGEX);
+    if (!matches) {
+        return identifier;
+    }
+    const inner = matches[1];
+    let output = '';
+    let mode = 0;
+    let buffer = '';
+    for(let i = 0; i < inner.length; i++){
+        const char = inner[i];
+        if (mode === 0) {
+            if (char === '_') {
+                mode = 1;
+            } else if (char === '$') {
+                mode = 2;
+            } else {
+                output += char;
+            }
+        } else if (mode === 1) {
+            if (char === '_') {
+                output += ' ';
+                mode = 0;
+            } else if (char === '$') {
+                output += '_';
+                mode = 2;
+            } else {
+                output += char;
+                mode = 0;
+            }
+        } else if (mode === 2) {
+            if (buffer.length === 2) {
+                output += decodeHex(buffer);
+                buffer = '';
+            }
+            if (char === '_') {
+                if (buffer !== '') {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 3;
+            } else if (char === '$') {
+                if (buffer !== '') {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 0;
+            } else {
+                buffer += char;
+            }
+        } else if (mode === 3) {
+            if (char === '_') {
+                throw new Error(`invalid hex: \`${buffer + char}\``);
+            } else if (char === '$') {
+                output += decodeHex(buffer);
+                buffer = '';
+                mode = 0;
+            } else {
+                buffer += char;
+            }
+        }
+    }
+    return output;
+}
+const MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;
+function deobfuscateModuleId(moduleId) {
+    return moduleId// Replace [project] with .
+    .replace(/\[project\]/g, '.')// Remove content in square brackets (e.g. [app-rsc])
+    .replace(/\s\[([^\]]*)\]/g, '')// Remove content in parentheses (e.g. (ecmascript))
+    .replace(/\s\(([^)]*)\)/g, '')// Remove content in angle brackets (e.g. <locals>)
+    .replace(/\s<([^>]*)>/g, '')// Clean up any extra whitespace
+    .trim();
+}
+function removeFreeCallWrapper(text) {
+    // Match (0, <ident>.<ident>) patterns anywhere in the text the beginning
+    // Overzealous: accept any non-whitespace member expression after the dot.
+    // TODO: Fix https://linear.app/vercel/issue/NEXT-4875 to allow using unicode property escapes
+    return text.replace(/\(0\s*,\s*(__TURBOPACK__[a-zA-Z0-9_$]+__\.[^\s)]+)\)/g, '$1');
+}
+function deobfuscateTextParts(text) {
+    // First, remove free call wrappers
+    const withoutFreeCall = removeFreeCallWrapper(text);
+    const parts = [];
+    let lastIndex = 0;
+    // Create a new regex instance for global matching
+    const regex = new RegExp(MAGIC_IDENTIFIER_REGEX.source, 'g');
+    for(let match = regex.exec(withoutFreeCall); match !== null; match = regex.exec(withoutFreeCall)){
+        const matchStart = match.index;
+        const matchEnd = regex.lastIndex;
+        const ident = match[0];
+        // Add raw text before this match (if any)
+        if (matchStart > lastIndex) {
+            const rawText = withoutFreeCall.substring(lastIndex, matchStart);
+            parts.push([
+                'raw',
+                rawText
+            ]);
+        }
+        // Process and add the deobfuscated part
+        try {
+            const decoded = decodeMagicIdentifier(ident);
+            // If it was a magic identifier, clean up the module ID
+            if (decoded !== ident) {
+                // Check if this is an "imported module" reference
+                const importedModuleMatch = decoded.match(/^imported module (.+)$/);
+                if (importedModuleMatch) {
+                    // Clean the entire module path (which includes [app-rsc], etc.)
+                    const modulePathWithMetadata = importedModuleMatch[1];
+                    const cleaned = deobfuscateModuleId(modulePathWithMetadata);
+                    parts.push([
+                        'deobfuscated',
+                        `{imported module ${cleaned}}`
+                    ]);
+                } else {
+                    const cleaned = deobfuscateModuleId(decoded);
+                    parts.push([
+                        'deobfuscated',
+                        `{${cleaned}}`
+                    ]);
+                }
+            } else {
+                // Not actually a magic identifier, treat as raw
+                parts.push([
+                    'raw',
+                    ident
+                ]);
+            }
+        } catch (e) {
+            parts.push([
+                'deobfuscated',
+                `{${ident} (decoding failed: ${e})}`
+            ]);
+        }
+        lastIndex = matchEnd;
+    }
+    // Add any remaining raw text after the last match
+    if (lastIndex < withoutFreeCall.length) {
+        const rawText = withoutFreeCall.substring(lastIndex);
+        parts.push([
+            'raw',
+            rawText
+        ]);
+    }
+    return parts;
+}
+function deobfuscateText(text) {
+    const parts = deobfuscateTextParts(text);
+    return parts.map((part)=>part[1]).join('');
+}
+
+//# sourceMappingURL=magic-identifier.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/match-remote-pattern.js

@@ -33,11 +33,7 @@ function matchRemotePattern(pattern, url) {
         }
     }
     if (pattern.hostname === undefined) {
-        throw Object.defineProperty(new Error(`Pattern should define hostname but found\n${JSON.stringify(pattern)}`), "__NEXT_ERROR_CODE", {
-            value: "E410",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Pattern should define hostname but found\n${JSON.stringify(pattern)}`);
     } else {
         if (!(0, _picomatch.makeRe)(pattern.hostname).test(url.hostname)) {
             return false;

package/.next/standalone/node_modules/next/dist/shared/lib/router/routes/app.js

@@ -109,28 +109,16 @@ function parseAppRouteImpl(pathname, allowedTypes) {
             continue;
         }
         if (appSegment.type === 'route-group' && !(allowedTypes & AllowGroupSegments)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group segment.`), "__NEXT_ERROR_CODE", {
-                value: "E1151",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group segment.`);
         }
         if (appSegment.type === 'parallel-route' && !(allowedTypes & AllowParallelSegments)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a parallel route segment.`), "__NEXT_ERROR_CODE", {
-                value: "E1152",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a parallel route segment.`);
         }
         segments.push(appSegment);
         if (appSegment.interceptionMarker) {
             const parts = pathname.split(appSegment.interceptionMarker);
             if (parts.length !== 2) {
-                throw Object.defineProperty(new Error(`Invalid interception route: ${pathname}`), "__NEXT_ERROR_CODE", {
-                    value: "E924",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid interception route: ${pathname}`);
             }
             interceptingRoute = parseAppRouteImpl(parts[0], allowedTypes);
             interceptedRoute = parseAppRouteImpl(parts[1], allowedTypes);

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/app-paths.js

@@ -58,7 +58,12 @@ function compareAppPaths(a, b) {
     if (!aHasSlot && bHasSlot) return 1;
     return a.localeCompare(b);
 }
-function selectAppPageEntry(pathname, appPaths, normalizePathname = (appPath)=>normalizeAppPath(appPath).replace(/%5F/g, '_')) {
+function normalizeAppPageEntryPathname(appPath) {
+    // Webpack app entries preserve escaped underscore segments as `%5F`, while
+    // normalized request pathnames expose the decoded `_` segment.
+    return normalizeAppPath(appPath).replace(/%5F/g, '_');
+}
+function selectAppPageEntry(pathname, appPaths, normalizePathname = normalizeAppPageEntryPathname) {
     let entry;
     for (const appPath of appPaths){
         if (normalizePathname(appPath) !== pathname) continue;

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js

@@ -50,8 +50,8 @@ const _resolveparamvalue = require("./resolve-param-value");
     if (fallbackRouteParams?.has(segmentKey)) {
         // We know that the fallback route params has the segment key because we
         // checked that above.
-        const [searchValue] = fallbackRouteParams.get(segmentKey);
-        value = searchValue;
+        const placeholder = fallbackRouteParams.get(segmentKey);
+        value = placeholder;
     } else if (Array.isArray(value)) {
         value = value.map((i)=>encodeURIComponent(i));
     } else if (typeof value === 'string') {
@@ -82,11 +82,7 @@ function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRo
             if (paramValue !== undefined) {
                 interpolated[paramName] = paramValue;
             } else if (paramType !== 'optional-catchall') {
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`), "__NEXT_ERROR_CODE", {
-                    value: "E932",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`);
             }
         }
         // Calculate next depth - increment if this is not a route group and not empty
@@ -122,11 +118,7 @@ function getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallb
                 ]
             };
         }
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`), "__NEXT_ERROR_CODE", {
-            value: "E864",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`);
     }
     const paramCacheKey = Array.isArray(value) ? value.join('/') : value;
     return {

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/interception-routes.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     INTERCEPTION_ROUTE_MARKERS: null,
     extractInterceptionRouteInformation: null,
+    findMissingCanonicalInterceptionRoutes: null,
     isInterceptionRouteAppPath: null
 });
 function _export(target, all) {
@@ -20,6 +21,9 @@ _export(exports, {
     extractInterceptionRouteInformation: function() {
         return extractInterceptionRouteInformation;
     },
+    findMissingCanonicalInterceptionRoutes: function() {
+        return findMissingCanonicalInterceptionRoutes;
+    },
     isInterceptionRouteAppPath: function() {
         return isInterceptionRouteAppPath;
     }
@@ -31,6 +35,53 @@ const INTERCEPTION_ROUTE_MARKERS = [
     '(..)',
     '(...)'
 ];
+function parseRoutePattern(route) {
+    const segments = route.split('/').filter(Boolean);
+    const tail = segments.at(-1);
+    const isOptionalCatchAll = tail !== undefined && tail.startsWith('[[...') && tail.endsWith(']]');
+    const isCatchAll = tail !== undefined && tail.startsWith('[...') && tail.endsWith(']');
+    const unbounded = isOptionalCatchAll || isCatchAll;
+    const prefixSegments = unbounded ? segments.slice(0, -1) : segments;
+    return {
+        prefix: prefixSegments.map((segment)=>segment.startsWith('[') && segment.endsWith(']') ? null : segment),
+        minLength: prefixSegments.length + (isCatchAll && !isOptionalCatchAll ? 1 : 0),
+        unbounded
+    };
+}
+function acceptsLength(pattern, length) {
+    return pattern.unbounded ? length >= pattern.minLength : length === pattern.minLength;
+}
+function prefixCovers(canonical, intercepted) {
+    return canonical.prefix.every((canonicalSegment, index)=>{
+        if (canonicalSegment === null) return true;
+        const interceptedSegment = intercepted.prefix[index];
+        return interceptedSegment !== undefined && interceptedSegment !== null && canonicalSegment === interceptedSegment;
+    });
+}
+function patternCoversAtLength(canonical, intercepted, length) {
+    return acceptsLength(canonical, length) && acceptsLength(intercepted, length) && prefixCovers(canonical, intercepted);
+}
+/** Returns whether ordinary route patterns cover every URL in `route`. */ function isRoutePatternCovered(route, ordinaryRoutes) {
+    const intercepted = parseRoutePattern(route);
+    if (!intercepted.unbounded) {
+        return ordinaryRoutes.some((pattern)=>patternCoversAtLength(pattern, intercepted, intercepted.minLength));
+    }
+    let unboundedCoverageStart = Infinity;
+    for (const pattern of ordinaryRoutes){
+        if (pattern.unbounded && prefixCovers(pattern, intercepted)) {
+            unboundedCoverageStart = Math.min(unboundedCoverageStart, Math.max(intercepted.minLength, pattern.minLength));
+        }
+    }
+    if (unboundedCoverageStart === Infinity) return false;
+    // An optional or required catchall can have its shorter paths covered by
+    // fixed routes before another catchall takes over the remaining suffix.
+    for(let length = intercepted.minLength; length < unboundedCoverageStart; length++){
+        if (!ordinaryRoutes.some((pattern)=>patternCoversAtLength(pattern, intercepted, length))) {
+            return false;
+        }
+    }
+    return true;
+}
 function isInterceptionRouteAppPath(path) {
     // TODO-APP: add more serious validation
     return path.split('/').find((segment)=>INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m))) !== undefined;
@@ -48,11 +99,7 @@ function extractInterceptionRouteInformation(path) {
         }
     }
     if (!interceptingRoute || !marker || !interceptedRoute) {
-        throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`), "__NEXT_ERROR_CODE", {
-            value: "E269",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`);
     }
     interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute) // normalize the path, e.g. /(blog)/feed -> /feed
     ;
@@ -68,11 +115,7 @@ function extractInterceptionRouteInformation(path) {
         case '(..)':
             // (..) indicates that we should match at one level up, so we need to remove the last segment of the intercepting route
             if (interceptingRoute === '/') {
-                throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`), "__NEXT_ERROR_CODE", {
-                    value: "E207",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`);
             }
             interceptedRoute = interceptingRoute.split('/').slice(0, -1).concat(interceptedRoute).join('/');
             break;
@@ -84,25 +127,25 @@ function extractInterceptionRouteInformation(path) {
             // (..)(..) indicates that we should match at two levels up, so we need to remove the last two segments of the intercepting route
             const splitInterceptingRoute = interceptingRoute.split('/');
             if (splitInterceptingRoute.length <= 2) {
-                throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`), "__NEXT_ERROR_CODE", {
-                    value: "E486",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`);
             }
             interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join('/');
             break;
         default:
-            throw Object.defineProperty(new Error('Invariant: unexpected marker'), "__NEXT_ERROR_CODE", {
-                value: "E112",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Invariant: unexpected marker');
     }
     return {
         interceptingRoute,
         interceptedRoute
     };
 }
+function findMissingCanonicalInterceptionRoutes(appPaths) {
+    const canonicalRoutes = Object.keys(appPaths).filter((route)=>!isInterceptionRouteAppPath(route));
+    const canonicalRoutePatterns = canonicalRoutes.map(parseRoutePattern);
+    return Object.keys(appPaths).filter(isInterceptionRouteAppPath).map((interceptionRoute)=>({
+            interceptionRoute,
+            canonicalRoute: extractInterceptionRouteInformation(interceptionRoute).interceptedRoute
+        })).filter(({ canonicalRoute })=>!isRoutePatternCovered(canonicalRoute, canonicalRoutePatterns)).sort((a, b)=>a.interceptionRoute.localeCompare(b.interceptionRoute));
+}
 
 //# sourceMappingURL=interception-routes.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.js

@@ -17,11 +17,7 @@ function parseRelativeUrl(url, base, parseQuery = true) {
     // Not using `origin` to support other protocols
     new URL(`${resolvedBase.protocol}//${resolvedBase.host}${url}`) : new URL(url, resolvedBase);
     if (origin !== globalBase.origin) {
-        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
-            value: "E159",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`invariant: invalid relative URL, router received ${url}`);
     }
     return {
         auth: null,

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/prepare-destination.js

@@ -267,11 +267,7 @@ function prepareDestination(args) {
         parsedDestination.search = destSearch ? compileNonPath(destSearch, args.params) : '';
     } catch (err) {
         if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
-            throw Object.defineProperty(new Error(`To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`), "__NEXT_ERROR_CODE", {
-                value: "E329",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`);
         }
         throw err;
     }

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/querystring.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     assign: null,
+    getRenderedSearch: null,
     searchParamsToUrlQuery: null,
     urlQueryToSearchParams: null
 });
@@ -17,6 +18,9 @@ _export(exports, {
     assign: function() {
         return assign;
     },
+    getRenderedSearch: function() {
+        return getRenderedSearch;
+    },
     searchParamsToUrlQuery: function() {
         return searchParamsToUrlQuery;
     },
@@ -24,6 +28,33 @@ _export(exports, {
         return urlQueryToSearchParams;
     }
 });
+function getRenderedSearch(query) {
+    // Inlined implementation of querystring.encode, which is not available in
+    // the Edge runtime.
+    const pairs = [];
+    for(const key in query){
+        const value = query[key];
+        if (value == null) continue;
+        if (Array.isArray(value)) {
+            for (const v of value){
+                pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`);
+            }
+        } else {
+            pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    // The result should match the format of a web URL's `search` property, since
+    // this is the format that's stored in the App Router state.
+    // TODO: We're a bit inconsistent about this. The x-nextjs-rewritten-query
+    // header omits the leading question mark. Should refactor to always do
+    // that instead.
+    if (pairs.length === 0) {
+        // If the search string is empty, return an empty string.
+        return '';
+    }
+    // Prepend '?' to the search params string.
+    return '?' + pairs.join('&');
+}
 function searchParamsToUrlQuery(searchParams) {
     const query = {};
     for (const [key, value] of searchParams.entries()){

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/resolve-param-value.js

@@ -83,11 +83,7 @@ function resolveParamValue(paramName, paramType, depth, route, params) {
             } else {
                 // We shouldn't be able to match a catchall segment without any path
                 // segments if it's not an optional catchall
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-                    value: "E931",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`);
             }
         case 'dynamic':
         case 'dynamic-intercepted-(..)(..)':

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/route-matcher.js

@@ -18,11 +18,7 @@ function getRouteMatcher({ re, groups }) {
             try {
                 return decodeURIComponent(param);
             } catch  {
-                throw Object.defineProperty(new _utils.DecodeError('failed to decode param'), "__NEXT_ERROR_CODE", {
-                    value: "E528",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _utils.DecodeError('failed to decode param');
             }
         };
         const params = {};

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/sorted-routes.js

@@ -50,11 +50,7 @@ class UrlNode {
         if (!this.placeholder) {
             const r = prefix === '/' ? '/' : prefix.slice(0, -1);
             if (this.optionalRestSlugName != null) {
-                throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${r}" and "${r}[[...${this.optionalRestSlugName}]]").`), "__NEXT_ERROR_CODE", {
-                    value: "E458",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${r}" and "${r}[[...${this.optionalRestSlugName}]]").`);
             }
             routes.unshift(r);
         }
@@ -72,11 +68,7 @@ class UrlNode {
             return;
         }
         if (isCatchAll) {
-            throw Object.defineProperty(new Error(`Catch-all must be the last part of the URL.`), "__NEXT_ERROR_CODE", {
-                value: "E392",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Catch-all must be the last part of the URL.`);
         }
         // The next segment in the urlPaths list
         let nextSegment = urlPaths[0];
@@ -91,11 +83,7 @@ class UrlNode {
                 isOptional = true;
             }
             if (segmentName.startsWith('…')) {
-                throw Object.defineProperty(new Error(`Detected a three-dot character ('…') at ('${segmentName}'). Did you mean ('...')?`), "__NEXT_ERROR_CODE", {
-                    value: "E147",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Detected a three-dot character ('…') at ('${segmentName}'). Did you mean ('...')?`);
             }
             if (segmentName.startsWith('...')) {
                 // Strip `...`, leaving only `something`
@@ -103,18 +91,10 @@ class UrlNode {
                 isCatchAll = true;
             }
             if (segmentName.startsWith('[') || segmentName.endsWith(']')) {
-                throw Object.defineProperty(new Error(`Segment names may not start or end with extra brackets ('${segmentName}').`), "__NEXT_ERROR_CODE", {
-                    value: "E421",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Segment names may not start or end with extra brackets ('${segmentName}').`);
             }
             if (segmentName.startsWith('.')) {
-                throw Object.defineProperty(new Error(`Segment names may not start with erroneous periods ('${segmentName}').`), "__NEXT_ERROR_CODE", {
-                    value: "E288",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Segment names may not start with erroneous periods ('${segmentName}').`);
             }
             function handleSlug(previousSlug, nextSlug) {
                 if (previousSlug !== null) {
@@ -125,27 +105,15 @@ class UrlNode {
                     // Because currently multiple dynamic params on the same segment level are not supported
                     if (previousSlug !== nextSlug) {
                         // TODO: This error seems to be confusing for users, needs an error link, the description can be based on above comment.
-                        throw Object.defineProperty(new Error(`You cannot use different slug names for the same dynamic path ('${previousSlug}' !== '${nextSlug}').`), "__NEXT_ERROR_CODE", {
-                            value: "E337",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`You cannot use different slug names for the same dynamic path ('${previousSlug}' !== '${nextSlug}').`);
                     }
                 }
                 slugNames.forEach((slug)=>{
                     if (slug === nextSlug) {
-                        throw Object.defineProperty(new Error(`You cannot have the same slug name "${nextSlug}" repeat within a single dynamic path`), "__NEXT_ERROR_CODE", {
-                            value: "E247",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`You cannot have the same slug name "${nextSlug}" repeat within a single dynamic path`);
                     }
                     if (slug.replace(/\W/g, '') === nextSegment.replace(/\W/g, '')) {
-                        throw Object.defineProperty(new Error(`You cannot have the slug names "${slug}" and "${nextSlug}" differ only by non-word symbols within a single dynamic path`), "__NEXT_ERROR_CODE", {
-                            value: "E499",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`You cannot have the slug names "${slug}" and "${nextSlug}" differ only by non-word symbols within a single dynamic path`);
                     }
                 });
                 slugNames.push(nextSlug);
@@ -153,11 +121,7 @@ class UrlNode {
             if (isCatchAll) {
                 if (isOptional) {
                     if (this.restSlugName != null) {
-                        throw Object.defineProperty(new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`), "__NEXT_ERROR_CODE", {
-                            value: "E299",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`);
                     }
                     handleSlug(this.optionalRestSlugName, segmentName);
                     // slugName is kept as it can only be one particular slugName
@@ -166,11 +130,7 @@ class UrlNode {
                     nextSegment = '[[...]]';
                 } else {
                     if (this.optionalRestSlugName != null) {
-                        throw Object.defineProperty(new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
-                            value: "E300",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`);
                     }
                     handleSlug(this.restSlugName, segmentName);
                     // slugName is kept as it can only be one particular slugName
@@ -180,11 +140,7 @@ class UrlNode {
                 }
             } else {
                 if (isOptional) {
-                    throw Object.defineProperty(new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
-                        value: "E435",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`);
                 }
                 handleSlug(this.slugName, segmentName);
                 // slugName is kept as it can only be one particular slugName