@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.js

@@ -34,12 +34,21 @@ var ExecutionState = /*#__PURE__*/ function(ExecutionState) {
     ExecutionState[ExecutionState["Abandoned"] = 4] = "Abandoned";
     return ExecutionState;
 }(ExecutionState || {});
+const FAST_SET_IMMEDIATE_ORIGINALS_KEY = Symbol.for('next.fast-set-immediate.originals');
+// Re-evaluations in dev should always use the same base/original functions.
+const originals = globalThis[FAST_SET_IMMEDIATE_ORIGINALS_KEY] ?? (globalThis[FAST_SET_IMMEDIATE_ORIGINALS_KEY] = {
+    setImmediate: globalThis.setImmediate,
+    clearImmediate: globalThis.clearImmediate,
+    nextTick: process.nextTick
+});
 let wasEnabledAtLeastOnce = false;
 let pendingNextTicks = 0;
 let currentExecution = null;
-const originalSetImmediate = globalThis.setImmediate;
-const originalClearImmediate = globalThis.clearImmediate;
-const originalNextTick = process.nextTick;
+const originalSetImmediate = originals.setImmediate;
+const originalClearImmediate = originals.clearImmediate;
+const originalNextTick = originals.nextTick;
+const originalSetImmediatePromisify = typeof originalSetImmediate === 'function' ? originalSetImmediate[_nodeutil.promisify.custom] : // and won't ever enable the patch, so this can be a dummy value
+undefined;
 function install() {
     if (process.env.NEXT_RUNTIME === 'edge') {
         // Nothing to patch. The exported functions all error if used in the edge runtime,
@@ -442,9 +451,7 @@ function patchedSetImmediate() {
 }
 function patchedSetImmediatePromise(value, options) {
     if (currentExecution === null) {
-        const originalPromisify = // @ts-expect-error: the types for `promisify.custom` are strange
-        originalSetImmediate[_nodeutil.promisify.custom];
-        return originalPromisify(value, options);
+        return originalSetImmediatePromisify(value, options);
     }
     return new Promise((resolve, reject)=>{
         // The abort signal makes the promise reject.

package/standalone/node_modules/next/dist/server/node-environment-extensions/{utils.js → io-utils.js}

@@ -87,11 +87,11 @@ function io(expression, type) {
                 break;
             }
         case 'request':
-            if (process.env.NODE_ENV === 'development') {
+            {
                 const stageController = workUnitStore.stagedRendering;
-                if (stageController && stageController.canSyncInterrupt()) {
+                if (stageController && stageController.shouldTrackSyncInterrupt()) {
                     let message;
-                    if (stageController.currentStage === _stagedrendering.RenderStage.Static) {
+                    if (stageController.currentStage === _stagedrendering.RenderStage.Static || stageController.currentStage === _stagedrendering.RenderStage.EarlyStatic) {
                         switch(type){
                             case 'time':
                                 message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing the current time in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-current-time`;
@@ -144,14 +144,23 @@ function io(expression, type) {
                         configurable: true
                     }));
                     stageController.syncInterruptCurrentStageWithReason(syncIOError);
+                    // A build-time validation render uses a 'request' store type, but may be abortable.
+                    // If we're in the second, restarted render of the restart-on-cache miss flow,
+                    // Sync IO is an error, and unlike dev, there's no need to continue the render past the sync IO,
+                    // so we can abort it.
+                    if (workUnitStore.controller && !workUnitStore.controller.signal.aborted) {
+                        workUnitStore.controller.abort(syncIOError);
+                    }
                 }
+                break;
             }
-            break;
+        case 'validation-client':
         case 'prerender-ppr':
         case 'prerender-legacy':
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
+        case 'generate-static-params':
             break;
         default:
             workUnitStore;
@@ -183,4 +192,4 @@ function applyOwnerStack(error) {
     return error;
 }
 
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=io-utils.js.map

package/standalone/node_modules/next/dist/server/node-environment-extensions/node-crypto.js

@@ -9,7 +9,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 if (process.env.NEXT_RUNTIME === 'edge') {
 // nothing to patch
 } else {
@@ -21,7 +21,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
     try {
         const _randomUUID = nodeCrypto.randomUUID;
         nodeCrypto.randomUUID = function randomUUID() {
-            (0, _utils.io)(randomUUIDExpression, 'random');
+            (0, _ioutils.io)(randomUUIDExpression, 'random');
             return _randomUUID.apply(this, arguments);
         };
     } catch  {
@@ -34,7 +34,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         nodeCrypto.randomBytes = function randomBytes() {
             if (typeof arguments[1] !== 'function') {
                 // randomBytes is sync if the second arg is undefined
-                (0, _utils.io)(randomBytesExpression, 'random');
+                (0, _ioutils.io)(randomBytesExpression, 'random');
             }
             return _randomBytes.apply(this, arguments);
         };
@@ -46,7 +46,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         const _randomFillSync = nodeCrypto.randomFillSync;
         // @ts-expect-error -- TODO: tell TS the overloads are preserved
         nodeCrypto.randomFillSync = function randomFillSync() {
-            (0, _utils.io)(randomFillSyncExpression, 'random');
+            (0, _ioutils.io)(randomFillSyncExpression, 'random');
             return _randomFillSync.apply(this, arguments);
         };
     } catch  {
@@ -59,7 +59,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         nodeCrypto.randomInt = function randomInt() {
             if (typeof arguments[2] !== 'function') {
                 // randomInt is sync if the third arg is undefined
-                (0, _utils.io)(randomIntExpression, 'random');
+                (0, _ioutils.io)(randomIntExpression, 'random');
             }
             return _randomInt.apply(this, arguments);
         };
@@ -71,7 +71,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         const _generatePrimeSync = nodeCrypto.generatePrimeSync;
         // @ts-expect-error -- TODO: tell TS the overloads are preserved
         nodeCrypto.generatePrimeSync = function generatePrimeSync() {
-            (0, _utils.io)(generatePrimeSyncExpression, 'random');
+            (0, _ioutils.io)(generatePrimeSyncExpression, 'random');
             return _generatePrimeSync.apply(this, arguments);
         };
     } catch  {
@@ -82,7 +82,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         const _generateKeyPairSync = nodeCrypto.generateKeyPairSync;
         // @ts-expect-error -- TODO: tell TS the overloads are preserved
         nodeCrypto.generateKeyPairSync = function generateKeyPairSync() {
-            (0, _utils.io)(generateKeyPairSyncExpression, 'random');
+            (0, _ioutils.io)(generateKeyPairSyncExpression, 'random');
             return _generateKeyPairSync.apply(this, arguments);
         };
     } catch  {
@@ -92,7 +92,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
     try {
         const _generateKeySync = nodeCrypto.generateKeySync;
         nodeCrypto.generateKeySync = function generateKeySync() {
-            (0, _utils.io)(generateKeySyncExpression, 'random');
+            (0, _ioutils.io)(generateKeySyncExpression, 'random');
             return _generateKeySync.apply(this, arguments);
         };
     } catch  {

package/standalone/node_modules/next/dist/server/node-environment-extensions/process-error-handlers.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installProcessErrorHandlers", {
+    enumerable: true,
+    get: function() {
+        return installProcessErrorHandlers;
+    }
+});
+const _ispostpone = require("../lib/router-utils/is-postpone");
+let _global = globalThis;
+function installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners) {
+    if (_global.nextInitializedProcessErrorHandlers) return;
+    _global.nextInitializedProcessErrorHandlers = true;
+    // The conventional wisdom of Node.js and other runtimes is to treat
+    // unhandled errors as fatal and exit the process.
+    //
+    // But Next.js is not a generic JS runtime — it's a specialized runtime for
+    // React Server Components.
+    //
+    // Many unhandled rejections are due to the late-awaiting pattern for
+    // prefetching data. In Next.js it's OK to call an async function without
+    // immediately awaiting it, to start the request as soon as possible
+    // without blocking unncessarily on the result. These can end up
+    // triggering an "unhandledRejection" if it later turns out that the
+    // data is not needed to render the page. Example:
+    //
+    //     const promise = fetchData()
+    //     const shouldShow = await checkCondition()
+    //     if (shouldShow) {
+    //       return <Component promise={promise} />
+    //     }
+    //
+    // In this example, `fetchData` is called immediately to start the request
+    // as soon as possible, but if `shouldShow` is false, then it will be
+    // discarded without unwrapping its result. If it errors, it will trigger
+    // an "unhandledRejection" event.
+    //
+    // Ideally, we would suppress these rejections completely without warning,
+    // because we don't consider them real errors. (TODO: Currently we do warn.)
+    //
+    // But regardless of whether we do or don't warn, we definitely shouldn't
+    // crash the entire process.
+    //
+    // Even a "legit" unhandled error unrelated to prefetching shouldn't
+    // prevent the rest of the page from rendering.
+    //
+    // So, we're going to intentionally override the default error handling
+    // behavior of the outer JS runtime to be more forgiving
+    // Remove any existing "unhandledRejection" and "uncaughtException" handlers.
+    // This is gated behind an experimental flag until we've considered the impact
+    // in various deployment environments. It's possible this may always need to
+    // be configurable.
+    if (shouldRemoveUncaughtErrorAndRejectionListeners) {
+        process.removeAllListeners('uncaughtException');
+        process.removeAllListeners('unhandledRejection');
+    }
+    // Install a new handler to prevent the process from crashing.
+    process.on('unhandledRejection', (reason)=>{
+        if ((0, _ispostpone.isPostpone)(reason)) {
+            // React postpones that are unhandled might end up logged here but they're
+            // not really errors. They're just part of rendering.
+            return;
+        }
+        // Immediately log the error.
+        // TODO: Ideally, if we knew that this error was triggered by application
+        // code, we would suppress it entirely without logging. We can't reliably
+        // detect all of these, but when cacheComponents is enabled, we could suppress
+        // at least some of them by waiting to log the error until after all in-
+        // progress renders have completed. Then, only log errors for which there
+        // was not a corresponding "rejectionHandled" event.
+        console.error(reason);
+    });
+    process.on('rejectionHandled', ()=>{
+    // TODO: See note in the unhandledRejection handler above. In the future,
+    // we may use the "rejectionHandled" event to de-queue an error from
+    // being logged.
+    });
+    // Unhandled exceptions are errors triggered by non-async functions, so this
+    // is unrelated to the late-awaiting pattern. However, for similar reasons,
+    // we still shouldn't crash the process. Just log it.
+    process.on('uncaughtException', (reason)=>{
+        if ((0, _ispostpone.isPostpone)(reason)) {
+            return;
+        }
+        console.error(reason);
+    });
+}
+
+//# sourceMappingURL=process-error-handlers.js.map

package/standalone/node_modules/next/dist/server/node-environment-extensions/random.js

@@ -8,12 +8,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 const expression = '`Math.random()`';
 try {
     const _random = Math.random;
     Math.random = (function random() {
-        (0, _utils.io)(expression, 'random');
+        (0, _ioutils.io)(expression, 'random');
         return _random.apply(null, arguments);
     // We bind here to alter the `toString` printing to match `Math.random`'s native `toString`.
     // eslint-disable-next-line no-extra-bind

package/standalone/node_modules/next/dist/server/node-environment-extensions/{unhandled-rejection.js → unhandled-rejection.external.js}

@@ -89,6 +89,11 @@ const warnUninstalledOnce = warn ? function warnUninstalledOnce(...args) {
         warn(...args);
     }
 } : undefined;
+// We use a global symbol to detect if the filter has already been installed.
+// If two instances of this module are loaded, each captures the other's handler
+// as an underlying listener, creating mutual recursion that overflows the stack.
+// We error defensively rather than silently degrading.
+const FILTER_INSTALLED_KEY = Symbol.for('next.unhandledRejectionFilter');
 let filterInstalled = false;
 // We store the proxied listeners for unhandled rejections here.
 let underlyingListeners = [];
@@ -143,8 +148,10 @@ const MACGUFFIN_EVENT = 'Next.UnhandledRejectionFilter.MacguffinEvent';
  *
  * This should be called once during server startup to install the global filter.
  */ function installUnhandledRejectionFilter() {
-    if (filterInstalled) {
-        warnWithTrace == null ? void 0 : warnWithTrace('Unexpected subsequent filter installation. This is a bug in Next.js');
+    if (globalThis[FILTER_INSTALLED_KEY] || filterInstalled) {
+        // Already installed by another evaluation of this module in the same
+        // process (e.g., Jest's module system re-evaluating an already-loaded
+        // module). Safe to skip since the filter is already active.
         return;
     }
     debug == null ? void 0 : debug('Installing Filter');
@@ -384,6 +391,7 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
         return originalProcessListeners.call(process, event);
     });
     filterInstalled = true;
+    globalThis[FILTER_INSTALLED_KEY] = true;
 }
 /**
  * Uninstalls the unhandled rejection filter and restores original process methods.
@@ -422,13 +430,20 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
 }
 /**
  * The filtering handler that decides whether to suppress or delegate unhandled rejections.
- */ function filteringUnhandledRejectionHandler(reason, promise) {
+ */ let handlingRejection = false;
+function filteringUnhandledRejectionHandler(reason, promise) {
+    if (handlingRejection) {
+        // An underlying listener synchronously re-emitted 'unhandledRejection'.
+        // Re-entering the listener loop would overflow the stack.
+        return;
+    }
     const capturedListenerMetadata = Array.from(listenerMetadata);
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workUnitStore) {
         switch(workUnitStore.type){
             case 'prerender':
             case 'prerender-client':
+            case 'validation-client':
             case 'prerender-runtime':
                 {
                     const signal = workUnitStore.renderSignal;
@@ -445,6 +460,7 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;
@@ -460,6 +476,7 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
         // do not automatically terminate the process.
         console.error('Unhandled Rejection:', reason);
     } else {
+        handlingRejection = true;
         try {
             for (const meta of capturedListenerMetadata){
                 if (meta.once) {
@@ -478,6 +495,8 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
             setImmediate(()=>{
                 throw error;
             });
+        } finally{
+            handlingRejection = false;
         }
     }
 }
@@ -486,4 +505,4 @@ if (ENABLE_UHR_FILTER) {
     installUnhandledRejectionFilter();
 }
 
-//# sourceMappingURL=unhandled-rejection.js.map
+//# sourceMappingURL=unhandled-rejection.external.js.map

package/standalone/node_modules/next/dist/server/node-environment-extensions/web-crypto.js

@@ -9,7 +9,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 let webCrypto;
 if (process.env.NEXT_RUNTIME === 'edge') {
     webCrypto = crypto;
@@ -25,7 +25,7 @@ const getRandomValuesExpression = '`crypto.getRandomValues()`';
 try {
     const _getRandomValues = webCrypto.getRandomValues;
     webCrypto.getRandomValues = function getRandomValues() {
-        (0, _utils.io)(getRandomValuesExpression, 'crypto');
+        (0, _ioutils.io)(getRandomValuesExpression, 'crypto');
         return _getRandomValues.apply(webCrypto, arguments);
     };
 } catch  {
@@ -35,7 +35,7 @@ const randomUUIDExpression = '`crypto.randomUUID()`';
 try {
     const _randomUUID = webCrypto.randomUUID;
     webCrypto.randomUUID = function randomUUID() {
-        (0, _utils.io)(randomUUIDExpression, 'crypto');
+        (0, _ioutils.io)(randomUUIDExpression, 'crypto');
         return _randomUUID.apply(webCrypto, arguments);
     };
 } catch  {

package/standalone/node_modules/next/dist/server/node-environment.js

@@ -9,7 +9,7 @@ require("./node-environment-extensions/error-inspect");
 require("./node-environment-extensions/console-file");
 require("./node-environment-extensions/console-exit");
 require("./node-environment-extensions/console-dim.external");
-require("./node-environment-extensions/unhandled-rejection");
+require("./node-environment-extensions/unhandled-rejection.external");
 require("./node-environment-extensions/random");
 require("./node-environment-extensions/date");
 require("./node-environment-extensions/web-crypto");

package/standalone/node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.js

@@ -9,7 +9,8 @@ Object.defineProperty(exports, "SegmentPrefixRSCPathnameNormalizer", {
     }
 });
 const _constants = require("../../../lib/constants");
-const PATTERN = new RegExp(`^(/.*)${_constants.RSC_SEGMENTS_DIR_SUFFIX}(/.*)${_constants.RSC_SEGMENT_SUFFIX}$`);
+const _escaperegexp = require("../../../shared/lib/escape-regexp");
+const PATTERN = new RegExp(`^(/.*)${(0, _escaperegexp.escapeStringRegexp)(_constants.RSC_SEGMENTS_DIR_SUFFIX)}(/.*)${(0, _escaperegexp.escapeStringRegexp)(_constants.RSC_SEGMENT_SUFFIX)}$`);
 class SegmentPrefixRSCPathnameNormalizer {
     match(pathname) {
         return PATTERN.test(pathname);

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

@@ -5,7 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     patchErrorInspectEdgeLite: null,
     patchErrorInspectNodeJS: null,
-    setBundlerFindSourceMapImplementation: null
+    setBundlerFindSourceMapImplementation: null,
+    setCodeFrameRenderer: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -22,6 +23,9 @@ _export(exports, {
     },
     setBundlerFindSourceMapImplementation: function() {
         return setBundlerFindSourceMapImplementation;
+    },
+    setCodeFrameRenderer: function() {
+        return setCodeFrameRenderer;
     }
 });
 const _module = require("module");
@@ -30,7 +34,6 @@ const _url = /*#__PURE__*/ _interop_require_wildcard(require("url"));
 const _sourcemap = require("next/dist/compiled/source-map");
 const _sourcemaps = require("./lib/source-maps");
 const _parsestack = require("./lib/parse-stack");
-const _shared = require("../next-devtools/server/shared");
 const _workunitasyncstorageexternal = require("./app-render/work-unit-async-storage.external");
 const _picocolors = require("../lib/picocolors");
 function _getRequireWildcardCache(nodeInterop) {
@@ -82,6 +85,17 @@ let bundlerFindSourceMapPayload = ()=>undefined;
 function setBundlerFindSourceMapImplementation(findSourceMapImplementation) {
     bundlerFindSourceMapPayload = findSourceMapImplementation;
 }
+let codeFrameRenderer;
+function setCodeFrameRenderer(renderer) {
+    codeFrameRenderer = renderer;
+}
+function getOriginalCodeFrame(frame, source, colors = process.stdout.isTTY) {
+    if (!codeFrameRenderer) {
+        // No renderer available - gracefully degrade
+        return null;
+    }
+    return codeFrameRenderer(frame, source, colors);
+}
 function frameToString(methodName, sourceURL, line1, column1) {
     let sourceLocation = line1 !== null ? `:${line1}` : '';
     if (column1 !== null && sourceLocation !== '') {
@@ -189,11 +203,15 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
         sourceMapPayload = maybeSourceMapPayload;
         try {
             // Pass the source map URL as the second parameter so that the consumer
-            // can resolve relative paths in the source map's `sources` array.
-            // This is a guess!  Turbopack places .map files as siblings to the chunks so this is sufficient to compute
-            // relative paths but is actually wrong (the chunk and sourcemap have different content hashes).
-            // We are using the node API to read the sourcemap and it doesn't give us access to the URI.
-            const sourceMapURL = sourceURL + '.map';
+            // can resolve relative paths in the source map's `sources` array. This is
+            // a guess! Turbopack places .map files as siblings to the chunks so this
+            // is sufficient to compute relative paths but is actually wrong (the
+            // chunk and sourcemap have different content hashes). We are using the
+            // node API to read the sourcemap and it doesn't give us access to the
+            // URI. Devirtualize `about://React/Server/file:///path/to/chunk.js?4` to
+            // `file:///path/to/chunk.js` so that relative `sources` in the source map
+            // resolve against the real chunk URL, not the virtual one.
+            const sourceMapURL = (0, _sourcemaps.devirtualizeReactServerURL)(sourceURL) + '.map';
             sourceMapConsumer = new _sourcemap.SourceMapConsumer(sourceMapPayload, // @ts-expect-error: our typings don't include this parameter but it is here.
             sourceMapURL);
         } catch (cause) {
@@ -267,19 +285,17 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
         arguments: [],
         ignored
     };
-    /** undefined = not yet computed*/ let codeFrame;
-    return Object.defineProperty({
+    /** undefined = not yet computed */ let codeFrame;
+    return {
         stack: originalFrame,
-        code: null
-    }, 'code', {
-        get: ()=>{
+        get code () {
             if (codeFrame === undefined) {
                 const sourceContent = sourceMapConsumer.sourceContentFor(sourcePosition.source, /* returnNullOnMissing */ true) ?? null;
-                codeFrame = (0, _shared.getOriginalCodeFrame)(originalFrame, sourceContent, inspectOptions.colors);
+                codeFrame = getOriginalCodeFrame(originalFrame, sourceContent, inspectOptions.colors);
             }
             return codeFrame;
         }
-    });
+    };
 }
 function parseAndSourceMap(error, inspectOptions) {
     const showIgnoreListed = process.env.__NEXT_SHOW_IGNORE_LISTED === 'true';
@@ -355,15 +371,17 @@ function parseAndSourceMap(error, inspectOptions) {
     return errorName + ': ' + error.message + sourceMappedStack + (sourceFrame !== null ? '\n' + sourceFrame : '');
 }
 function sourceMapError(error, inspectOptions) {
+    // Setting an undefined `cause` would print `[cause]: undefined`
+    const options = error.cause !== undefined ? {
+        cause: error.cause
+    } : undefined;
     // Create a new Error object with the source mapping applied and then use native
     // Node.js formatting on the result.
-    const newError = error.cause !== undefined ? Object.defineProperty(new Error(error.message, {
-        cause: error.cause
-    }), "__NEXT_ERROR_CODE", {
+    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), "__NEXT_ERROR_CODE", {
+    }) : Object.defineProperty(new Error(error.message, options), "__NEXT_ERROR_CODE", {
         value: "E394",
         enumerable: false,
         configurable: true
@@ -398,8 +416,7 @@ function patchErrorInspectNodeJS(errorConstructor) {
             try {
                 return inspect(newError, {
                     ...inspectOptions,
-                    depth: (inspectOptions.depth ?? // Default in Node.js
-                    2) - depth
+                    depth
                 });
             } finally{
                 ;

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

@@ -122,6 +122,15 @@ class RenderResult {
         }
     }
     /**
+   * Pipes the response through a transform stream. This converts the response
+   * to a single readable stream (chaining if needed) and pipes it through the
+   * provided transform.
+   *
+   * @param transform The transform stream to pipe through
+   */ pipeThrough(transform) {
+        this.response = this.readable.pipeThrough(transform);
+    }
+    /**
    * Unshifts a new stream to the response. This will convert the response to an
    * array of streams if it is not already one and will add the new stream to
    * the start of the array. When this response is piped, all of the streams