@evoscientist/webui 0.2.4 → 0.2.6

package/dist/node_modules/next/dist/server/app-render/action-handler.js

@@ -25,6 +25,7 @@ const _httpaccessfallback = require("../../client/components/http-access-fallbac
 const _redirect = require("../../client/components/redirect");
 const _redirecterror = require("../../client/components/redirect-error");
 const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
+const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
 const _flightrenderresult = require("./flight-render-result");
 const _utils = require("../lib/server-ipc/utils");
 const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
@@ -125,7 +126,6 @@ function addRevalidationHeader(res, { workStore, requestStore }) {
 /**
  * Forwards a server action request to a separate worker. Used when the requested action is not available in the current worker.
  */ async function createForwardedActionResponse(req, res, host, workerPathname, basePath) {
-    var _getRequestMeta;
     if (!host) {
         throw Object.defineProperty(new Error('Invariant: Missing `host` header from a forwarded Server Actions request.'), "__NEXT_ERROR_CODE", {
             value: "E226",
@@ -138,13 +138,35 @@ function addRevalidationHeader(res, { workStore, requestStore }) {
     // we use this to skip rendering the flight tree so that we don't update the UI
     // with the response from the forwarded worker
     forwardedHeaders.set('x-action-forwarded', '1');
-    const proto = ((_getRequestMeta = (0, _requestmeta.getRequestMeta)(req, 'initProtocol')) == null ? void 0 : _getRequestMeta.replace(/:+$/, '')) || 'https';
-    // For standalone or the serverful mode, use the internal origin directly
-    // other than the host headers from the request.
-    const origin = process.env.__NEXT_PRIVATE_ORIGIN || `${proto}://${host.value}`;
+    // TODO: Remove __NEXT_PRIVATE_ORIGIN
+    let origin = process.env.__NEXT_PRIVATE_ORIGIN;
+    if (origin === undefined) {
+        const initUrl = (0, _requestmeta.getRequestMeta)(req, 'initURL');
+        if (initUrl !== undefined) {
+            try {
+                const parsedUrl = new URL(initUrl);
+                origin = parsedUrl.origin;
+            } catch (error) {
+                throw Object.defineProperty(new Error('Could not determine origin for forwarded Server Actions request. This can happen if port or hostname are not configured for this server.', {
+                    cause: error
+                }), "__NEXT_ERROR_CODE", {
+                    value: "E1447",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        } else {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Missing initURL'), "__NEXT_ERROR_CODE", {
+                value: "E1446",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
     const fetchUrl = new URL(`${origin}${basePath}${workerPathname}`);
     try {
-        var _response_headers_get;
+        var _response_headers_get, // Since we aren't consuming the response body, we cancel it to avoid memory leaks
+        _response_body;
         let body;
         if (// The type check here ensures that `req` is correctly typed, and the
         // environment variable check provides dead code elimination.
@@ -188,10 +210,15 @@ function addRevalidationHeader(res, { workStore, requestStore }) {
                 }
             }
             return new _flightrenderresult.FlightRenderResult(response.body);
-        } else {
-            var // Since we aren't consuming the response body, we cancel it to avoid memory leaks
-            _response_body;
-            (_response_body = response.body) == null ? void 0 : _response_body.cancel();
+        }
+        (_response_body = response.body) == null ? void 0 : _response_body.cancel();
+        // Pass the action-not-found marker through so the client throws
+        // UnrecognizedActionError instead of a generic "unexpected response".
+        if (response.headers.get(_approuterheaders.NEXT_ACTION_NOT_FOUND_HEADER) === '1') {
+            res.setHeader(_approuterheaders.NEXT_ACTION_NOT_FOUND_HEADER, '1');
+            res.setHeader('content-type', 'text/plain');
+            res.statusCode = 404;
+            return _renderresult.default.fromStatic('Server action not found.', 'text/plain');
         }
     } catch (err) {
         // we couldn't stream the forwarded response, so we'll just return an empty response
@@ -239,7 +266,6 @@ async function createRedirectRenderResult(req, res, originalHost, redirectUrl, r
     // `basePath` we treat it as an app-relative redirect;
     const appRelativeRedirectUrl = getAppRelativeRedirectUrl(basePath, originalHost, redirectUrl, currentPathname);
     if (appRelativeRedirectUrl) {
-        var _getRequestMeta;
         if (!originalHost) {
             throw Object.defineProperty(new Error('Invariant: Missing `host` header from a forwarded Server Actions request.'), "__NEXT_ERROR_CODE", {
                 value: "E226",
@@ -249,10 +275,31 @@ async function createRedirectRenderResult(req, res, originalHost, redirectUrl, r
         }
         const forwardedHeaders = getForwardedHeaders(req, res);
         forwardedHeaders.set(_approuterheaders.RSC_HEADER, '1');
-        const proto = ((_getRequestMeta = (0, _requestmeta.getRequestMeta)(req, 'initProtocol')) == null ? void 0 : _getRequestMeta.replace(/:+$/, '')) || 'https';
-        // For standalone or the serverful mode, use the internal origin directly
-        // other than the host headers from the request.
-        const origin = process.env.__NEXT_PRIVATE_ORIGIN || `${proto}://${originalHost.value}`;
+        // TODO: Remove __NEXT_PRIVATE_ORIGIN
+        let origin = process.env.__NEXT_PRIVATE_ORIGIN;
+        if (origin === undefined) {
+            const initUrl = (0, _requestmeta.getRequestMeta)(req, 'initURL');
+            if (initUrl !== undefined) {
+                try {
+                    const parsedUrl = new URL(initUrl);
+                    origin = parsedUrl.origin;
+                } catch (error) {
+                    throw Object.defineProperty(new Error('Could not determine origin for forwarded Server Actions request. This can happen if port or hostname are not configured for this server.', {
+                        cause: error
+                    }), "__NEXT_ERROR_CODE", {
+                        value: "E1447",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            } else {
+                throw Object.defineProperty(new _invarianterror.InvariantError('Missing initURL'), "__NEXT_ERROR_CODE", {
+                    value: "E1446",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        }
         const fetchUrl = new URL(`${origin}${appRelativeRedirectUrl.pathname}${appRelativeRedirectUrl.search}`);
         if (workStore.pendingRevalidatedTags) {
             var _workStore_incrementalCache_prerenderManifest_preview, _workStore_incrementalCache_prerenderManifest, _workStore_incrementalCache;
@@ -364,7 +411,8 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
     }
     // If the app has no server actions at all, we can 404 early.
     if (!hasServerActions()) {
-        return handleUnrecognizedFetchAction(getActionNotFoundError(actionId));
+        const error = actionId !== null && !(0, _serverreferenceinfo.mightBeServerReferenceId)(actionId) ? (0, _manifestssingleton.getInvalidServerReferenceIdError)(actionId) : (0, _manifestssingleton.getActionNotFoundError)(actionId);
+        return handleUnrecognizedFetchAction(error);
     }
     if (workStore.isStaticGeneration) {
         throw Object.defineProperty(new Error("Invariant: server actions can't be handled during static rendering"), "__NEXT_ERROR_CODE", {
@@ -443,12 +491,15 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
     }
     // ensure we avoid caching server actions unexpectedly
     res.setHeader('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate');
-    const { actionAsyncStorage } = ComponentMod;
     const actionWasForwarded = Boolean(req.headers['x-action-forwarded']);
-    if (actionId) {
+    // Only attempt to forward if this request has not already been forwarded.
+    // Otherwise middleware that rewrites the action POST can cause the receiving
+    // worker to forward again, looping indefinitely.
+    if (actionId && !actionWasForwarded) {
         const forwardedWorker = (0, _manifestssingleton.selectWorkerForForwarding)(actionId, page);
-        // If forwardedWorker is truthy, it means there isn't a worker for the action
-        // in the current handler, so we forward the request to a worker that has the action.
+        // If forwardedWorker is truthy, it means there isn't a worker for the
+        // action in the current handler, so we forward the request to a worker that
+        // has the action.
         if (forwardedWorker) {
             return {
                 type: 'done',
@@ -457,12 +508,16 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
         }
     }
     try {
-        return await actionAsyncStorage.run({
+        return await _actionasyncstorageexternal.actionAsyncStorage.run({
             isAction: true
         }, async ()=>{
             // We only use these for fetch actions -- MPA actions handle them inside `decodeAction`.
             let actionModId;
             let boundActionArguments = [];
+            const defaultBodySizeLimit = '1 MB';
+            const bodySizeLimit = (serverActions == null ? void 0 : serverActions.bodySizeLimit) ?? defaultBodySizeLimit;
+            const bodySizeLimitBytes = bodySizeLimit !== defaultBodySizeLimit ? require('next/dist/compiled/bytes').parse(bodySizeLimit) : 1024 * 1024 // 1 MB
+            ;
             if (// The type check here ensures that `req` is correctly typed, and the
             // environment variable check provides dead code elimination.
             process.env.NEXT_RUNTIME === 'edge' && (0, _helpers.isWebNextRequest)(req)) {
@@ -473,13 +528,48 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                         configurable: true
                     });
                 }
-                // TODO: add body limit
                 // Use react-server-dom-webpack/server
                 const { createTemporaryReferenceSet, decodeReply, decodeAction, decodeFormState } = ComponentMod;
                 temporaryReferences = createTemporaryReferenceSet();
                 if (isMultipartAction) {
                     // TODO-APP: Add streaming support
-                    const formData = await req.request.formData();
+                    // Read the body stream with size tracking to enforce bodySizeLimitBytes.
+                    // We cannot call req.request.formData() directly as that would bypass
+                    // the body size limit entirely.
+                    const edgeChunks = [];
+                    let edgeBodySize = 0;
+                    const edgeReader = req.body.getReader();
+                    while(true){
+                        const { done, value } = await edgeReader.read();
+                        if (done) break;
+                        edgeBodySize += value.byteLength;
+                        if (edgeBodySize > bodySizeLimitBytes) {
+                            const { ApiError } = require('../api-utils');
+                            throw Object.defineProperty(new ApiError(413, `Body exceeded ${bodySizeLimit} limit.\n` + `To configure the body size limit for Server Actions, see: https://nextjs.org/docs/app/api-reference/next-config-js/serverActions#bodysizelimit`), "__NEXT_ERROR_CODE", {
+                                value: "E394",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        edgeChunks.push(value);
+                    }
+                    // Reconstruct a Blob from the buffered chunks and parse formData from it.
+                    // Note: we must pass the original Content-Type as an explicit header
+                    // rather than relying on the Blob's `type`. The Blob constructor
+                    // normalizes `type` to ASCII lowercase per the File API spec, which
+                    // would lowercase the multipart boundary parameter (e.g.
+                    // `boundary=----WebKitFormBoundaryAbCdEf`). The body bytes contain the
+                    // original mixed-case boundary delimiter, so a lowercased boundary
+                    // would fail to match and `formData()` would throw. An explicit header
+                    // on the Request takes precedence over the Blob's normalized type.
+                    const edgeBodyBlob = new Blob(edgeChunks);
+                    const formData = await new Request('http://n/', {
+                        method: 'POST',
+                        headers: {
+                            'content-type': req.headers['content-type'] ?? ''
+                        },
+                        body: edgeBodyBlob
+                    }).formData();
                     if (isFetchAction) {
                         // A fetch action with a multipart body.
                         try {
@@ -537,12 +627,22 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                     // In practice, this happens if `encodeReply` returned a string instead of FormData,
                     // which can happen for very simple JSON-like values that don't need multiple flight rows.
                     const chunks = [];
+                    let nonMultipartBodySize = 0;
                     const reader = req.body.getReader();
                     while(true){
                         const { done, value } = await reader.read();
                         if (done) {
                             break;
                         }
+                        nonMultipartBodySize += value.byteLength;
+                        if (nonMultipartBodySize > bodySizeLimitBytes) {
+                            const { ApiError } = require('../api-utils');
+                            throw Object.defineProperty(new ApiError(413, `Body exceeded ${bodySizeLimit} limit.\n` + `To configure the body size limit for Server Actions, see: https://nextjs.org/docs/app/api-reference/next-config-js/serverActions#bodysizelimit`), "__NEXT_ERROR_CODE", {
+                                value: "E394",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
                         chunks.push(value);
                     }
                     const actionData = Buffer.concat(chunks).toString('utf-8');
@@ -562,10 +662,6 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                 // state prefix in minimal mode), use it instead of req.body
                 const actionBodyFromMeta = (0, _requestmeta.getRequestMeta)(req, 'actionBody');
                 const body = actionBodyFromMeta ? Readable.from(actionBodyFromMeta) : req.body;
-                const defaultBodySizeLimit = '1 MB';
-                const bodySizeLimit = (serverActions == null ? void 0 : serverActions.bodySizeLimit) ?? defaultBodySizeLimit;
-                const bodySizeLimitBytes = bodySizeLimit !== defaultBodySizeLimit ? require('next/dist/compiled/bytes').parse(bodySizeLimit) : 1024 * 1024 // 1 MB
-                ;
                 let size = 0;
                 const sizeLimitTransform = new Transform({
                     transform (chunk, encoding, callback) {
@@ -776,12 +872,12 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                 const maybeRevalidatesPromise = skipPageRendering ? (0, _revalidationutils.executeRevalidates)(workStore) : false;
                 return {
                     type: 'done',
-                    result: await generateFlight(req, ctx, requestStore, {
-                        actionResult: Promise.resolve(actionResult),
-                        skipPageRendering,
-                        temporaryReferences,
-                        waitUntil: maybeRevalidatesPromise === false ? undefined : maybeRevalidatesPromise
-                    })
+                    result: await _actionasyncstorageexternal.actionAsyncStorage.exit(()=>generateFlight(req, ctx, requestStore, {
+                            actionResult: Promise.resolve(actionResult),
+                            skipPageRendering,
+                            temporaryReferences,
+                            waitUntil: maybeRevalidatesPromise === false ? undefined : maybeRevalidatesPromise
+                        }))
                 };
             } else {
                 // TODO: this shouldn't be reachable, because all non-fetch codepaths return early.
@@ -793,17 +889,20 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
         if ((0, _redirecterror.isRedirectError)(err)) {
             const redirectUrl = (0, _redirect.getURLFromRedirectError)(err);
             const redirectType = (0, _redirect.getRedirectTypeFromError)(err);
-            // if it's a fetch action, we'll set the status code for logging/debugging purposes
-            // but we won't set a Location header, as the redirect will be handled by the client router
-            res.statusCode = _redirectstatuscode.RedirectStatusCode.SeeOther;
-            metadata.statusCode = _redirectstatuscode.RedirectStatusCode.SeeOther;
             if (isFetchAction) {
+                // Fetch actions communicate redirects through `x-action-redirect` and
+                // can include the redirect target's Flight response in the body. Since
+                // this is not an HTTP redirect, keep the response successful.
+                res.statusCode = 200;
+                metadata.statusCode = 200;
                 return {
                     type: 'done',
                     result: await createRedirectRenderResult(req, res, host, redirectUrl, redirectType, ctx.renderOpts.basePath, workStore, requestStore.url.pathname)
                 };
             }
             // For an MPA action, the redirect doesn't need a body, just a Location header.
+            res.statusCode = _redirectstatuscode.RedirectStatusCode.SeeOther;
+            metadata.statusCode = _redirectstatuscode.RedirectStatusCode.SeeOther;
             res.setHeader('Location', redirectUrl);
             return {
                 type: 'done',
@@ -917,7 +1016,6 @@ async function executeActionAndPrepareForRender(action, args, workStore, request
  * the action came from a different deployment. It could also simply be an invalid POST request that is not a server action.
  * In either case, we'll throw an error to be handled by the caller.
  */ function getActionModIdOrError(actionId, serverModuleMap) {
-    var _serverModuleMap_actionId;
     // if we're missing the action ID header, we can't do any further processing
     if (!actionId) {
         throw Object.defineProperty(new _invarianterror.InvariantError("Missing 'next-action' header."), "__NEXT_ERROR_CODE", {
@@ -926,28 +1024,28 @@ async function executeActionAndPrepareForRender(action, args, workStore, request
             configurable: true
         });
     }
-    const actionModId = (_serverModuleMap_actionId = serverModuleMap[actionId]) == null ? void 0 : _serverModuleMap_actionId.id;
-    if (!actionModId) {
-        throw getActionNotFoundError(actionId);
+    const entry = serverModuleMap[actionId];
+    if (entry == null) {
+        // The proxy throws for malformed IDs and IDs that are missing from the
+        // manifest. It only returns undefined when the ID collides with a
+        // well-known property name (e.g. `toString`) that the proxy excludes from
+        // server reference validation so that framework reflection probes don't
+        // throw. Next.js never produces such an ID, so this is almost certainly a
+        // probe with a known-bad ID. Repeat the manifest's throw logic here so the
+        // caller gets a diagnosable error instead of a `TypeError`.
+        throw (0, _serverreferenceinfo.mightBeServerReferenceId)(actionId) ? (0, _manifestssingleton.getActionNotFoundError)(actionId) : (0, _manifestssingleton.getInvalidServerReferenceIdError)(actionId);
     }
-    return actionModId;
-}
-function getActionNotFoundError(actionId) {
-    return Object.defineProperty(new Error(`Failed to find Server Action${actionId ? ` "${actionId}"` : ''}. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
-        value: "E974",
-        enumerable: false,
-        configurable: true
-    });
+    return entry.id;
 }
 const $ACTION_ = '$ACTION_';
 const $ACTION_REF_ = '$ACTION_REF_';
 const $ACTION_ID_ = '$ACTION_ID_';
-const ACTION_ID_EXPECTED_LENGTH = 42;
 /**
  * This function mirrors logic inside React's decodeAction and should be kept in sync with that.
  * It pre-parses the FormData to ensure that any action IDs referred to are actual action IDs for
  * this Next.js application.
  */ function areAllActionIdsValid(mpaFormData, serverModuleMap) {
+    let seenActionRefs = 0;
     let hasAtLeastOneAction = false;
     // Before we attempt to decode the payload for a possible MPA action, assert that all
     // action IDs are valid IDs. If not we should disregard the payload
@@ -962,6 +1060,12 @@ const ACTION_ID_EXPECTED_LENGTH = 42;
             }
             hasAtLeastOneAction = true;
         } else if (key.startsWith($ACTION_REF_)) {
+            if (++seenActionRefs > 2) {
+                // We only expect to see at most 2 $ACTION_REF_ fields in the form data:
+                // one from <form action="..." method="post">
+                // and one from <input action="..." type="submit">
+                return false;
+            }
             // Bound args case
             const actionDescriptorField = $ACTION_ + key.slice($ACTION_REF_.length) + ':0';
             const actionFields = mpaFormData.getAll(actionDescriptorField);
@@ -986,10 +1090,13 @@ function isInvalidStringActionDescriptor(actionDescriptor, serverModuleMap) {
         return true;
     }
     const from = ACTION_DESCRIPTOR_ID_PREFIX.length;
-    const to = from + ACTION_ID_EXPECTED_LENGTH;
+    const to = actionDescriptor.indexOf('"', from);
+    if (to === -1) {
+        return true;
+    }
     // We expect actionDescriptor to be '{"id":"<actionId>",...}'
     const actionId = actionDescriptor.slice(from, to);
-    if (actionId.length !== ACTION_ID_EXPECTED_LENGTH || actionDescriptor[to] !== '"') {
+    if (!(0, _serverreferenceinfo.mightBeServerReferenceId)(actionId)) {
         return true;
     }
     const entry = serverModuleMap[actionId];
@@ -1002,11 +1109,12 @@ function isInvalidActionIdFieldName(actionIdFieldName, serverModuleMap) {
     // The field name must always start with $ACTION_ID_ but since it is
     // the id is extracted from the key of the field we have already validated
     // this before entering this function
-    if (actionIdFieldName.length !== $ACTION_ID_.length + ACTION_ID_EXPECTED_LENGTH) {
+    const actionId = actionIdFieldName.slice($ACTION_ID_.length);
+    if (!(0, _serverreferenceinfo.mightBeServerReferenceId)(actionId)) {
         // this field name has too few or too many characters
+        // or it is otherwise in the wrong format
         return true;
     }
-    const actionId = actionIdFieldName.slice($ACTION_ID_.length);
     const entry = serverModuleMap[actionId];
     if (entry == null) {
         return true;

package/dist/node_modules/next/dist/server/app-render/app-render-prerender-utils.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     ReactServerPrerenderResult: null,
     ReactServerResult: null,
+    ReplayableNodeStream: null,
     createReactServerPrerenderResult: null,
     createReactServerPrerenderResultFromRender: null,
     processPrelude: null
@@ -22,6 +23,9 @@ _export(exports, {
     ReactServerResult: function() {
         return ReactServerResult;
     },
+    ReplayableNodeStream: function() {
+        return ReplayableNodeStream;
+    },
     createReactServerPrerenderResult: function() {
         return createReactServerPrerenderResult;
     },
@@ -33,11 +37,23 @@ _export(exports, {
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
+function isWebStream(stream) {
+    return typeof stream.tee === 'function';
+}
 class ReactServerResult {
     constructor(stream){
-        this._stream = stream;
+        if (process.env.__NEXT_USE_NODE_STREAMS && !isWebStream(stream)) {
+            this._stream = null;
+            this._replayable = new ReplayableNodeStream(stream);
+        } else {
+            this._stream = stream;
+            this._replayable = null;
+        }
     }
     tee() {
+        if (this._replayable) {
+            return this._replayable.createReplayStream();
+        }
         if (this._stream === null) {
             throw Object.defineProperty(new Error('Cannot tee a ReactServerResult that has already been consumed'), "__NEXT_ERROR_CODE", {
                 value: "E106",
@@ -45,11 +61,37 @@ class ReactServerResult {
                 configurable: true
             });
         }
-        const tee = this._stream.tee();
-        this._stream = tee[0];
-        return tee[1];
+        if (isWebStream(this._stream)) {
+            const tee = this._stream.tee();
+            this._stream = tee[0];
+            return tee[1];
+        }
+        if (process.env.NEXT_RUNTIME === 'edge') {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Node.js Readable cannot be teed in the edge runtime'), "__NEXT_ERROR_CODE", {
+                value: "E1149",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            let Readable;
+            if (process.env.TURBOPACK) {
+                Readable = require('node:stream').Readable;
+            } else {
+                Readable = __non_webpack_require__('node:stream').Readable;
+            }
+            const webStream = Readable.toWeb(this._stream);
+            const tee = webStream.tee();
+            this._stream = Readable.fromWeb(tee[0]);
+            return Readable.fromWeb(tee[1]);
+        }
     }
     consume() {
+        if (this._replayable) {
+            const stream = this._replayable.createReplayStream();
+            this._replayable.dispose();
+            this._replayable = null;
+            return stream;
+        }
         if (this._stream === null) {
             throw Object.defineProperty(new Error('Cannot consume a ReactServerResult that has already been consumed'), "__NEXT_ERROR_CODE", {
                 value: "E470",
@@ -62,6 +104,119 @@ class ReactServerResult {
         return stream;
     }
 }
+class ReplayableNodeStream {
+    constructor(stream){
+        this._chunks = [];
+        this._done = false;
+        this._error = null;
+        this._subscribers = new Set();
+        stream.on('data', (chunk)=>{
+            const buf = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+            if (this._chunks !== null) {
+                this._chunks.push(buf);
+            }
+            for (const sub of this._subscribers){
+                sub.onChunk(buf);
+            }
+        });
+        stream.on('end', ()=>{
+            this._done = true;
+            for (const sub of this._subscribers){
+                sub.onEnd();
+            }
+            this._subscribers.clear();
+        });
+        stream.on('error', (err)=>{
+            this._error = err;
+            for (const sub of this._subscribers){
+                sub.onError(err);
+            }
+            this._subscribers.clear();
+        });
+    }
+    /**
+   * Creates a new Node.js Readable stream that first emits all buffered chunks,
+   * then forwards any new chunks from the source as they arrive.
+   *
+   * Buffered chunks are delivered via _read() (pull-based) rather than pushed
+   * eagerly. This is critical because createReplayStream() is called outside
+   * of AsyncLocalStorage context, and eagerly pushing chunks triggers internal
+   * Node.js stream scheduling (process.nextTick for maybeReadMore) that
+   * captures the empty ALS context. By deferring to _read(), chunks are only
+   * delivered when the consumer reads, which happens inside the correct ALS
+   * scope (e.g. during Fizz's performWork).
+   */ createReplayStream() {
+        if (this._chunks === null) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Cannot create a replay stream after the ReplayableNodeStream has been disposed.'), "__NEXT_ERROR_CODE", {
+                value: "E1156",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let ReadableCtor;
+        if (process.env.NEXT_RUNTIME === 'edge') {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Node.js Readable cannot be teed in the edge runtime'), "__NEXT_ERROR_CODE", {
+                value: "E1149",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            if (process.env.__NEXT_BUNDLER === 'Webpack' || process.env.__NEXT_BUNDLER === 'Rspack') {
+                ReadableCtor = __non_webpack_require__('node:stream').Readable;
+            } else {
+                ReadableCtor = require('node:stream').Readable;
+            }
+        }
+        const bufferedChunks = this._chunks.slice();
+        let bufferIndex = 0;
+        let bufferDrained = false;
+        const isDone = this._done;
+        const sourceError = this._error;
+        const stream = new ReadableCtor({
+            read () {
+                if (!bufferDrained) {
+                    bufferDrained = true;
+                    for(let i = bufferIndex; i < bufferedChunks.length; i++){
+                        this.push(bufferedChunks[i]);
+                    }
+                    bufferIndex = bufferedChunks.length;
+                    if (isDone) {
+                        this.push(null);
+                    }
+                }
+            }
+        });
+        if (sourceError) {
+            stream.destroy(sourceError);
+            return stream;
+        }
+        if (isDone) {
+            return stream;
+        }
+        const subscriber = {
+            onChunk: (chunk)=>{
+                stream.push(chunk);
+            },
+            onEnd: ()=>{
+                stream.push(null);
+            },
+            onError: (err)=>{
+                stream.destroy(err);
+            }
+        };
+        this._subscribers.add(subscriber);
+        stream.on('close', ()=>{
+            this._subscribers.delete(subscriber);
+        });
+        return stream;
+    }
+    /**
+   * Clears the buffered chunks and all subscriber references. After calling
+   * this, no new replay streams can be created.
+   */ dispose() {
+        this._chunks = null;
+    }
+}
 async function createReactServerPrerenderResult(underlying) {
     const chunks = [];
     const { prelude } = await underlying;
@@ -77,13 +232,19 @@ async function createReactServerPrerenderResult(underlying) {
 }
 async function createReactServerPrerenderResultFromRender(underlying) {
     const chunks = [];
-    const reader = underlying.getReader();
-    while(true){
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        } else {
-            chunks.push(value);
+    if (isWebStream(underlying)) {
+        const reader = underlying.getReader();
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            } else {
+                chunks.push(value);
+            }
+        }
+    } else {
+        for await (const chunk of underlying){
+            chunks.push(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
         }
     }
     return new ReactServerPrerenderResult(chunks);
@@ -110,6 +271,10 @@ class ReactServerPrerenderResult {
     constructor(chunks){
         this._chunks = chunks;
     }
+    asChunks() {
+        const chunks = this.assertChunks('asChunks()');
+        return chunks;
+    }
     asUnclosingStream() {
         const chunks = this.assertChunks('asUnclosingStream()');
         return createUnclosingStream(chunks);