@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/patch-error-inspect.js

@@ -108,7 +108,7 @@ function setCodeFrameRenderer(renderer) {
     ;
     globalThis[CODE_FRAME_RENDERER] = renderer;
 }
-function getOriginalCodeFrame(frame, source, colors = process.stdout.isTTY) {
+function getOriginalCodeFrame(frame, source, colors = _picocolors.stdoutIsTerminal) {
     const codeFrameRenderer = globalThis[CODE_FRAME_RENDERER];
     if (!codeFrameRenderer) {
         // No renderer available - gracefully degrade
@@ -431,15 +431,7 @@ function sourceMapError(error, inspectOptions) {
     } : undefined;
     // Create a new Error object with the source mapping applied and then use native
     // Node.js formatting on the result.
-    const newError = error instanceof AggregateError ? Object.defineProperty(new AggregateError(error.errors, error.message, options), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    }) : Object.defineProperty(new Error(error.message, options), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    const newError = error instanceof AggregateError ? new AggregateError(error.errors, error.message, options) : new Error(error.message, options);
     // TODO: Ensure `class MyError extends Error {}` prints `MyError` as the name
     newError.stack = parseAndSourceMap(error, inspectOptions);
     for(const key in error){
@@ -451,6 +443,22 @@ function sourceMapError(error, inspectOptions) {
     }
     return newError;
 }
+/**
+ * Node.js passes the remaining depth in `depth`. An `AggregateError` keeps its
+ * errors in an array. Node.js spends one level of the depth on that array, and
+ * one more level on each error in the array. A `cause` costs one level only.
+ * This function adds the missing level back, so an `AggregateError` prints its
+ * errors at the same nesting as a `cause`. Without it, a `fetch` failure logs
+ * `[errors]: [ [Error], [Error] ]` and hides the address and the port of every
+ * refused connection.
+ *
+ * A `depth` of `null` means unlimited, so this function returns it unchanged.
+ */ function getInspectDepth(error, depth) {
+    if (depth === null || !(error instanceof AggregateError)) {
+        return depth;
+    }
+    return depth + 1;
+}
 function patchErrorInspectNodeJS(errorConstructor) {
     const inspectSymbol = Symbol.for('nodejs.util.inspect.custom');
     errorConstructor.prepareStackTrace = prepareUnsourcemappedStackTrace;
@@ -470,7 +478,7 @@ function patchErrorInspectNodeJS(errorConstructor) {
             try {
                 return inspect(newError, {
                     ...inspectOptions,
-                    depth
+                    depth: getInspectDepth(newError, depth)
                 });
             } finally{
                 ;

package/app/node_modules/next/dist/server/pipe-readable.js

@@ -25,19 +25,18 @@ _export(exports, {
     }
 });
 const _nextrequest = require("./web/spec-extension/adapters/next-request");
-const _detachedpromise = require("../lib/detached-promise");
+const _promisewithresolvers = require("../shared/lib/promise-with-resolvers");
 const _tracer = require("./lib/trace/tracer");
 const _constants = require("./lib/trace/constants");
-const _clientcomponentrendererlogger = require("./client-component-renderer-logger");
 function isAbortError(e) {
     return (e == null ? void 0 : e.name) === 'AbortError' || (e == null ? void 0 : e.name) === _nextrequest.ResponseAbortedName;
 }
 const HAS_CLIENT_COMPONENT_METRICS_ENABLED = 'performance' in globalThis && process.env.NEXT_OTEL_PERFORMANCE_PREFIX;
-function createWriterFromResponse(res, waitUntilForEnd) {
+function createWriterFromResponse(res, waitUntilForEnd, clientComponentLoadTracker) {
     let started = false;
     // Create a promise that will resolve once the response has drained. See
     // https://nodejs.org/api/stream.html#stream_event_drain
-    let drained = new _detachedpromise.DetachedPromise();
+    let drained = (0, _promisewithresolvers.createPromiseWithResolvers)();
     function onDrain() {
         drained.resolve();
     }
@@ -50,7 +49,7 @@ function createWriterFromResponse(res, waitUntilForEnd) {
     });
     // Create a promise that will resolve once the response has finished. See
     // https://nodejs.org/api/http.html#event-finish_1
-    const finished = new _detachedpromise.DetachedPromise();
+    const finished = (0, _promisewithresolvers.createPromiseWithResolvers)();
     res.once('finish', ()=>{
         finished.resolve();
     });
@@ -63,7 +62,7 @@ function createWriterFromResponse(res, waitUntilForEnd) {
             if (!started) {
                 started = true;
                 if (HAS_CLIENT_COMPONENT_METRICS_ENABLED) {
-                    const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)();
+                    const metrics = clientComponentLoadTracker == null ? void 0 : clientComponentLoadTracker.snapshot();
                     if (metrics) {
                         performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, {
                             start: metrics.clientComponentLoadStart,
@@ -88,16 +87,12 @@ function createWriterFromResponse(res, waitUntilForEnd) {
                 if (!ok) {
                     await drained.promise;
                     // Reset the drained promise so that we can wait for the next drain event.
-                    drained = new _detachedpromise.DetachedPromise();
+                    drained = (0, _promisewithresolvers.createPromiseWithResolvers)();
                 }
             } catch (err) {
                 res.end();
-                throw Object.defineProperty(new Error('failed to write chunk to response', {
+                throw new Error('failed to write chunk to response', {
                     cause: err
-                }), "__NEXT_ERROR_CODE", {
-                    value: "E321",
-                    enumerable: false,
-                    configurable: true
                 });
             }
         },
@@ -117,7 +112,7 @@ function createWriterFromResponse(res, waitUntilForEnd) {
         }
     });
 }
-async function pipeToNodeResponse(readable, res, waitUntilForEnd) {
+async function pipeToNodeResponse(readable, res, waitUntilForEnd, clientComponentLoadTracker) {
     try {
         // If the response has already errored, then just return now.
         const { errored, destroyed } = res;
@@ -125,29 +120,52 @@ async function pipeToNodeResponse(readable, res, waitUntilForEnd) {
         // Create a new AbortController so that we can abort the readable if the
         // client disconnects.
         const controller = (0, _nextrequest.createAbortController)(res);
-        const writer = createWriterFromResponse(res, waitUntilForEnd);
+        const writer = createWriterFromResponse(res, waitUntilForEnd, clientComponentLoadTracker);
         await readable.pipeTo(writer, {
             signal: controller.signal
         });
     } catch (err) {
         // If this isn't related to an abort error, re-throw it.
         if (isAbortError(err)) return;
-        throw Object.defineProperty(new Error('failed to pipe response', {
+        throw new Error('failed to pipe response', {
             cause: err
-        }), "__NEXT_ERROR_CODE", {
-            value: "E180",
-            enumerable: false,
-            configurable: true
         });
     }
 }
-async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd) {
+async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd, clientComponentLoadTracker) {
     try {
         const { errored, destroyed } = res;
         if (errored || destroyed) return;
         let started = false;
-        const finished = new _detachedpromise.DetachedPromise();
+        const finished = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        // One `drain` listener for the whole response, as in
+        // `createWriterFromResponse` above. It must not be `res.once('drain')` per
+        // backpressured write: the `compression` middleware forwards `res.on` to
+        // its zlib stream but leaves `removeListener` pointing at the response, so
+        // a `once` listener is never removed from the stream it was added to. Each
+        // backpressured write would leak one, and past ten Node reports the stream
+        // as a probable leak via `MaxListenersExceededWarning`.
+        //
+        // TODO: the upstream fix for that asymmetry is
+        // https://github.com/expressjs/compression/pull/153, which intercepts
+        // `removeListener` so it reaches the zlib stream. It has been open since
+        // 2019 and is not in upstream 1.8.1; we vendor 1.7.4. If it ever lands and
+        // we upgrade, `res.off('drain', onDrain)` below would start working with
+        // compression active and the caveat on the `close` handler could go away.
+        let paused = false;
+        const onDrain = ()=>{
+            // The listener outlives the readable: `off` below cannot reach the zlib
+            // stream either, so a late drain can arrive after teardown.
+            if (!paused || readable.destroyed) return;
+            paused = false;
+            readable.resume();
+        };
+        res.on('drain', onDrain);
         res.once('close', ()=>{
+            // Only removes the listener when compression is inactive, which is the
+            // case where it was added to the response itself. Otherwise it lives on
+            // the zlib stream, which is released with the response.
+            res.off('drain', onDrain);
             readable.destroy();
             finished.resolve();
         });
@@ -155,7 +173,7 @@ async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd) {
             if (!started) {
                 started = true;
                 if ('performance' in globalThis && process.env.NEXT_OTEL_PERFORMANCE_PREFIX) {
-                    const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)();
+                    const metrics = clientComponentLoadTracker == null ? void 0 : clientComponentLoadTracker.snapshot();
                     if (metrics) {
                         performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, {
                             start: metrics.clientComponentLoadStart,
@@ -173,10 +191,8 @@ async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd) {
                 res.flush();
             }
             if (!ok) {
+                paused = true;
                 readable.pause();
-                res.once('drain', ()=>{
-                    readable.resume();
-                });
             }
         });
         readable.on('end', async ()=>{
@@ -199,12 +215,8 @@ async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd) {
         await finished.promise;
     } catch (err) {
         if (isAbortError(err)) return;
-        throw Object.defineProperty(new Error('failed to pipe response', {
+        throw new Error('failed to pipe response', {
             cause: err
-        }), "__NEXT_ERROR_CODE", {
-            value: "E180",
-            enumerable: false,
-            configurable: true
         });
     }
 }

package/app/node_modules/next/dist/server/render-result.js

@@ -63,11 +63,7 @@ class RenderResult {
         }
         if (typeof this.response !== 'string') {
             if (!stream) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('dynamic responses cannot be unchunked. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-                    value: "E732",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('dynamic responses cannot be unchunked. This is a bug in Next.js');
             }
             return (0, _nodewebstreamshelper.streamToString)(this.readable);
         }
@@ -97,11 +93,7 @@ class RenderResult {
         }
         if (isNodeReadable(this.response)) {
             if (process.env.NEXT_RUNTIME === 'edge') {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Node.js Readable cannot be converted to a web stream in the edge runtime'), "__NEXT_ERROR_CODE", {
-                    value: "E1150",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Node.js Readable cannot be converted to a web stream in the edge runtime');
             } else {
                 let Readable;
                 if (process.env.TURBOPACK) {
@@ -137,11 +129,7 @@ class RenderResult {
             ];
         } else if (isNodeReadable(this.response)) {
             if (process.env.NEXT_RUNTIME === 'edge') {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Node.js Readable cannot be converted to a web stream in the edge runtime'), "__NEXT_ERROR_CODE", {
-                    value: "E1150",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Node.js Readable cannot be converted to a web stream in the edge runtime');
             } else {
                 let Readable;
                 if (process.env.TURBOPACK) {
@@ -236,10 +224,10 @@ class RenderResult {
    * @param res
    */ async pipeToNodeResponse(res) {
         if (this.response !== null && typeof this.response !== 'string' && !Buffer.isBuffer(this.response) && !Array.isArray(this.response) && isNodeReadable(this.response)) {
-            await (0, _pipereadable.pipeNodeReadableToNodeResponse)(this.response, res, this.waitUntil);
+            await (0, _pipereadable.pipeNodeReadableToNodeResponse)(this.response, res, this.waitUntil, this.metadata.clientComponentLoadTracker);
             return;
         }
-        await (0, _pipereadable.pipeToNodeResponse)(this.readable, res, this.waitUntil);
+        await (0, _pipereadable.pipeToNodeResponse)(this.readable, res, this.waitUntil, this.metadata.clientComponentLoadTracker);
     }
 }