@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/client/components/offline.js

@@ -0,0 +1,172 @@
+/**
+ * Centralized offline detection, state management, and retry logic.
+ *
+ * This module tracks whether the app is offline and provides primitives for
+ * retrying failed network requests. It is designed to be extended in the
+ * future — e.g., instrumenting module chunk loading, Flight chunk resolution,
+ * or eventually being promoted to a React-level feature.
+ *
+ * All stateful behavior (event listeners, polling, state tracking) only runs
+ * in the browser. On the server and during hydration, getOffline() always
+ * returns false.
+ *
+ * ## Known limitation: queued fetches
+ *
+ * When the user navigates multiple times while offline, each navigation queues
+ * a separate fetch that blocks on waitForConnection(). When connectivity is
+ * restored, all of them resume and retry simultaneously.
+ *
+ * Future mitigations:
+ * - Stale cache access (PR 3): offline navigations will reuse back-forward
+ *   cache entries, so most navigations won't issue new fetches at all. This is
+ *   the primary shield against duplicate requests.
+ * - Fetch cancellation: on router.refresh(), we could abort pending blocked
+ *   fetches since refresh invalidates all dynamic caches.
+ */ // Backoff delays for the polling loop: 500ms → 1s → 2s → 3s (cap)
+// Timeout for the HEAD connectivity check. If the request doesn't resolve
+// within this window, we assume we're still offline. 200ms is more than enough
+// — network errors reject almost instantly.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    checkOfflineError: null,
+    getOffline: null,
+    notifyOnline: null,
+    waitForConnection: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkOfflineError: function() {
+        return checkOfflineError;
+    },
+    getOffline: function() {
+        return getOffline;
+    },
+    notifyOnline: function() {
+        return notifyOnline;
+    },
+    waitForConnection: function() {
+        return waitForConnection;
+    }
+});
+const _scheduler = require("./segment-cache/scheduler");
+const _fetch = require("./segment-cache/fetch");
+const _approuterheaders = require("./app-router-headers");
+const _useoffline = require("./use-offline");
+const CONNECTIVITY_CHECK_TIMEOUT_MS = 200;
+let offlineState = null;
+function checkOfflineError(err) {
+    if (err instanceof DOMException) {
+        if (err.name === 'AbortError' || err.name === 'TimeoutError') {
+            return false;
+        }
+    }
+    notifyOffline();
+    return true;
+}
+function getOffline() {
+    return offlineState;
+}
+/**
+ * Enters the offline state if not already in it, and starts the
+ * connectivity polling loop.
+ */ function notifyOffline() {
+    if (offlineState !== null) {
+        return offlineState;
+    }
+    let resolve;
+    const promise = new Promise((r)=>{
+        resolve = r;
+    });
+    offlineState = {
+        promise,
+        resolve: resolve,
+        timeoutHandle: null,
+        backoffStep: 0
+    };
+    (0, _useoffline.dispatchOfflineChange)(true);
+    checkConnectivity(offlineState);
+    return offlineState;
+}
+function notifyOnline() {
+    if (offlineState === null) {
+        return;
+    }
+    if (offlineState.timeoutHandle !== null) {
+        clearTimeout(offlineState.timeoutHandle);
+    }
+    const resolve = offlineState.resolve;
+    offlineState = null;
+    resolve();
+    (0, _useoffline.dispatchOfflineChange)(false);
+    (0, _scheduler.pingPrefetchScheduler)();
+}
+/**
+ * Does a HEAD request to confirm connectivity, then either resolves the
+ * offline state or schedules the next check with backoff.
+ */ async function checkConnectivity(state) {
+    // Cancel any previously scheduled check so we don't end up with
+    // parallel polling loops.
+    if (state.timeoutHandle !== null) {
+        clearTimeout(state.timeoutHandle);
+        state.timeoutHandle = null;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(()=>controller.abort(), CONNECTIVITY_CHECK_TIMEOUT_MS);
+    try {
+        // HEAD request to the current page with the RSC header, so we're
+        // testing connectivity to the same endpoint that navigations use.
+        await (0, _fetch.fetch)(location.href, {
+            method: 'HEAD',
+            headers: {
+                [_approuterheaders.RSC_HEADER]: '1'
+            },
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        // If the fetch didn't throw, we're back online.
+        notifyOnline();
+    } catch (err) {
+        // If the error is from our own timeout abort, that actually means
+        // the request went out and is waiting for a response — i.e., we're
+        // back online. A truly offline request fails almost instantly (well
+        // within the 200ms timeout).
+        if (err instanceof DOMException && err.name === 'AbortError') {
+            clearTimeout(timeoutId);
+            notifyOnline();
+            return;
+        }
+        // Network error — still offline. Schedule the next check with backoff.
+        const delay = state.backoffStep === 0 ? 500 : state.backoffStep === 1 ? 1000 : state.backoffStep === 2 ? 2000 : 3000;
+        state.backoffStep++;
+        state.timeoutHandle = setTimeout(()=>checkConnectivity(state), delay);
+    }
+}
+function waitForConnection(state) {
+    return state.promise;
+}
+function pingOfflineState() {
+    if (offlineState !== null) {
+        checkConnectivity(offlineState);
+    }
+}
+// Set up browser event listeners for proactive offline detection.
+if (typeof window !== 'undefined') {
+    window.addEventListener('offline', notifyOffline);
+    window.addEventListener('online', pingOfflineState);
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=offline.js.map

package/dist/node_modules/next/dist/client/components/readonly-url-search-params.js

@@ -15,6 +15,11 @@ Object.defineProperty(exports, "ReadonlyURLSearchParams", {
 class ReadonlyURLSearchParamsError extends Error {
     constructor(){
         super('Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams');
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1174",
+            enumerable: false,
+            configurable: true
+        });
     }
 }
 class ReadonlyURLSearchParams extends URLSearchParams {

package/dist/node_modules/next/dist/client/components/redirect.js

@@ -38,7 +38,7 @@ _export(exports, {
 });
 const _redirectstatuscode = require("./redirect-status-code");
 const _redirecterror = require("./redirect-error");
-const actionAsyncStorage = typeof window === 'undefined' ? require('../../server/app-render/action-async-storage.external').actionAsyncStorage : undefined;
+const _serverasyncstorage = require("./server-async-storage");
 function getRedirectError(url, type, statusCode = _redirectstatuscode.RedirectStatusCode.TemporaryRedirect) {
     const error = Object.defineProperty(new Error(_redirecterror.REDIRECT_ERROR_CODE), "__NEXT_ERROR_CODE", {
         value: "E394",
@@ -49,7 +49,7 @@ function getRedirectError(url, type, statusCode = _redirectstatuscode.RedirectSt
     return error;
 }
 function redirect(/** The URL to redirect to */ url, type) {
-    type ??= actionAsyncStorage?.getStore()?.isAction ? 'push' : 'replace';
+    type ??= _serverasyncstorage.actionAsyncStorage?.getStore()?.isAction ? 'push' : 'replace';
     throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
 }
 function permanentRedirect(/** The URL to redirect to */ url, type = 'replace') {

package/dist/node_modules/next/dist/client/components/router-reducer/compute-changed-path.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", {
     computeChangedPath: null,
     extractPathFromFlightRouterState: null,
     extractSourcePageFromFlightRouterState: null,
-    getSelectedParams: null
+    getSelectedParams: null,
+    segmentToSourcePagePathname: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -26,6 +27,9 @@ _export(exports, {
     },
     getSelectedParams: function() {
         return getSelectedParams;
+    },
+    segmentToSourcePagePathname: function() {
+        return segmentToSourcePagePathname;
     }
 });
 const _interceptionroutes = require("../../../shared/lib/router/utils/interception-routes");

package/dist/node_modules/next/dist/client/components/router-reducer/create-initial-router-state.js

@@ -18,7 +18,7 @@ const _bfcache = require("../segment-cache/bfcache");
 const _fetchserverresponse = require("./fetch-server-response");
 const _optimisticroutes = require("../segment-cache/optimistic-routes");
 function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFlightStreamForCache, location }) {
-    const { c: initialCanonicalUrlParts, f: initialFlightData, q: initialRenderedSearch, i: initialCouldBeIntercepted, S: initialSupportsPerSegmentPrefetching, s: initialStaleTime, l: initialStaticStageByteLength, h: initialHeadVaryParams, p: initialRuntimePrefetchStream, d: initialDynamicStaleTimeSeconds } = initialRSCPayload;
+    const { c: initialCanonicalUrlParts, f: initialFlightData, q: initialRenderedSearch, i: initialCouldBeIntercepted, S: initialSupportsPerSegmentPrefetching, s: initialStaleTime, l: initialStaticStageByteLength, h: initialHeadVaryParams, r: initialRootVaryParams, p: initialRuntimePrefetchStream, d: initialDynamicStaleTimeSeconds } = initialRSCPayload;
     // When initialized on the server, the canonical URL is provided as an array of parts.
     // This is to ensure that when the RSC payload streamed to the client, crawlers don't interpret it
     // as a URL that should be crawled.
@@ -35,14 +35,15 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
     // head is embedded into the CacheNode tree, but eventually we'll lift it out
     // and store it on the top-level state object.
     //
-    // TODO: For statically-generated-at-build-time HTML pages, the
-    // FlightRouterState baked into the initial RSC payload won't have the
-    // correct segment inlining hints (ParentInlinedIntoSelf, InlinedIntoChild)
-    // because those are computed after the pre-render. The client will need to
-    // fetch the correct hints from the route tree prefetch (/_tree) response
-    // before acting on inlining decisions.
+    // For statically-generated-at-build-time HTML pages, the FlightRouterState
+    // baked into the initial RSC payload won't have the correct segment inlining
+    // hints because those are computed after the pre-render. The server marks
+    // these trees with InliningHintsStale, which causes the route cache entry
+    // to be immediately expired. The next prefetch will re-fetch the tree with
+    // correct hints from the /_tree response.
     const acc = {
-        metadataVaryPath: null
+        metadataVaryPath: null,
+        treeDivergedFromBase: false
     };
     const initialRouteTree = (0, _cache.convertRootFlightRouterStateToRouteTree)(initialTree, initialRenderedSearch, acc);
     const metadataVaryPath = acc.metadataVaryPath;
@@ -51,19 +52,25 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
     // route learning nor segment cache state persists from SSR to client.
     if (location !== null && metadataVaryPath !== null) {
         // Learn the route pattern so we can predict it for future navigations.
-        (0, _optimisticroutes.discoverKnownRoute)(Date.now(), location.pathname, null, null, initialRouteTree, metadataVaryPath, initialCouldBeIntercepted, canonicalUrl, initialSupportsPerSegmentPrefetching, false // hasDynamicRewrite
+        (0, _optimisticroutes.discoverKnownRoute)(Date.now(), location.pathname, location.search, null, null, initialRouteTree, metadataVaryPath, initialCouldBeIntercepted, canonicalUrl, initialSupportsPerSegmentPrefetching, false // hasDynamicRewrite
         );
+        // TODO: Implement Shell extraction as part of Cached Navigations.
+        // Intentionally holding off on doing this until we decide how the Cached
+        // Navigations behavior should work in combination with App Shells.
         // Write the initial seed data into the segment cache so subsequent
         // navigations to the initial page can serve cached segments instantly.
         if (initialSeedData !== null && initialStaleTime !== undefined) {
             if (initialStaticStageByteLength !== undefined && initialFlightStreamForCache != null) {
                 // Partially static page — truncate the cloned Flight stream at the
                 // static stage byte boundary, decode, and cache the static subset.
-                (0, _fetchserverresponse.decodeStaticStage)(initialFlightStreamForCache, initialStaticStageByteLength, undefined).then(async (staticStageResponse)=>{
+                // Promise.resolve wraps the Flight-deserialized thenable into a
+                // native Promise so we can chain `.then` on it safely.
+                Promise.resolve(initialStaticStageByteLength).then(async (byteLength)=>{
+                    const staticStageResponse = await (0, _fetchserverresponse.decodeStageUntilBoundary)(initialFlightStreamForCache, byteLength, undefined);
                     const now = Date.now();
-                    const staleAt = await (0, _cache.getStaleAt)(now, staticStageResponse.s);
-                    (0, _cache.writeStaticStageResponseIntoCache)(now, staticStageResponse.f, undefined, staticStageResponse.h, staleAt, initialTree, initialRenderedSearch, true // isResponsePartial
-                    );
+                    const staleAt = await (0, _cache.resolveStaleAt)(now, staticStageResponse.s);
+                    (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, staticStageResponse.f, undefined, staticStageResponse.h, staticStageResponse.r ?? null, staleAt, initialTree, initialRenderedSearch, true, _cache // hydration writes are bound to the shared map
+                    .segmentCacheMap);
                 }).catch(()=>{
                 // The static stage processing failed. Not fatal — the page
                 // rendered normally, we just won't write into the cache.
@@ -75,9 +82,9 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
                 // since we can just take the seed data that we already decoded during
                 // hydration and write it into the cache directly.
                 const now = Date.now();
-                (0, _cache.getStaleAt)(now, initialStaleTime).then((staleAt)=>{
-                    (0, _cache.writeStaticStageResponseIntoCache)(now, initialFlightData, undefined, initialHeadVaryParams, staleAt, initialTree, initialRenderedSearch, false // isResponsePartial
-                    );
+                (0, _cache.resolveStaleAt)(now, initialStaleTime).then((staleAt)=>{
+                    (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, initialFlightData, undefined, initialHeadVaryParams, initialRootVaryParams ?? null, staleAt, initialTree, initialRenderedSearch, false, _cache // hydration writes are bound to the shared map
+                    .segmentCacheMap);
                 }).catch(()=>{
                 // The static stage processing failed. Not fatal — the page
                 // rendered normally, we just won't write into the cache.
@@ -96,7 +103,8 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
         if (initialRuntimePrefetchStream != null) {
             (0, _cache.processRuntimePrefetchStream)(Date.now(), initialRuntimePrefetchStream, initialTree, initialRenderedSearch).then((processed)=>{
                 if (processed !== null) {
-                    (0, _cache.writeDynamicRenderResponseIntoCache)(Date.now(), _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, processed.staleAt, processed.navigationSeed, null);
+                    (0, _cache.writeDynamicRenderResponseIntoCache)(Date.now(), _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, processed.rootVaryParamsIterable, processed.staleAt, processed.navigationSeed, null, _cache // hydration writes are bound to the shared map
+                    .segmentCacheMap);
                 }
             }).catch(()=>{
             // Runtime prefetch cache write failed. Not fatal — the page rendered

package/dist/node_modules/next/dist/client/components/router-reducer/fetch-server-response.js

@@ -6,9 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     createFetch: null,
     createFromNextReadableStream: null,
-    decodeStaticStage: null,
+    decodeBufferedStage: null,
+    decodeStageUntilBoundary: null,
     fetchServerResponse: null,
     processFetch: null,
+    resolveShellStageData: null,
     resolveStaticStageData: null
 });
 function _export(target, all) {
@@ -24,8 +26,11 @@ _export(exports, {
     createFromNextReadableStream: function() {
         return createFromNextReadableStream;
     },
-    decodeStaticStage: function() {
-        return decodeStaticStage;
+    decodeBufferedStage: function() {
+        return decodeBufferedStage;
+    },
+    decodeStageUntilBoundary: function() {
+        return decodeStageUntilBoundary;
     },
     fetchServerResponse: function() {
         return fetchServerResponse;
@@ -33,12 +38,16 @@ _export(exports, {
     processFetch: function() {
         return processFetch;
     },
+    resolveShellStageData: function() {
+        return resolveShellStageData;
+    },
     resolveStaticStageData: function() {
         return resolveStaticStageData;
     }
 });
 const _client = require("react-server-dom-webpack/client");
 const _invarianterror = require("../../../shared/lib/invariant-error");
+const _fetch = require("../segment-cache/fetch");
 const _approuterheaders = require("../app-router-headers");
 const _appcallserver = require("../../app-call-server");
 const _appfindsourcemapurl = require("../../app-find-source-map-url");
@@ -109,7 +118,13 @@ async function fetchServerResponse(url, options) {
         // TODO: Remove this check once the old PPR flag is removed
         const isLegacyPPR = process.env.__NEXT_PPR && !process.env.__NEXT_CACHE_COMPONENTS;
         const shouldImmediatelyDecode = !isLegacyPPR;
-        const res = await createFetch(url, headers, 'auto', shouldImmediatelyDecode);
+        const res = await createFetch(url, headers, 'auto', shouldImmediatelyDecode, options.signal);
+        // If the fetch succeeds while we're in the offline state, notify the
+        // offline module so it can short-circuit the polling loop.
+        if (process.env.__NEXT_USE_OFFLINE) {
+            const { notifyOnline } = require('../offline');
+            notifyOnline();
+        }
         const responseUrl = (0, _routeparams.urlToUrlWithoutFlightMarker)(new URL(res.url));
         const canonicalUrl = res.redirected ? responseUrl : originalUrl;
         const contentType = res.headers.get('content-type') || '';
@@ -188,9 +203,36 @@ async function fetchServerResponse(url, options) {
             staticStageData,
             runtimePrefetchStream: flightResponse.p ?? null,
             responseHeaders: res.headers,
-            debugInfo: flightResponsePromise._debugInfo ?? null
+            debugInfo: flightResponsePromise._debugInfo ?? null,
+            revealAfter: flightResponse._revealAfter ?? null
         };
     } catch (err) {
+        if (options.signal?.aborted) {
+            // A newer HMR refresh superseded this one and aborted its request.
+            // Rethrow so the caller treats it as canceled, rather than logging a
+            // failure or falling back to an MPA navigation.
+            throw err;
+        }
+        // If the fetch rejected due to a network error, wait for connectivity
+        // to be restored and then retry. checkOfflineError returns true for
+        // network errors (and starts the polling loop); returns false for
+        // intentional aborts/timeouts, which fall through to the MPA fallback.
+        //
+        // Note: when the user navigates multiple times while offline, each
+        // navigation queues a separate retry here. Once connectivity returns,
+        // all pending retries resume simultaneously. This is mitigated in PR 3
+        // by reusing back-forward cache entries during offline navigation, which
+        // avoids issuing new fetches in the first place.
+        if (process.env.__NEXT_USE_OFFLINE && !isPageUnloading) {
+            const { checkOfflineError, getOffline, waitForConnection } = require('../offline');
+            if (checkOfflineError(err)) {
+                const offline = getOffline();
+                if (offline !== null) {
+                    await waitForConnection(offline);
+                }
+                return fetchServerResponse(url, options);
+            }
+        }
         if (!isPageUnloading) {
             console.error(`Failed to fetch RSC payload for ${originalUrl}. Falling back to browser navigation.`, err);
         }
@@ -213,11 +255,15 @@ async function processFetch(response) {
         let responseStream;
         let cacheData;
         if (process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS) {
-            const [stream1, stream2] = stream.tee();
+            // Three readers needed: the main Flight decoder, the static-stage
+            // extractor, and the shell-stage extractor. Tee twice.
+            const [stream1, rest] = stream.tee();
+            const [staticBodyClone, shellBodyClone] = rest.tee();
             responseStream = stream1;
             cacheData = {
                 isResponsePartial: isPartial,
-                responseBodyClone: stream2
+                staticBodyClone,
+                shellBodyClone
             };
         } else {
             responseStream = stream;
@@ -250,11 +296,11 @@ async function processFetch(response) {
     };
 }
 async function resolveStaticStageData(cacheData, flightResponse, headers) {
-    const { isResponsePartial, responseBodyClone } = cacheData;
-    if (responseBodyClone) {
+    const { isResponsePartial, staticBodyClone } = cacheData;
+    if (staticBodyClone) {
         if (!isResponsePartial) {
             // Fully static — cache the entire decoded response as-is.
-            responseBodyClone.cancel();
+            staticBodyClone.cancel();
             return {
                 response: flightResponse,
                 isResponsePartial: false
@@ -263,24 +309,154 @@ async function resolveStaticStageData(cacheData, flightResponse, headers) {
         if (flightResponse.l !== undefined) {
             // Partially static — truncate the body clone at the byte boundary and
             // decode it.
-            const response = await decodeStaticStage(responseBodyClone, flightResponse.l, headers);
+            const staticStageByteLength = await flightResponse.l;
+            const response = await decodeStageUntilBoundary(staticBodyClone, staticStageByteLength, headers);
             return {
                 response,
                 isResponsePartial: true
             };
         }
         // No caching — cancel the unused clone.
-        responseBodyClone.cancel();
+        staticBodyClone.cancel();
     }
     return null;
 }
-async function decodeStaticStage(responseBodyClone, staticStageByteLengthPromise, headers) {
-    const staticStageByteLength = await staticStageByteLengthPromise;
-    const truncatedStream = truncateStream(responseBodyClone, staticStageByteLength);
-    return createFromNextReadableStream(truncatedStream, headers, {
+async function resolveShellStageData(cacheData, flightResponse, headers) {
+    const { shellBodyClone } = cacheData;
+    if (!shellBodyClone) {
+        return null;
+    }
+    if (flightResponse.a === undefined) {
+        shellBodyClone.cancel();
+        return null;
+    }
+    const shellByteLength = await flightResponse.a;
+    if (shellByteLength === null) {
+        // Shell == main response — caller reuses the existing flightResponse.
+        shellBodyClone.cancel();
+        return null;
+    }
+    return decodeStageUntilBoundary(shellBodyClone, shellByteLength, headers);
+}
+async function decodeStageUntilBoundary(responseBodyClone, byteLength, headers) {
+    const { buffer } = await (0, _cache.createNonTaskyPrefetchResponseStream)(responseBodyClone, byteLength);
+    return decodeBufferedStage(buffer, headers);
+}
+function decodeBufferedStage(buffer, headers) {
+    const stream = new ReadableStream({
+        start (controller) {
+            controller.enqueue(buffer);
+            controller.close();
+        }
+    });
+    return createFromNextReadableStream(stream, headers, {
+        allowPartialStream: true
+    });
+}
+// When an HMR refresh can be superseded, we decode its Flight response through
+// a wrapper stream we can close on abort. Closing the stream (rather than
+// letting the aborted fetch error it) makes React's Flight client mark
+// unresolved rows as halted: they suspend during render instead of rejecting,
+// so a superseded request never surfaces an error on an already-committed tree.
+// Because the stream is closed, there's also no unclosed-stream GC-root leak
+// (see #89610). The wrapper is created synchronously here so that the decode
+// starts at the same point `createFromNextFetch` would, preserving the
+// server-latency debug timing.
+function createHaltingFlightResponse(fetchPromise, headers, signal) {
+    let closed = false;
+    let reader = null;
+    const wrapper = new ReadableStream({
+        start (controller) {
+            const onAbort = ()=>{
+                closed = true;
+                try {
+                    controller.close();
+                } catch  {
+                // The controller may already be closed; nothing to do.
+                }
+                if (reader !== null) {
+                    reader.cancel().catch(()=>{});
+                }
+            };
+            if (signal.aborted) {
+                onAbort();
+            } else {
+                signal.addEventListener('abort', onAbort, {
+                    once: true
+                });
+            }
+        },
+        async pull (controller) {
+            if (closed) {
+                return;
+            }
+            if (reader === null) {
+                let response;
+                try {
+                    response = await fetchPromise;
+                } catch (err) {
+                    // We don't inspect `err`. If the request was superseded, `onAbort`
+                    // already ran synchronously (abort listeners fire during
+                    // `signal.abort()`, before this rejection microtask), so `closed` is
+                    // true and the controller is already closed — erroring it would
+                    // throw, and a superseded request's failure is moot regardless of its
+                    // cause. Only a genuine, non-superseded failure reaches here with
+                    // `closed` still false; that is the case we surface.
+                    if (!closed) {
+                        controller.error(err);
+                    }
+                    return;
+                }
+                if (closed) {
+                    // Aborted while awaiting the response. The `fetch` abort tears down
+                    // an in-flight request, but if it had already completed we still hold
+                    // an unread body; release it so it isn't left dangling.
+                    response.body?.cancel().catch(()=>{});
+                    return;
+                }
+                const body = response.body;
+                if (body === null) {
+                    controller.close();
+                    return;
+                }
+                reader = body.getReader();
+            }
+            try {
+                const { done, value } = await reader.read();
+                if (closed) {
+                    return;
+                }
+                if (done) {
+                    controller.close();
+                } else {
+                    controller.enqueue(value);
+                }
+            } catch (err) {
+                // Same as the fetch catch above: once superseded (`closed`) the
+                // controller is already closed and the outcome is moot, so we swallow
+                // the rejection unconditionally; only a real, non-superseded read
+                // failure (`closed` still false) is surfaced.
+                if (!closed) {
+                    controller.error(err);
+                }
+            }
+        }
+    });
+    // React attaches `_debugInfo` to the returned promise at runtime.
+    return createFromNextReadableStream(wrapper, headers, {
         allowPartialStream: true
     });
 }
+// Selects the Flight decode strategy: a halting wrapper for cancellable HMR
+// refreshes, otherwise the standard fetch-based decode. Gated to the dev server
+// (where HMR runs) so the wrapper is eliminated from production and
+// `--debug-prerender` bundles regardless of the flag.
+function decodeFlightResponse(fetchPromise, headers, signal) {
+    if (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_SERVER_COMPONENTS_HMR_CANCELLATION && signal) {
+        return createHaltingFlightResponse(fetchPromise, headers, signal);
+    }
+    return createFromNextFetch(fetchPromise, headers);
+}
 async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode, signal) {
     // TODO: In output: "export" mode, the headers do nothing. Omit them (and the
     // cache busting search param) from the request so they're
@@ -313,7 +489,7 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
     // track them separately.
     let fetchUrl = new URL(url);
     await (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
-    let processed = fetch(fetchUrl, fetchOptions).then(processFetch);
+    let processed = (0, _fetch.fetch)(fetchUrl, fetchOptions).then(processFetch);
     let fetchPromise = processed.then(({ response })=>response);
     // Immediately pass the fetch promise to the Flight client so that the debug
     // info includes the latency from the client to the server. The internal timer
@@ -323,7 +499,7 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
     // top-level prefetch response never blocks a navigation; if it hasn't already
     // been written into the cache by the time the navigation happens, the router
     // will go straight to a dynamic request.
-    let flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
+    let flightResponsePromise = shouldImmediatelyDecode ? decodeFlightResponse(fetchPromise, headers, signal) : null;
     let browserResponse = await fetchPromise;
     // If the server responds with a redirect (e.g. 307), and the redirected
     // location does not contain the cache busting search param set in the
@@ -368,9 +544,9 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
             // TODO: We should abort the previous request.
             fetchUrl = new URL(responseUrl);
             await (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
-            processed = fetch(fetchUrl, fetchOptions).then(processFetch);
+            processed = (0, _fetch.fetch)(fetchUrl, fetchOptions).then(processFetch);
             fetchPromise = processed.then(({ response })=>response);
-            flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
+            flightResponsePromise = shouldImmediatelyDecode ? decodeFlightResponse(fetchPromise, headers, signal) : null;
             browserResponse = await fetchPromise;
             // We just performed a manual redirect, so this is now true.
             redirected = true;
@@ -417,36 +593,6 @@ function createFromNextFetch(promiseForResponse, requestHeaders) {
         debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
     });
 }
-function truncateStream(stream, byteLength) {
-    const reader = stream.getReader();
-    let remaining = byteLength;
-    return new ReadableStream({
-        async pull (controller) {
-            if (remaining <= 0) {
-                reader.cancel();
-                controller.close();
-                return;
-            }
-            const { done, value } = await reader.read();
-            if (done) {
-                controller.close();
-                return;
-            }
-            if (value.byteLength <= remaining) {
-                controller.enqueue(value);
-                remaining -= value.byteLength;
-            } else {
-                controller.enqueue(value.subarray(0, remaining));
-                remaining = 0;
-                reader.cancel();
-                controller.close();
-            }
-        },
-        cancel () {
-            reader.cancel();
-        }
-    });
-}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });