@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/server/og/cache-image-response.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCachedImageResponseBody", {
+    enumerable: true,
+    get: function() {
+        return getCachedImageResponseBody;
+    }
+});
+const _nodestream = require("node:stream");
+const _nodecrypto = require("node:crypto");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _manifestssingleton = require("../app-render/manifests-singleton");
+const _static = require("react-server-dom-webpack/static");
+const _client = require("react-server-dom-webpack/client");
+function importOgModule() {
+    // Cache Components is Node-only (rejected for the edge runtime at compile
+    // time), so we always load the Node build. Loading it dynamically keeps the
+    // heavy `@vercel/og` renderer (satori + WASM) off the module-load path, so
+    // it's pulled in only when an image is actually rendered.
+    return import('next/dist/compiled/@vercel/og/index.node.js');
+}
+function getCachedImageResponseBody(args) {
+    return new ReadableStream({
+        async start (controller) {
+            const arrayBuffer = await getCachedImageResponseArrayBuffer(args);
+            if (arrayBuffer.byteLength > 0) {
+                controller.enqueue(new Uint8Array(arrayBuffer));
+            }
+            controller.close();
+        }
+    });
+}
+async function getCachedImageResponseArrayBuffer(args) {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    switch(workUnitStore == null ? void 0 : workUnitStore.type){
+        case 'prerender':
+            break;
+        case undefined:
+        case 'request':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'prerender-runtime':
+        case 'prerender-client':
+        case 'validation-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+        case 'generate-static-params':
+            return renderImageResponseArrayBuffer(args);
+        default:
+            return workUnitStore;
+    }
+    const { cacheSignal, resumeDataCache, renderSignal } = workUnitStore;
+    if (!resumeDataCache) {
+        return renderImageResponseArrayBuffer(args);
+    }
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected a work store while caching an `ImageResponse` during prerendering.'), "__NEXT_ERROR_CODE", {
+            value: "E1382",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const [element, options] = args;
+    // `createHangingInputAbortSignal` aborts once the prerender's cache-sourced
+    // input is ready, so anything the serialization below is still awaiting past
+    // that point can be treated as dynamic (non-cache) input. In the prospective
+    // pass it aborts when `cacheSignal.inputReady()` resolves (no cache reads
+    // in progress); in the final pass the caches are already filled, so it just
+    // aborts on the next tick.
+    const hangingInputAbortSignal = (0, _dynamicrendering.createHangingInputAbortSignal)(workUnitStore);
+    // We open the cache read lazily, once we know the serialization completed and
+    // we're about to render and store the image. Opening it before serializing
+    // would keep `cacheSignal.inputReady()` from resolving and thus prevent the
+    // abort signal from ever firing, deadlocking the prospective prerender.
+    let readState = 'ready';
+    function beginReadOnce() {
+        if (readState === 'ready') {
+            readState = 'pending';
+            cacheSignal == null ? void 0 : cacheSignal.beginRead();
+        }
+    }
+    function endReadIfStarted() {
+        if (readState === 'pending') {
+            cacheSignal == null ? void 0 : cacheSignal.endRead();
+        }
+        readState = 'done';
+    }
+    // We serialize the element tree with `prerenderToNodeStream` rather than
+    // `renderToPipeableStream`. It's the right fit for prerendering, and it
+    // schedules work deferred for size (`deferTask`) on microtasks, so a fully
+    // static tree finishes flushing before the abort signal fires; a tree still
+    // pending at abort time is then genuinely waiting on dynamic input rather
+    // than just deferred.
+    //
+    // `renderToPipeableStream` would schedule that deferred work on
+    // `setImmediate` instead, which isn't necessarily a deal-breaker: the
+    // sequential-task scheme page rendering uses (`runInSequentialTasks`) drains
+    // pending immediates at each task boundary, so deferred work still runs in
+    // time. But route handler prerendering doesn't use that scheme, so here the
+    // deferred immediates would race the abort.
+    //
+    // The prerender halts silently on abort, leaving unfulfilled references in
+    // place rather than reporting through `onError`. So to tell a halt (the tree
+    // needed dynamic input) apart from a normal completion, we record whether the
+    // abort fired before the serialization finished. `abort()` runs this listener
+    // synchronously, well before we read `resultIsPartial` below.
+    let prerenderCompleted = false;
+    let resultIsPartial = false;
+    let serializationError;
+    hangingInputAbortSignal.addEventListener('abort', ()=>{
+        if (!prerenderCompleted) {
+            resultIsPartial = true;
+        }
+    }, {
+        once: true
+    });
+    const { clientModules, rscModuleMapping } = (0, _manifestssingleton.getClientReferenceManifest)();
+    try {
+        // We serialize only the `element`. It's the part that needs Flight, to run
+        // its async Server Components once and to surface any dynamic input. The
+        // `options` are already-resolved plain data; they're folded into the cache
+        // key directly and passed to satori as-is below.
+        const { prelude } = await (0, _static.prerenderToNodeStream)(element, clientModules, {
+            signal: hangingInputAbortSignal,
+            filterStackFrame: undefined,
+            onError (error) {
+                // A halt (our deliberate abort) emits nothing, so this is only called
+                // for genuine serialization errors. We surface the first one.
+                if (serializationError === undefined && !resultIsPartial) {
+                    serializationError = error;
+                }
+            }
+        });
+        prerenderCompleted = true;
+        if (serializationError !== undefined) {
+            throw serializationError;
+        }
+        if (resultIsPartial) {
+            // The element tree needed dynamic input (e.g. `cookies()` or an uncached
+            // `fetch`), so the image can't be produced statically. Return a hanging
+            // promise: the body never resolves, and the final prerender's macrotask
+            // budget then classifies the route as dynamic.
+            // Whatever dynamic input made the element partial already classified
+            // itself when it created its own hanging promise (cookies() creates a
+            // runtime hanging promise, an uncached fetch creates a dynamic one,
+            // ...), so this wrapper adds no new information and can use the
+            // non-recording dynamic variant.
+            return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(renderSignal, workStore.route, 'dynamic `ImageResponse`');
+        }
+        // The serialization finished before any dynamic input was needed, so we
+        // will render and cache the image. Hold the cache read now, before the
+        // stream is buffered and deserialized below, so that the prospective
+        // prerender's `cacheReady()` waits for the image to be stored.
+        beginReadOnce();
+        const chunks = [];
+        for await (const chunk of prelude){
+            chunks.push(chunk);
+        }
+        const elementBuffer = Buffer.concat(chunks);
+        // Derive a stable cache key from the serialized element plus the options.
+        // We hash rather than reuse the raw serialized bytes so the key stays
+        // compact even for large inputs (e.g. embedded fonts), and we fold the
+        // options in by content so two images that differ only in their options
+        // (size, fonts, ...) don't collide. The options are hashed directly here,
+        // never serialized through Flight, which would both bloat the key and apply
+        // `Buffer.prototype .toJSON` to font data.
+        const hash = (0, _nodecrypto.createHash)('sha256');
+        hash.update(elementBuffer);
+        updateHashWithOptions(hash, options);
+        const cacheKey = hash.digest('base64');
+        const cached = resumeDataCache.imageResponses.get(cacheKey);
+        if (cached) {
+            return await cached;
+        }
+        // Deserialize the element and hand it to satori. Because the user's
+        // components already ran during serialization, satori only walks resolved
+        // host elements and never re-runs them, confining user-space I/O to the
+        // in-store serialization above.
+        const deserializedElement = await (0, _client.createFromNodeStream)(_nodestream.Readable.from([
+            elementBuffer
+        ]), {
+            // We don't want to trigger preloads of client references here.
+            moduleLoading: null,
+            moduleMap: rscModuleMapping,
+            serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
+        }, {
+            findSourceMapURL: undefined
+        });
+        // The Flight client hands back the output of an async Server Component as
+        // a `React.lazy` (sync components and plain host elements are inlined).
+        // satori can't unwrap lazies, so we resolve them into plain elements first.
+        // We only reach here once the serialization completed, so every lazy is
+        // already resolved and `_init` returns synchronously.
+        const resolvedElement = resolveFlightLazies(deserializedElement);
+        // Pair the resolved element with the original, in-memory `options`, which
+        // never went through Flight. This keeps the font `Buffer` intact: had it
+        // been serialized, Flight would apply the `toJSON` method that Node's
+        // `Buffer` carries, turning it into a `{ type: 'Buffer', data: [...] }`
+        // object that satori's font parser rejects (it needs an `ArrayBuffer` or a
+        // typed array).
+        const resolvedArgs = [
+            resolvedElement,
+            options
+        ];
+        // Render satori outside the prerender work-unit store. It does uncached
+        // `fetch` calls (e.g. loading a font), and inside a Cache Components
+        // prerender an uncached `fetch` outside a cache scope becomes a hanging
+        // promise. Those are framework fetches, not user I/O, so we let them
+        // resolve normally with no store.
+        const arrayBufferPromise = _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>renderImageResponseArrayBuffer(resolvedArgs));
+        if (resumeDataCache.mutable) {
+            resumeDataCache.imageResponses.set(cacheKey, arrayBufferPromise);
+        }
+        return await arrayBufferPromise;
+    } finally{
+        endReadIfStarted();
+    }
+}
+/**
+ * Updates a hash with a stable encoding of the `ImageResponse` options so they
+ * can participate in the cache key without being serialized through Flight.
+ * Binary values (font `Buffer`s, `ArrayBuffer`s, typed arrays) are hashed by
+ * their raw bytes; objects are walked in sorted-key order.
+ *
+ * `ImageResponse` options are plain data: numbers, strings, booleans, nested
+ * plain objects/arrays, and binary font data. Exotic objects such as `Map` or
+ * `Date` keep their state outside their enumerable own keys, so the key walk
+ * below would hash them incorrectly. Options never contain these, but we warn
+ * if one ever shows up so a mis-keyed cache can be reported.
+ *
+ * The encoding is self-delimiting: every node starts with a type tag, and
+ * variable-length parts (byte runs, primitives, keys) are length-prefixed,
+ * while arrays and objects are count-prefixed. This makes it injective, so no
+ * concatenation of values can be mistaken for a differently shaped input.
+ */ function updateHashWithOptions(hash, value) {
+    if (value === undefined) {
+        hash.update('u');
+        return;
+    }
+    if (value === null) {
+        hash.update('n');
+        return;
+    }
+    const type = typeof value;
+    if (type !== 'object') {
+        // Tag with the primitive type so e.g. the number `1` and the string `'1'`
+        // don't hash the same.
+        updateHashWithBytes(hash, 'p', Buffer.from(`${type}:${String(value)}`));
+        return;
+    }
+    if (value instanceof ArrayBuffer) {
+        updateHashWithBytes(hash, 'a', new Uint8Array(value));
+        return;
+    }
+    if (ArrayBuffer.isView(value)) {
+        updateHashWithBytes(hash, 'v', new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+        return;
+    }
+    if (Array.isArray(value)) {
+        hash.update(`[${value.length},`);
+        for (const item of value){
+            updateHashWithOptions(hash, item);
+        }
+        return;
+    }
+    // The key walk below captures a plain object faithfully, but an exotic object
+    // keeps its state elsewhere (a `Map`'s/`Set`'s entries, a `Date`'s time), so
+    // two different values would hash the same and could return the wrong cached
+    // image. This shouldn't happen for `ImageResponse` options, so we warn rather
+    // than fail, then hash best-effort, so it can be reported. Not gated on
+    // `NODE_ENV`: this runs during the production `next build` prerender, where
+    // the warning is most useful.
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        var _value_constructor;
+        const typeName = ((_value_constructor = value.constructor) == null ? void 0 : _value_constructor.name) ?? 'object';
+        console.warn(`Cannot reliably include an \`ImageResponse\` option of type ` + `\`${typeName}\` in the cache key, so different images may collide and ` + `return an incorrect cached result. Please report this to the Next.js ` + `team.`);
+    }
+    const keys = Object.keys(value).sort();
+    hash.update(`{${keys.length},`);
+    for (const key of keys){
+        updateHashWithBytes(hash, 'k', Buffer.from(key));
+        updateHashWithOptions(hash, value[key]);
+    }
+}
+/**
+ * Hashes a length-prefixed, tagged byte run: `<tag><byteLength>:<bytes>`. The
+ * length prefix keeps the run self-delimiting so it can't blend into adjacent
+ * nodes.
+ */ function updateHashWithBytes(hash, tag, bytes) {
+    hash.update(`${tag}${bytes.byteLength}:`);
+    hash.update(bytes);
+}
+async function renderImageResponseArrayBuffer(args) {
+    const OGImageResponse = (await importOgModule()).ImageResponse;
+    const imageResponse = new OGImageResponse(...args);
+    if (!imageResponse.body) {
+        return new ArrayBuffer(0);
+    }
+    return imageResponse.arrayBuffer();
+}
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+/**
+ * Recursively replaces the `React.lazy` references that Flight emits for
+ * resolved async Server Components with the elements they resolve to, so that
+ * satori (which doesn't understand lazy nodes) can walk the tree. This must
+ * only be called on a fully resolved (completed) Flight result, where each
+ * lazy's `_init` returns synchronously rather than suspending.
+ */ function resolveFlightLazies(node) {
+    if (node === null || typeof node !== 'object') {
+        return node;
+    }
+    if (node.$$typeof === REACT_LAZY_TYPE) {
+        const lazy = node;
+        return resolveFlightLazies(lazy._init(lazy._payload));
+    }
+    if (Array.isArray(node)) {
+        return node.map(resolveFlightLazies);
+    }
+    const element = node;
+    if (element.props && 'children' in element.props) {
+        return {
+            ...element,
+            props: {
+                ...element.props,
+                children: resolveFlightLazies(element.props.children)
+            }
+        };
+    }
+    return node;
+}
+
+//# sourceMappingURL=cache-image-response.js.map

package/dist/node_modules/next/dist/server/og/image-response.js

@@ -11,13 +11,32 @@ Object.defineProperty(exports, "ImageResponse", {
 function importModule() {
     return import(process.env.NEXT_RUNTIME === 'edge' ? 'next/dist/compiled/@vercel/og/index.edge.js' : 'next/dist/compiled/@vercel/og/index.node.js');
 }
+// The Cache Components-specific caching path (and its React Flight and Node
+// stream dependencies) lives in a separate module that is only required for
+// Node.js Cache Components builds. The `NEXT_RUNTIME` guard matters because
+// `__NEXT_CACHE_COMPONENTS` is derived from config, not the per-route runtime,
+// so it stays `true` in edge bundles too. A Pages Router edge route that
+// renders an `ImageResponse` is valid under Cache Components, and without the
+// guard this node-only module would be pulled into that edge bundle and fail to
+// compile. (App Router edge routes, including metadata routes, are
+// independently rejected at compile time under Cache Components.) Both checks
+// fold to constants at build time, so the `require` is eliminated as dead code
+// for edge builds and for apps without Cache Components, which keep
+// ImageResponse's original streaming behavior.
+let getCachedImageResponseBody;
+if (process.env.NEXT_RUNTIME !== 'edge' && process.env.__NEXT_CACHE_COMPONENTS) {
+    getCachedImageResponseBody = require('./cache-image-response').getCachedImageResponseBody;
+}
 class ImageResponse extends Response {
     static #_ = this.displayName = 'ImageResponse';
     constructor(...args){
-        const readable = new ReadableStream({
+        // Under Cache Components, route the render through the cache so metadata
+        // image routes can be statically prerendered. Otherwise stream the rendered
+        // image directly from the underlying `@vercel/og` response.
+        const readable = getCachedImageResponseBody ? getCachedImageResponseBody(args) : new ReadableStream({
             async start (controller) {
-                const OGImageResponse = // So far we have to manually determine which build to use,
-                // as the auto resolving is not working
+                const OGImageResponse = // So far we have to manually determine which build to use, as the
+                // auto resolving is not working
                 (await importModule()).ImageResponse;
                 const imageResponse = new OGImageResponse(...args);
                 if (!imageResponse.body) {

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

@@ -28,7 +28,6 @@ _export(exports, {
         return setCodeFrameRenderer;
     }
 });
-const _module = require("module");
 const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 const _url = /*#__PURE__*/ _interop_require_wildcard(require("url"));
 const _sourcemap = require("next/dist/compiled/source-map");
@@ -81,21 +80,63 @@ function _interop_require_wildcard(obj, nodeInterop) {
 // This is only a fallback for when Node.js fails to due to bugs e.g. https://github.com/nodejs/node/issues/52102
 // TODO: Remove once all supported Node.js versions are fixed.
 // TODO(veil): Set from Webpack as well
-let bundlerFindSourceMapPayload = ()=>undefined;
+//
+// Stored on `globalThis` for the same reason as the code frame renderer below:
+// this module is bundled into several runtimes that each get their own copy,
+// and the copy that installs the implementation is not necessarily the one that
+// symbolicates a frame. The dev validation worker depends on that, because it
+// installs its implementation from the worker bundle while the frames are
+// symbolicated by the app-page bundle's copy.
+const BUNDLER_FIND_SOURCE_MAP = Symbol.for('next.dev.bundlerFindSourceMap');
 function setBundlerFindSourceMapImplementation(findSourceMapImplementation) {
-    bundlerFindSourceMapPayload = findSourceMapImplementation;
+    ;
+    globalThis[BUNDLER_FIND_SOURCE_MAP] = findSourceMapImplementation;
 }
-let codeFrameRenderer;
+function bundlerFindSourceMapPayload(sourceURL) {
+    var _globalThis_BUNDLER_FIND_SOURCE_MAP;
+    return (_globalThis_BUNDLER_FIND_SOURCE_MAP = globalThis[BUNDLER_FIND_SOURCE_MAP]) == null ? void 0 : _globalThis_BUNDLER_FIND_SOURCE_MAP.call(globalThis, sourceURL);
+}
+// The code-frame renderer is stored on `globalThis` rather than in a module
+// variable because this module is bundled into several runtimes (the dev
+// server, the app-page runtime bundle, and the dev worker bundles) that each
+// get their own copy. `Error.prepareStackTrace` is a single process-global, so
+// whichever copy patched it last is the one that renders errors, which may not
+// be the copy `setCodeFrameRenderer` was called on. Sharing the renderer
+// through a `globalThis` symbol lets any copy install it and any copy read it.
+const CODE_FRAME_RENDERER = Symbol.for('next.dev.codeFrameRenderer');
 function setCodeFrameRenderer(renderer) {
-    codeFrameRenderer = renderer;
+    ;
+    globalThis[CODE_FRAME_RENDERER] = renderer;
 }
 function getOriginalCodeFrame(frame, source, colors = process.stdout.isTTY) {
+    const codeFrameRenderer = globalThis[CODE_FRAME_RENDERER];
     if (!codeFrameRenderer) {
         // No renderer available - gracefully degrade
         return null;
     }
     return codeFrameRenderer(frame, source, colors);
 }
+// Constructing a consumer indexes the whole payload — expensive for large
+// chunk maps and previously paid per frame — so consumers are shared across
+// all frames and errors whose lookups returned the same payload. The inner
+// key is the URL the consumer resolves relative `sources` against.
+const sourceMapConsumers = new WeakMap();
+function getOrCreateSourceMapConsumer(payload, sourceMapURL) {
+    let consumersByURL = sourceMapConsumers.get(payload);
+    let consumer = consumersByURL == null ? void 0 : consumersByURL.get(sourceMapURL);
+    if (consumer === undefined) {
+        consumer = new _sourcemap.SourceMapConsumer(payload, // @ts-expect-error: our typings don't include this parameter but it is here.
+        sourceMapURL);
+        if (consumersByURL === undefined) {
+            consumersByURL = new Map();
+            // Throws for payloads that aren't objects; those are invalid source
+            // maps anyway, and the caller reports them.
+            sourceMapConsumers.set(payload, consumersByURL);
+        }
+        consumersByURL.set(sourceMapURL, consumer);
+    }
+    return consumer;
+}
 function frameToString(methodName, sourceURL, line1, column1) {
     let sourceLocation = line1 !== null ? `:${line1}` : '';
     if (column1 !== null && sourceLocation !== '') {
@@ -164,7 +205,10 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
     let sourceMapConsumer;
     let sourceMapPayload;
     if (sourceMapCacheEntry === undefined) {
-        let sourceURL = frame.file;
+        // Fake frame scripts (`about://React/Server/file:///path/to/chunk.js?42`)
+        // have their positions padded to match the underlying chunk, so they
+        // resolve via the chunk's source map.
+        let sourceURL = (0, _sourcemaps.devirtualizeReactServerURL)(frame.file);
         // e.g. "/Users/foo/APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js"
         // or "C:\Users\foo\APP\.next\server\chunks\ssr\[root-of-the-server]__2934a0._.js"
         // will be keyed by Node.js as "file:///APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js".
@@ -172,13 +216,25 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
         //
         // But frame.file might also be "webpack-internal:///(rsc)/./app/bad-sourcemap/page.js" or
         // "<anonymous>" or "node:internal/process/task_queues" here
-        if (_path.isAbsolute(frame.file)) {
-            sourceURL = _url.pathToFileURL(frame.file).toString();
+        if (_path.isAbsolute(sourceURL)) {
+            sourceURL = _url.pathToFileURL(sourceURL).toString();
         }
         let maybeSourceMapPayload;
         try {
-            const sourceMap = (0, _module.findSourceMap)(sourceURL);
-            maybeSourceMapPayload = sourceMap == null ? void 0 : sourceMap.payload;
+            maybeSourceMapPayload = (0, _sourcemaps.findSourceMapPayload)(sourceURL);
+            if (maybeSourceMapPayload === undefined && sourceURL.startsWith('file://')) {
+                // Devirtualizing React's fake frame URL decodes the path, while Node.js
+                // keys its source map cache by the `pathToFileURL` encoding of the same
+                // path, so a path containing characters that encoding escapes (such as
+                // the brackets in Turbopack's `[root-of-the-server]` chunks) misses
+                // above. Node.js also accepts the plain path, which is unambiguous for
+                // both interpretations, so retry with that before giving up.
+                //
+                // TODO(veil): Making React's fake frame URLs reversible, as proposed in
+                // https://github.com/react/react/pull/37105, would let the first lookup
+                // succeed on its own and retire this retry.
+                maybeSourceMapPayload = (0, _sourcemaps.findSourceMapPayload)(_url.fileURLToPath(sourceURL));
+            }
         } catch (cause) {
             // We should not log an actual error instance here because that will re-enter
             // this codepath during error inspection and could lead to infinite recursion.
@@ -208,12 +264,10 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
             // 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);
+            // URI. `sourceURL` is already devirtualized so that relative `sources`
+            // resolve against the real chunk URL, not React's virtual one.
+            const sourceMapURL = sourceURL + '.map';
+            sourceMapConsumer = getOrCreateSourceMapConsumer(sourceMapPayload, sourceMapURL);
         } catch (cause) {
             // We should not log an actual error instance here because that will re-enter
             // this codepath during error inspection and could lead to infinite recursion.

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     isAbortError: null,
+    pipeNodeReadableToNodeResponse: null,
     pipeToNodeResponse: null
 });
 function _export(target, all) {
@@ -16,6 +17,9 @@ _export(exports, {
     isAbortError: function() {
         return isAbortError;
     },
+    pipeNodeReadableToNodeResponse: function() {
+        return pipeNodeReadableToNodeResponse;
+    },
     pipeToNodeResponse: function() {
         return pipeToNodeResponse;
     }
@@ -28,6 +32,7 @@ const _clientcomponentrendererlogger = require("./client-component-renderer-logg
 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) {
     let started = false;
     // Create a promise that will resolve once the response has drained. See
@@ -57,7 +62,7 @@ function createWriterFromResponse(res, waitUntilForEnd) {
             // started writing chunks.
             if (!started) {
                 started = true;
-                if ('performance' in globalThis && process.env.NEXT_OTEL_PERFORMANCE_PREFIX) {
+                if (HAS_CLIENT_COMPONENT_METRICS_ENABLED) {
                     const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)();
                     if (metrics) {
                         performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, {
@@ -136,5 +141,72 @@ async function pipeToNodeResponse(readable, res, waitUntilForEnd) {
         });
     }
 }
+async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd) {
+    try {
+        const { errored, destroyed } = res;
+        if (errored || destroyed) return;
+        let started = false;
+        const finished = new _detachedpromise.DetachedPromise();
+        res.once('close', ()=>{
+            readable.destroy();
+            finished.resolve();
+        });
+        readable.on('data', (chunk)=>{
+            if (!started) {
+                started = true;
+                if ('performance' in globalThis && process.env.NEXT_OTEL_PERFORMANCE_PREFIX) {
+                    const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)();
+                    if (metrics) {
+                        performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, {
+                            start: metrics.clientComponentLoadStart,
+                            end: metrics.clientComponentLoadStart + metrics.clientComponentLoadTimes
+                        });
+                    }
+                }
+                res.flushHeaders();
+                (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.startResponse, {
+                    spanName: 'start response'
+                }, ()=>undefined);
+            }
+            const ok = res.write(chunk);
+            if ('flush' in res && typeof res.flush === 'function') {
+                res.flush();
+            }
+            if (!ok) {
+                readable.pause();
+                res.once('drain', ()=>{
+                    readable.resume();
+                });
+            }
+        });
+        readable.on('end', async ()=>{
+            if (waitUntilForEnd) {
+                await waitUntilForEnd;
+            }
+            if (!res.writableFinished) {
+                res.end();
+            }
+            finished.resolve();
+        });
+        readable.on('error', (err)=>{
+            if (isAbortError(err)) {
+                finished.resolve();
+                return;
+            }
+            res.destroy(err);
+            finished.resolve();
+        });
+        await finished.promise;
+    } catch (err) {
+        if (isAbortError(err)) return;
+        throw Object.defineProperty(new Error('failed to pipe response', {
+            cause: err
+        }), "__NEXT_ERROR_CODE", {
+            value: "E180",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
 
 //# sourceMappingURL=pipe-readable.js.map