@sifxprime/krouter 0.5.166 → 0.5.167

package/app/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

package/app/node_modules/next/dist/shared/lib/rsc-transport.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createSkippedSegmentData: null,
+    readFulfilledValue: null,
+    segmentToTransportSegment: null,
+    transportNodeToFlightRouterState: null,
+    transportSegmentToSegment: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createSkippedSegmentData: function() {
+        return createSkippedSegmentData;
+    },
+    readFulfilledValue: function() {
+        return readFulfilledValue;
+    },
+    segmentToTransportSegment: function() {
+        return segmentToTransportSegment;
+    },
+    transportNodeToFlightRouterState: function() {
+        return transportNodeToFlightRouterState;
+    },
+    transportSegmentToSegment: function() {
+        return transportSegmentToSegment;
+    }
+});
+const _segment = require("./segment");
+function createSkippedSegmentData() {
+    return {
+        r: null,
+        p: true,
+        v: null
+    };
+}
+function readFulfilledValue(valueFromServer, unresolvedValue, rejectedValue = unresolvedValue) {
+    const thenable = valueFromServer;
+    // Force Flight to unwrap a received-but-not-yet-settled row.
+    thenable.then(noop, noop);
+    switch(thenable.status){
+        case 'fulfilled':
+            return thenable.value;
+        case 'rejected':
+            return rejectedValue;
+        // No status yet: the row is still pending, or absent from this decode.
+        case undefined:
+        default:
+            return unresolvedValue;
+    }
+}
+const noop = ()=>{};
+function segmentToTransportSegment(segment) {
+    if (typeof segment === 'string') {
+        return segment;
+    }
+    return {
+        n: segment[0],
+        t: segment[2],
+        k: segment[1],
+        s: segment[3]
+    };
+}
+function transportSegmentToSegment(transportSegment) {
+    if (typeof transportSegment === 'string') {
+        return transportSegment;
+    }
+    return [
+        transportSegment.n,
+        // `k` may be null when the client is expected to parse the param value
+        // from the URL (per-segment prefetch responses). Callers that need the
+        // real value resolve it from the rendered pathname instead of using this
+        // function (see resolveTransportSegment in decode-server-response); the
+        // remaining callers are value-insensitive (segment request keys, which
+        // never include param values) or only see concrete keys.
+        transportSegment.k ?? '',
+        transportSegment.t,
+        transportSegment.s
+    ];
+}
+function transportNodeToFlightRouterState(node, renderedSearch) {
+    const parallelRoutes = {};
+    const children = node.c;
+    if (children !== undefined) {
+        for (const [parallelRouteKey, childNode] of children){
+            parallelRoutes[parallelRouteKey] = transportNodeToFlightRouterState(childNode, renderedSearch);
+        }
+    }
+    const flightRouterState = [
+        transportSegmentToSegment(node.s),
+        parallelRoutes
+    ];
+    if (node.h !== undefined) {
+        flightRouterState[4] = node.h;
+    }
+    if (flightRouterState[0] === _segment.PAGE_SEGMENT_KEY) {
+        flightRouterState[5] = renderedSearch;
+    }
+    return flightRouterState;
+}
+
+//# sourceMappingURL=rsc-transport.js.map

package/app/node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.js

@@ -32,23 +32,10 @@ _export(exports, {
         return createSegmentRequestKeyPart;
     }
 });
-const _segment = require("../segment");
 const ROOT_SEGMENT_REQUEST_KEY = '';
 const HEAD_REQUEST_KEY = '/_head';
 function createSegmentRequestKeyPart(segment) {
     if (typeof segment === 'string') {
-        if (segment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
-            // The Flight Router State type sometimes includes the search params in
-            // the page segment. However, the Segment Cache tracks this as a separate
-            // key. So, we strip the search params here, and then add them back when
-            // the cache entry is turned back into a FlightRouterState. This is an
-            // unfortunate consequence of the FlightRouteState being used both as a
-            // transport type and as a cache key; we'll address this once more of the
-            // Segment Cache implementation has settled.
-            // TODO: We should hoist the search params out of the FlightRouterState
-            // type entirely, This is our plan for dynamic route params, too.
-            return _segment.PAGE_SEGMENT_KEY;
-        }
         const safeName = // TODO: FlightRouterState encodes Not Found routes as "/_not-found".
         // But params typically don't include the leading slash. We should use
         // a different encoding to avoid this special case.

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

@@ -6,21 +6,43 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "readVaryParams", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    SEARCH_PARAMS_VARY_ID: null,
+    createVaryParams: null,
+    decodeVaryParams: null,
+    readVaryParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    SEARCH_PARAMS_VARY_ID: function() {
+        return SEARCH_PARAMS_VARY_ID;
+    },
+    createVaryParams: function() {
+        return createVaryParams;
+    },
+    decodeVaryParams: function() {
+        return decodeVaryParams;
+    },
+    readVaryParams: function() {
         return readVaryParams;
     }
 });
+const _rsctransport = require("../rsc-transport");
+const SEARCH_PARAMS_VARY_ID = 0;
 /**
  * Synchronously drains a vary params `AsyncIterable`, adding each yielded name
  * to `target`.
  *
  * By the time this runs (on the client, or in collectSegmentData), the Flight
  * stream has been fully buffered, so every yielded value is already
- * materialized and can be read without awaiting. We force each iterator result
- * to resolve synchronously using the same `.then(noop)` trick React uses
- * internally, then read its `status`/`value` directly.
+ * materialized and can be read without awaiting: each iterator result is a
+ * Flight chunk whose settled state `readFulfilledValue` reads off the
+ * thenable's status.
  *
  * We add "every param yielded up to the point the stream suspends": a
  * normally-closed iterable drains fully, while one left hanging (a sync-I/O
@@ -32,35 +54,34 @@ Object.defineProperty(exports, "readVaryParams", {
  */ function drainVaryParams(iterable, target) {
     const iterator = iterable[Symbol.asyncIterator]();
     while(true){
-        const chunk = iterator.next();
-        // Attach a no-op listener to force Flight to synchronously resolve the
-        // chunk. A freshly-arrived result may be in an intermediate
-        // 'resolved_model' state (data received but not unwrapped); calling
-        // .then() transitions it to 'fulfilled', making the value available
-        // synchronously. (A native Promise has no `status` and simply reads as
-        // not-fulfilled below, so this can never hang.)
-        chunk.then(noop, noop);
-        if (chunk.status !== 'fulfilled' || chunk.value === undefined) {
-            // The stream suspended here. Everything yielded before this point has
-            // already been added.
-            return;
-        }
-        const step = chunk.value;
-        if (step.done) {
+        const step = (0, _rsctransport.readFulfilledValue)(iterator.next(), undefined);
+        if (step === undefined || step.done) {
+            // Either the stream suspended here — everything yielded before this
+            // point has already been added — or the iterable finished cleanly.
             return;
         }
         target.add(step.value);
     }
 }
-function readVaryParams(iterable, rootIterable) {
+function decodeVaryParams(iterable, rootIterable) {
     if (iterable === null || iterable === undefined || rootIterable === null || rootIterable === undefined) {
         return null;
     }
-    const varyParams = new Set();
-    drainVaryParams(iterable, varyParams);
-    drainVaryParams(rootIterable, varyParams);
-    return varyParams;
+    const total = new Set();
+    drainVaryParams(iterable, total);
+    drainVaryParams(rootIterable, total);
+    return createVaryParams(total);
+}
+function createVaryParams(total) {
+    // TODO: Don't need to use a native promise. Just inline a thenable that
+    // immediately calls its listener.
+    const settled = Promise.resolve(total);
+    settled.status = 'fulfilled';
+    settled.value = total;
+    return settled;
+}
+function readVaryParams(varyParams) {
+    return (0, _rsctransport.readFulfilledValue)(varyParams, null);
 }
-const noop = ()=>{};
 
 //# sourceMappingURL=vary-params-decoding.js.map

package/app/node_modules/next/dist/shared/lib/segment.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
     DEFAULT_SEGMENT_KEY: null,
     NOT_FOUND_SEGMENT_KEY: null,
     PAGE_SEGMENT_KEY: null,
-    addSearchParamsIfPageSegment: null,
     computeSelectedLayoutSegment: null,
     getSegmentValue: null,
     getSelectedLayoutSegmentPath: null,
@@ -29,9 +28,6 @@ _export(exports, {
     PAGE_SEGMENT_KEY: function() {
         return PAGE_SEGMENT_KEY;
     },
-    addSearchParamsIfPageSegment: function() {
-        return addSearchParamsIfPageSegment;
-    },
     computeSelectedLayoutSegment: function() {
         return computeSelectedLayoutSegment;
     },
@@ -58,14 +54,6 @@ function isGroupSegment(segment) {
 function isParallelRouteSegment(segment) {
     return segment.startsWith('@') && segment !== '@children';
 }
-function addSearchParamsIfPageSegment(segment, searchParams) {
-    const isPageSegment = segment.includes(PAGE_SEGMENT_KEY);
-    if (isPageSegment) {
-        const stringifiedQuery = JSON.stringify(searchParams);
-        return stringifiedQuery !== '{}' ? PAGE_SEGMENT_KEY + '?' + stringifiedQuery : PAGE_SEGMENT_KEY;
-    }
-    return segment;
-}
 function computeSelectedLayoutSegment(segments, parallelRouteKey) {
     if (!segments || segments.length === 0) {
         return null;
@@ -89,7 +77,7 @@ function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first = true, segm
     if (!node) return segmentPath;
     const segment = node[0];
     let segmentValue = getSegmentValue(segment);
-    if (!segmentValue || segmentValue.startsWith(PAGE_SEGMENT_KEY)) {
+    if (!segmentValue || segmentValue === PAGE_SEGMENT_KEY) {
         return segmentPath;
     }
     segmentPath.push(segmentValue);

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

@@ -30,6 +30,9 @@ function msToNs(ms) {
 }
 function backgroundLogCompilationEvents(project, { eventTypes, signal, parentSpan } = {}) {
     const iterator = project.compilationEventsSubscribe(eventTypes);
+    // If there is no signal assume there will be no clean shutdown,
+    // to ensure trace spans aren't lost just flush after each one.
+    const flushEachTraceEvent = signal === undefined;
     // Close the iterator as soon as the signal fires so the for-await loop
     // exits without waiting for the next compilation event.
     signal?.addEventListener('abort', ()=>iterator.return?.(undefined), {
@@ -43,11 +46,9 @@ function backgroundLogCompilationEvents(project, { eventTypes, signal, parentSpa
                     const data = JSON.parse(event.eventJson);
                     parentSpan.manualTraceChild(data.name, msToNs(data.startTimeMs), msToNs(data.endTimeMs), Object.fromEntries(data.attributes ?? []));
                     (0, _trace1.traceMemoryUsage)(data.name, parentSpan);
-                    // We flush after each event to make sure it makes it to disk.  These events are rare and
-                    // tend to happen at the very end of a build so to make sure they are logged we need to
-                    // flush.
-                    // NOTE: in a `next build` environment where we are reporting events to the parent thread, this is a no-op.
-                    await (0, _trace.flushAllTraces)();
+                    if (flushEachTraceEvent) {
+                        (0, _trace.flushAllTraces)();
+                    }
                 } catch  {}
                 continue; // don't log these events, they just go to the trace file
             }
@@ -76,8 +77,7 @@ function backgroundLogCompilationEvents(project, { eventTypes, signal, parentSpa
         }
     }();
     // Prevent unhandled rejection if the subscription errors after the project shuts down.
-    promise.catch(()=>{});
-    return promise;
+    return promise.catch(()=>{});
 }
 
 //# sourceMappingURL=compilation-events.js.map

package/app/node_modules/next/dist/shared/lib/turbopack/internal-error.js

@@ -24,20 +24,15 @@ const _events = require("../../../telemetry/events");
 const _shared = require("../../../trace/shared");
 class TurbopackInternalError extends Error {
     constructor({ message, anonymizedLocation }){
-        super(message), this.name = 'TurbopackInternalError', // Manually set this as this isn't statically determinable
-        this.__NEXT_ERROR_CODE = 'TurbopackInternalError';
+        super(message), this.name = 'TurbopackInternalError';
         this.location = anonymizedLocation;
     }
 }
 function throwTurbopackInternalError(conversionError, opts) {
     if (conversionError != null) {
         // Somehow napi failed to convert `opts` to a JS object??? Just give up and throw that instead.
-        throw Object.defineProperty(new Error('NAPI type conversion error in throwTurbopackInternalError', {
+        throw new Error('NAPI type conversion error in throwTurbopackInternalError', {
             cause: conversionError
-        }), "__NEXT_ERROR_CODE", {
-            value: "E723",
-            enumerable: false,
-            configurable: true
         });
     }
     const err = new TurbopackInternalError(opts);

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

@@ -449,11 +449,7 @@ class TurbopackManifestLoader {
                 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
-                        });
+                        throw new Error(`Invalid source: ${matcher.regexp}`);
                     }
                     matcher.regexp = parsedPage.regexStr;
                 }
@@ -463,7 +459,7 @@ class TurbopackManifestLoader {
         this.pendingCacheDeletes.push(middlewareManifestPath);
         (0, _writeatomic.writeFileAtomic)(middlewareManifestPath, JSON.stringify(middlewareManifest, null, 2));
         // Client middleware manifest This is only used in dev though, packages/next/src/build/index.ts
-        // writes the mainfest again for builds.
+        // writes the manifest again for builds.
         const matchers = middlewareManifest?.middleware['/']?.matchers || [];
         const clientMiddlewareManifestJs = `self.__MIDDLEWARE_MATCHERS = ${JSON.stringify(matchers, null, 2)};self.__MIDDLEWARE_MATCHERS_CB && self.__MIDDLEWARE_MATCHERS_CB()`;
         this.pendingCacheDeletes.push(clientMiddlewareManifestPath);

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

@@ -85,13 +85,9 @@ function processIssues(currentEntryIssues, key, result, throwIssue, logErrors) {
         }
     }
     if (relevantIssues.size && throwIssue) {
-        throw Object.defineProperty(new ModuleBuildError([
+        throw new ModuleBuildError([
             ...relevantIssues
-        ].join('\n\n')), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        ].join('\n\n'));
     }
 }
 function formatFilePath(filePath) {
@@ -260,11 +256,7 @@ function renderStyledStringToErrorAnsi(string) {
         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
-            });
+            throw new Error('Unknown StyledString type', string);
     }
 }
 function isFileSystemCacheEnabledForDev(config) {

package/app/node_modules/next/dist/shared/lib/utils.js

@@ -83,7 +83,6 @@ _export(exports, {
 const WEB_VITALS = [
     'CLS',
     'FCP',
-    'FID',
     'INP',
     'LCP',
     'TTFB'
@@ -138,11 +137,7 @@ async function loadGetInitialProps(App, ctx) {
     if (process.env.NODE_ENV !== 'production') {
         if (App.prototype?.getInitialProps) {
             const message = `"${getDisplayName(App)}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`;
-            throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                value: "E1035",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(message);
         }
     }
     // when called from _app `ctx` is nested in `ctx`
@@ -162,11 +157,7 @@ async function loadGetInitialProps(App, ctx) {
     }
     if (!props) {
         const message = `"${getDisplayName(App)}.getInitialProps()" should resolve to an object. But found "${props}" instead.`;
-        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1025",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(message);
     }
     if (process.env.NODE_ENV !== 'production') {
         if (Object.keys(props).length === 0 && !ctx.ctx) {

package/app/node_modules/next/dist/shared/lib/zod.js

@@ -86,13 +86,9 @@ function normalizeZodErrors(error) {
     });
 }
 function formatZodError(prefix, error) {
-    return Object.defineProperty(new Error((0, _zodvalidationerror.fromZodError)(error, {
+    return new Error((0, _zodvalidationerror.fromZodError)(error, {
         prefix: prefix
-    }).toString()), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    }).toString());
 }
 function reportZodError(prefix, error) {
     _log.error(formatZodError(prefix, error).message);

package/app/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -82,7 +82,7 @@ async function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.3.8",
+        nextVersion: "16.4.1",
         agentName: await (0, _agentname.getAgentName)()
     };
     return traits;

package/app/node_modules/next/dist/telemetry/detached-flush.js

@@ -14,24 +14,17 @@ function _interop_require_default(obj) {
     };
 }
 (async ()=>{
-    const args = [
-        ...process.argv
-    ];
-    const eventsFile = args.pop();
-    let dir = args.pop();
-    const mode = args.pop();
+    const [mode, inputDir, eventsFile, suppliedDistDir] = process.argv.slice(2);
+    let dir = inputDir;
     if (!dir || mode !== 'dev') {
-        throw Object.defineProperty(new Error(`Invalid flags should be run as node detached-flush dev ./path-to/project [eventsFile]`), "__NEXT_ERROR_CODE", {
-            value: "E908",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invalid flags should be run as node detached-flush dev ./path-to/project [eventsFile] [distDir]`);
     }
     dir = (0, _getprojectdir.getProjectDir)(dir);
-    const config = await (0, _config.default)(_constants.PHASE_DEVELOPMENT_SERVER, dir);
-    const distDir = _path.default.join(dir, config.distDir || '.next');
-    // Support both old format (no eventsFile arg) and new format (with eventsFile arg)
-    const eventsPath = _path.default.join(distDir, eventsFile && !eventsFile.includes('/') ? eventsFile : '_events.json');
+    // Build nudges pass their resolved output directory to avoid loading dev config again.
+    const distDir = suppliedDistDir ? _path.default.resolve(suppliedDistDir) : _path.default.join(dir, (await (0, _config.default)(_constants.PHASE_DEVELOPMENT_SERVER, dir)).distDir || '.next');
+    // Named batches live in cache so build cleanup cannot remove them before submission.
+    // Retain the legacy root path for callers without an events filename.
+    const eventsPath = eventsFile && !eventsFile.includes('/') ? _path.default.join(distDir, 'cache', eventsFile) : _path.default.join(distDir, '_events.json');
     let events;
     try {
         events = JSON.parse(_fs.default.readFileSync(eventsPath, 'utf8'));

package/app/node_modules/next/dist/telemetry/events/build.js

@@ -72,7 +72,6 @@ _export(exports, {
         return eventTypeCheckCompleted;
     }
 });
-const _errortelemetryutils = require("../../lib/error-telemetry-utils");
 const REGEXP_DIRECTORY_DUNDER = /[\\/]__[^\\/]+(?<![\\/]__(?:tests|mocks))__[\\/]/i;
 const REGEXP_DIRECTORY_TESTS = /[\\/]__(tests|mocks)__[\\/]/i;
 const REGEXP_FILE_TEST = /\.(?:spec|test)\.[^.]+$/i;
@@ -178,7 +177,7 @@ function eventErrorThrown(error, anonymizedLocation) {
     return {
         eventName: ERROR_THROWN_EVENT,
         payload: {
-            errorCode: (0, _errortelemetryutils.extractNextErrorCode)(error) || 'Unknown',
+            errorCode: error.name || 'Unknown',
             location: anonymizedLocation
         }
     };

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

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