react-router 0.0.0-experimental-4ed3f5da9 → 0.0.0-experimental-cb25a21e1

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * React Router v0.0.0-experimental-4ed3f5da9
+ * React Router v0.0.0-experimental-cb25a21e1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -12,123 +12,6 @@ import * as React from 'react';
 import * as ReactDOM from 'react-dom';
 import { decode } from 'turbo-stream';
 
-function _AsyncGenerator(gen) {
-  var front, back;
-  function resume(key, arg) {
-    try {
-      var result = gen[key](arg),
-        value = result.value,
-        overloaded = value instanceof _OverloadYield;
-      Promise.resolve(overloaded ? value.v : value).then(function (arg) {
-        if (overloaded) {
-          var nextKey = "return" === key ? "return" : "next";
-          if (!value.k || arg.done) return resume(nextKey, arg);
-          arg = gen[nextKey](arg).value;
-        }
-        settle(result.done ? "return" : "normal", arg);
-      }, function (err) {
-        resume("throw", err);
-      });
-    } catch (err) {
-      settle("throw", err);
-    }
-  }
-  function settle(type, value) {
-    switch (type) {
-      case "return":
-        front.resolve({
-          value: value,
-          done: !0
-        });
-        break;
-      case "throw":
-        front.reject(value);
-        break;
-      default:
-        front.resolve({
-          value: value,
-          done: !1
-        });
-    }
-    (front = front.next) ? resume(front.key, front.arg) : back = null;
-  }
-  this._invoke = function (key, arg) {
-    return new Promise(function (resolve, reject) {
-      var request = {
-        key: key,
-        arg: arg,
-        resolve: resolve,
-        reject: reject,
-        next: null
-      };
-      back ? back = back.next = request : (front = back = request, resume(key, arg));
-    });
-  }, "function" != typeof gen.return && (this.return = void 0);
-}
-_AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () {
-  return this;
-}, _AsyncGenerator.prototype.next = function (arg) {
-  return this._invoke("next", arg);
-}, _AsyncGenerator.prototype.throw = function (arg) {
-  return this._invoke("throw", arg);
-}, _AsyncGenerator.prototype.return = function (arg) {
-  return this._invoke("return", arg);
-};
-function _OverloadYield(value, kind) {
-  this.v = value, this.k = kind;
-}
-function _asyncIterator(iterable) {
-  var method,
-    async,
-    sync,
-    retry = 2;
-  for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
-    if (async && null != (method = iterable[async])) return method.call(iterable);
-    if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
-    async = "@@asyncIterator", sync = "@@iterator";
-  }
-  throw new TypeError("Object is not async iterable");
-}
-function AsyncFromSyncIterator(s) {
-  function AsyncFromSyncIteratorContinuation(r) {
-    if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
-    var done = r.done;
-    return Promise.resolve(r.value).then(function (value) {
-      return {
-        value: value,
-        done: done
-      };
-    });
-  }
-  return AsyncFromSyncIterator = function (s) {
-    this.s = s, this.n = s.next;
-  }, AsyncFromSyncIterator.prototype = {
-    s: null,
-    n: null,
-    next: function () {
-      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
-    },
-    return: function (value) {
-      var ret = this.s.return;
-      return void 0 === ret ? Promise.resolve({
-        value: value,
-        done: !0
-      }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
-    },
-    throw: function (value) {
-      var thr = this.s.return;
-      return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
-    }
-  }, new AsyncFromSyncIterator(s);
-}
-function _awaitAsyncGenerator(value) {
-  return new _OverloadYield(value, 0);
-}
-function _wrapAsyncGenerator(fn) {
-  return function () {
-    return new _AsyncGenerator(fn.apply(this, arguments));
-  };
-}
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
@@ -1603,6 +1486,7 @@ function createRouter(init) {
   // Flag to ignore the next history update, so we can revert the URL change on
   // a POP navigation that was blocked by the user without touching router state
   let ignoreNextHistoryUpdate = false;
+  let pendingRevalidationDfd = null;
   // Initialize the router, all side effects should be kicked off from here.
   // Implemented as a Fluent API for ease of:
   //   let router = createRouter(init).initialize();
@@ -1739,7 +1623,7 @@ function createRouter(init) {
   // - Navigation will always be set to IDLE_NAVIGATION
   // - Can pass any other state in newState
   function completeNavigation(location, newState, _temp) {
-    var _location$state, _location$state2;
+    var _location$state, _location$state2, _pendingRevalidationD;
     let {
       flushSync
     } = _temp === void 0 ? {} : _temp;
@@ -1839,6 +1723,8 @@ function createRouter(init) {
     pendingViewTransitionEnabled = false;
     isUninterruptedRevalidation = false;
     isRevalidationRequired = false;
+    (_pendingRevalidationD = pendingRevalidationDfd) == null ? void 0 : _pendingRevalidationD.resolve();
+    pendingRevalidationDfd = null;
     cancelledDeferredRoutes = [];
     cancelledFetcherLoads = [];
   }
@@ -1906,7 +1792,7 @@ function createRouter(init) {
       });
       return;
     }
-    return await startNavigation(historyAction, nextLocation, {
+    await startNavigation(historyAction, nextLocation, {
       submission,
       // Send through the formData serialization error if we have one so we can
       // render at the right error boundary after we match routes
@@ -1921,14 +1807,29 @@ function createRouter(init) {
   // is interrupted by a navigation, allow this to "succeed" by calling all
   // loaders during the next loader round
   function revalidate() {
+    // We can't just return the promise from `startNavigation` because that
+    // navigation may be interrupted and our revalidation wouldn't be finished
+    // until the _next_ navigation completes.  Instead we just track via a
+    // deferred and resolve it the next time we run through `completeNavigation`
+    // This is different than navigations which will settle if interrupted
+    // because the navigation to a specific location is no longer relevant.
+    // Revalidations are location-independent and will settle whenever we land
+    // on our final location
+    if (!pendingRevalidationDfd) {
+      pendingRevalidationDfd = createDeferred();
+    }
     interruptActiveLoads();
     updateState({
       revalidation: "loading"
     });
+    // Capture this here for the edge-case that we have a fully synchronous
+    // startNavigation which would resolve and null out pendingRevalidationDfd
+    // before we return from this function
+    let promise = pendingRevalidationDfd.promise;
     // If we're currently submitting an action, we don't need to start a new
     // navigation, we'll just let the follow up loader execution call all loaders
     if (state.navigation.state === "submitting") {
-      return;
+      return promise;
     }
     // If we're currently in an idle state, start a new navigation for the current
     // action/location and mark it as uninterrupted, which will skip the history
@@ -1937,7 +1838,7 @@ function createRouter(init) {
       startNavigation(state.historyAction, state.location, {
         startUninterruptedRevalidation: true
       });
-      return;
+      return promise;
     }
     // Otherwise, if we're currently in a loading state, just start a new
     // navigation to the navigation.location but do not trigger an uninterrupted
@@ -1945,6 +1846,7 @@ function createRouter(init) {
     startNavigation(pendingAction || state.historyAction, state.navigation.location, {
       overrideNavigation: state.navigation
     });
+    return promise;
   }
   // Start a navigation to the given action/location.  Can optionally provide a
   // overrideNavigation which will override the normalLoad in the case of a redirect
@@ -2287,7 +2189,7 @@ function createRouter(init) {
     } : {});
   }
   // Trigger a fetcher load/submit for the given fetcher key
-  function fetch(key, routeId, href, opts) {
+  async function fetch(key, routeId, href, opts) {
     if (isServer) {
       throw new Error("router.fetch() was called during the server render, but it shouldn't be. " + "You are likely calling a useFetcher() method in the body of your component. " + "Try moving it to a useEffect or a callback.");
     }
@@ -2318,7 +2220,7 @@ function createRouter(init) {
     let match = getTargetMatch(matches, path);
     pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
     if (submission && isMutationMethod(submission.formMethod)) {
-      handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);
+      await handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);
       return;
     }
     // Store off the match so we can call it's shouldRevalidate on subsequent
@@ -2327,7 +2229,7 @@ function createRouter(init) {
       routeId,
       path
     });
-    handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);
+    await handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);
   }
   // Call the action for the matched fetcher.submit(), and then handle redirects,
   // errors, and revalidation
@@ -3082,7 +2984,7 @@ function createStaticHandler$1(routes, opts) {
       };
     }
     let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, skipLoaderErrorBubbling === true, null);
-    if (isResponse$1(result)) {
+    if (isResponse(result)) {
       return result;
     }
     // When returning StaticHandlerContext, we patch back in the location here
@@ -3151,7 +3053,7 @@ function createStaticHandler$1(routes, opts) {
       });
     }
     let result = await queryImpl(request, location, matches, requestContext, null, false, match);
-    if (isResponse$1(result)) {
+    if (isResponse(result)) {
       return result;
     }
     let error = result.errors ? Object.values(result.errors)[0] : undefined;
@@ -3184,7 +3086,7 @@ function createStaticHandler$1(routes, opts) {
         return result;
       }
       let result = await loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch);
-      return isResponse$1(result) ? result : _extends({}, result, {
+      return isResponse(result) ? result : _extends({}, result, {
         actionData: null,
         actionHeaders: {}
       });
@@ -3192,7 +3094,7 @@ function createStaticHandler$1(routes, opts) {
       // If the user threw/returned a Response in callLoaderOrAction for a
       // `queryRoute` call, we throw the `HandlerResult` to bail out early
       // and then return or throw the raw Response here accordingly
-      if (isHandlerResult(e) && isResponse$1(e.result)) {
+      if (isHandlerResult(e) && isResponse(e.result)) {
         if (e.type === ResultType.error) {
           throw e.result;
         }
@@ -3200,7 +3102,7 @@ function createStaticHandler$1(routes, opts) {
       }
       // Redirects are always returned since they don't propagate to catch
       // boundaries
-      if (isRedirectResponse$1(e)) {
+      if (isRedirectResponse(e)) {
         return e;
       }
       throw e;
@@ -3363,7 +3265,7 @@ function createStaticHandler$1(routes, opts) {
         // Throw redirects and let the server handle them with an HTTP redirect
         throw normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath);
       }
-      if (isResponse$1(result.result) && isRouteRequest) {
+      if (isResponse(result.result) && isRouteRequest) {
         // For SSR single-route requests, we want to hand Responses back
         // directly without unwrapping
         throw result;
@@ -3942,7 +3844,7 @@ async function convertHandlerResultToDataResult(handlerResult) {
     type,
     status
   } = handlerResult;
-  if (isResponse$1(result)) {
+  if (isResponse(result)) {
     let data;
     try {
       let contentType = result.headers.get("Content-Type");
@@ -3985,7 +3887,7 @@ async function convertHandlerResultToDataResult(handlerResult) {
       statusCode: isRouteErrorResponse(result) ? result.status : status
     };
   }
-  if (isDeferredData$1(result)) {
+  if (isDeferredData(result)) {
     var _result$init, _result$init2;
     return {
       type: ResultType.deferred,
@@ -4332,7 +4234,7 @@ function isHandlerResult(result) {
   return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
 }
 function isRedirectHandlerResult(result) {
-  return isResponse$1(result.result) && redirectStatusCodes.has(result.result.status);
+  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
 }
 function isDeferredResult(result) {
   return result.type === ResultType.deferred;
@@ -4343,15 +4245,15 @@ function isErrorResult(result) {
 function isRedirectResult(result) {
   return (result && result.type) === ResultType.redirect;
 }
-function isDeferredData$1(value) {
+function isDeferredData(value) {
   let deferred = value;
   return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
 }
-function isResponse$1(value) {
+function isResponse(value) {
   return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
 }
-function isRedirectResponse$1(result) {
-  if (!isResponse$1(result)) {
+function isRedirectResponse(result) {
+  if (!isResponse(result)) {
     return false;
   }
   let status = result.status;
@@ -4593,6 +4495,31 @@ function persistAppliedTransitions(_window, transitions) {
     }
   }
 }
+function createDeferred() {
+  let resolve;
+  let reject;
+  let promise = new Promise((res, rej) => {
+    resolve = async val => {
+      res(val);
+      try {
+        await promise;
+      } catch (e) {}
+    };
+    reject = async error => {
+      rej(error);
+      try {
+        await promise;
+      } catch (e) {}
+    };
+  });
+  return {
+    promise,
+    //@ts-ignore
+    resolve,
+    //@ts-ignore
+    reject
+  };
+}
 //#endregion
 
 const DataRouterContext = /*#__PURE__*/React.createContext(null);
@@ -5251,9 +5178,11 @@ function useRevalidator() {
   let dataRouterContext = useDataRouterContext$2(DataRouterHook$1.UseRevalidator);
   let state = useDataRouterState$1(DataRouterStateHook$1.UseRevalidator);
   return React.useMemo(() => ({
-    revalidate: dataRouterContext.router.revalidate,
+    async revalidate() {
+      await dataRouterContext.router.revalidate();
+    },
     state: state.revalidation
-  }), [dataRouterContext.router.revalidate, state.revalidation]);
+  }), [dataRouterContext.router, state.revalidation]);
 }
 /**
  * Returns the active route matches, useful for accessing loaderData for
@@ -5415,7 +5344,7 @@ function useNavigateStable() {
   useIsomorphicLayoutEffect(() => {
     activeRef.current = true;
   });
-  let navigate = React.useCallback(function (to, options) {
+  let navigate = React.useCallback(async function (to, options) {
     if (options === void 0) {
       options = {};
     }
@@ -5426,7 +5355,7 @@ function useNavigateStable() {
     if (typeof to === "number") {
       router.navigate(to);
     } else {
-      router.navigate(to, _extends({
+      await router.navigate(to, _extends({
         fromRouteId: id
       }, options));
     }
@@ -5689,11 +5618,13 @@ function Navigate(_ref4) {
   // StrictMode they navigate to the same place
   let path = resolveTo(to, getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === "path");
   let jsonPath = JSON.stringify(path);
-  React.useEffect(() => navigate(JSON.parse(jsonPath), {
-    replace,
-    state,
-    relative
-  }), [navigate, jsonPath, relative, replace, state]);
+  React.useEffect(() => {
+    navigate(JSON.parse(jsonPath), {
+      replace,
+      state,
+      relative
+    });
+  }, [navigate, jsonPath, relative, replace, state]);
   return null;
 }
 /**
@@ -6367,18 +6298,6 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
   });
   return newMatches;
 }
-function getDataLinkHrefs(page, matches, manifest) {
-  let path = parsePathPatch(page);
-  return dedupeHrefs(matches.filter(match => manifest.routes[match.route.id].hasLoader).map(match => {
-    let {
-      pathname,
-      search
-    } = path;
-    let searchParams = new URLSearchParams(search);
-    searchParams.set("_data", match.route.id);
-    return pathname + "?" + searchParams;
-  }));
-}
 function getModuleLinkHrefs(matches, manifestPatch) {
   return dedupeHrefs(matches.map(match => {
     let route = manifestPatch.routes[match.route.id];
@@ -6473,71 +6392,6 @@ function createHtml(html) {
   };
 }
 
-function isCatchResponse(response) {
-  return response.headers.get("X-Remix-Catch") != null;
-}
-function isErrorResponse(response) {
-  return response.headers.get("X-Remix-Error") != null;
-}
-function isNetworkErrorResponse(response) {
-  // If we reach the Remix server, we can safely identify response types via the
-  // X-Remix-Error/X-Remix-Catch headers.  However, if we never reach the Remix
-  // server, and instead receive a 4xx/5xx from somewhere in between (like
-  // Cloudflare), then we get a false negative in the isErrorResponse check and
-  // we incorrectly assume that the user returns the 4xx/5xx response and
-  // consider it successful.  To alleviate this, we add X-Remix-Response to any
-  // non-Error/non-Catch responses coming back from the server.  If we don't
-  // see this, we can conclude that a 4xx/5xx response never actually reached
-  // the Remix server and we can bubble it up as an error.
-  return isResponse(response) && response.status >= 400 && response.headers.get("X-Remix-Error") == null && response.headers.get("X-Remix-Catch") == null && response.headers.get("X-Remix-Response") == null;
-}
-function isRedirectResponse(response) {
-  return response.headers.get("X-Remix-Redirect") != null;
-}
-function isDeferredResponse(response) {
-  var _response$headers$get;
-  return !!((_response$headers$get = response.headers.get("Content-Type")) != null && _response$headers$get.match(/text\/remix-deferred/));
-}
-function isResponse(value) {
-  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-}
-function isDeferredData(value) {
-  let deferred = value;
-  return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
-}
-async function fetchData(request, routeId, retry) {
-  if (retry === void 0) {
-    retry = 0;
-  }
-  let url = new URL(request.url);
-  url.searchParams.set("_data", routeId);
-  if (retry > 0) {
-    // Retry up to 3 times waiting 50, 250, 1250 ms
-    // between retries for a total of 1550 ms before giving up.
-    await new Promise(resolve => setTimeout(resolve, 5 ** retry * 10));
-  }
-  let init = await createRequestInit(request);
-  let revalidation = window.__remixRevalidation;
-  let response = await fetch(url.href, init).catch(error => {
-    if (typeof revalidation === "number" && revalidation === window.__remixRevalidation && (error == null ? void 0 : error.name) === "TypeError" && retry < 3) {
-      return fetchData(request, routeId, retry + 1);
-    }
-    throw error;
-  });
-  if (isErrorResponse(response)) {
-    let data = await response.json();
-    let error = new Error(data.message);
-    error.stack = data.stack;
-    return error;
-  }
-  if (isNetworkErrorResponse(response)) {
-    let text = await response.text();
-    let error = new Error(text);
-    error.stack = undefined;
-    return error;
-  }
-  return response;
-}
 async function createRequestInit(request) {
   let init = {
     signal: request.signal
@@ -6565,184 +6419,6 @@ async function createRequestInit(request) {
   }
   return init;
 }
-const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-async function parseDeferredReadableStream(stream) {
-  if (!stream) {
-    throw new Error("parseDeferredReadableStream requires stream argument");
-  }
-  let deferredData;
-  let deferredResolvers = {};
-  try {
-    let sectionReader = readStreamSections(stream);
-    // Read the first section to get the critical data
-    let initialSectionResult = await sectionReader.next();
-    let initialSection = initialSectionResult.value;
-    if (!initialSection) throw new Error("no critical data");
-    let criticalData = JSON.parse(initialSection);
-    // Setup deferred data and resolvers for later based on the critical data
-    if (typeof criticalData === "object" && criticalData !== null) {
-      for (let [eventKey, value] of Object.entries(criticalData)) {
-        if (typeof value !== "string" || !value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
-          continue;
-        }
-        deferredData = deferredData || {};
-        deferredData[eventKey] = new Promise((_resolve, _reject) => {
-          deferredResolvers[eventKey] = {
-            resolve: value => {
-              _resolve(value);
-              delete deferredResolvers[eventKey];
-            },
-            reject: error => {
-              _reject(error);
-              delete deferredResolvers[eventKey];
-            }
-          };
-        });
-      }
-    }
-    // Read the rest of the stream and resolve deferred promises
-    void (async () => {
-      try {
-        var _iteratorAbruptCompletion = false;
-        var _didIteratorError = false;
-        var _iteratorError;
-        try {
-          for (var _iterator = _asyncIterator(sectionReader), _step; _iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
-            let section = _step.value;
-            {
-              // Determine event type and data
-              let [event, ...sectionDataStrings] = section.split(":");
-              let sectionDataString = sectionDataStrings.join(":");
-              let data = JSON.parse(sectionDataString);
-              if (event === "data") {
-                for (let [key, value] of Object.entries(data)) {
-                  if (deferredResolvers[key]) {
-                    deferredResolvers[key].resolve(value);
-                  }
-                }
-              } else if (event === "error") {
-                for (let [key, value] of Object.entries(data)) {
-                  let err = new Error(value.message);
-                  err.stack = value.stack;
-                  if (deferredResolvers[key]) {
-                    deferredResolvers[key].reject(err);
-                  }
-                }
-              }
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (_iteratorAbruptCompletion && _iterator.return != null) {
-              await _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-        }
-        for (let [key, resolver] of Object.entries(deferredResolvers)) {
-          resolver.reject(new AbortedDeferredError("Deferred " + key + " will never be resolved"));
-        }
-      } catch (error) {
-        // Reject any existing deferred promises if something blows up
-        for (let resolver of Object.values(deferredResolvers)) {
-          resolver.reject(error);
-        }
-      }
-    })();
-    return new DeferredData(_extends({}, criticalData, deferredData));
-  } catch (error) {
-    for (let resolver of Object.values(deferredResolvers)) {
-      resolver.reject(error);
-    }
-    throw error;
-  }
-}
-function readStreamSections(_x) {
-  return _readStreamSections.apply(this, arguments);
-}
-function _readStreamSections() {
-  _readStreamSections = _wrapAsyncGenerator(function* (stream) {
-    let reader = stream.getReader();
-    let buffer = [];
-    let sections = [];
-    let closed = false;
-    let encoder = new TextEncoder();
-    let decoder = new TextDecoder();
-    let readStreamSection = async () => {
-      if (sections.length > 0) return sections.shift();
-      // Read from the stream until we have at least one complete section to process
-      while (!closed && sections.length === 0) {
-        let chunk = await reader.read();
-        if (chunk.done) {
-          closed = true;
-          break;
-        }
-        // Buffer the raw chunks
-        buffer.push(chunk.value);
-        try {
-          // Attempt to split off a section from the buffer
-          let bufferedString = decoder.decode(mergeArrays(...buffer));
-          let splitSections = bufferedString.split("\n\n");
-          if (splitSections.length >= 2) {
-            // We have a complete section, so add it to the sections array
-            sections.push(...splitSections.slice(0, -1));
-            // Remove the section from the buffer and store the rest for future processing
-            buffer = [encoder.encode(splitSections.slice(-1).join("\n\n"))];
-          }
-          // If we successfully parsed at least one section, break out of reading the stream
-          // to allow upstream processing of the processable sections
-          if (sections.length > 0) {
-            break;
-          }
-        } catch (_unused) {
-          // If we failed to parse the buffer it was because we failed to decode the stream
-          // because we are missing bytes that we haven't yet received, so continue reading
-          // from the stream until we have a complete section
-          continue;
-        }
-      }
-      // If we have a complete section, return it
-      if (sections.length > 0) {
-        return sections.shift();
-      }
-      // If we have no complete section, but we have no more chunks to process,
-      // split those sections and clear out the buffer as there is no more data
-      // to process. If this errors, let it bubble up as the stream ended
-      // without valid data
-      if (buffer.length > 0) {
-        let bufferedString = decoder.decode(mergeArrays(...buffer));
-        sections = bufferedString.split("\n\n").filter(s => s);
-        buffer = [];
-      }
-      // Return any remaining sections that have been processed
-      return sections.shift();
-    };
-    let section = yield _awaitAsyncGenerator(readStreamSection());
-    while (section) {
-      yield section;
-      section = yield _awaitAsyncGenerator(readStreamSection());
-    }
-  });
-  return _readStreamSections.apply(this, arguments);
-}
-function mergeArrays() {
-  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
-    arrays[_key] = arguments[_key];
-  }
-  let out = new Uint8Array(arrays.reduce((total, arr) => total + arr.length, 0));
-  let offset = 0;
-  for (let arr of arrays) {
-    out.set(arr, offset);
-    offset += arr.length;
-  }
-  return out;
-}
 
 const SingleFetchRedirectSymbol = Symbol("SingleFetchRedirect");
 // StreamTransfer recursively renders down chunks of the `serverHandoffStream`
@@ -6935,7 +6611,10 @@ function addRevalidationParam(manifest, routeModules, matchedRoutes, loadRoutes,
   return url;
 }
 function singleFetchUrl(reqUrl) {
-  let url = typeof reqUrl === "string" ? new URL(reqUrl, window.location.origin) : reqUrl;
+  let url = typeof reqUrl === "string" ? new URL(reqUrl,
+  // This can be called during the SSR flow via PrefetchPageLinksImpl so
+  // don't assume window is available
+  typeof window === "undefined" ? "server://singlefetch/" : window.location.origin) : reqUrl;
   url.pathname = (url.pathname === "/" ? "_root" : url.pathname) + ".data";
   return url;
 }
@@ -7243,7 +6922,6 @@ function PrefetchPageLinksImpl(_ref3) {
     linkProps = _objectWithoutPropertiesLoose(_ref3, _excluded2$1);
   let location = useLocation();
   let {
-    future,
     manifest,
     routeModules
   } = useRemixContext();
@@ -7252,21 +6930,12 @@ function PrefetchPageLinksImpl(_ref3) {
   } = useDataRouterStateContext();
   let newMatchesForData = React.useMemo(() => getNewMatchesForLinks(page, nextMatches, matches, manifest, location, "data"), [page, nextMatches, matches, manifest, location]);
   let newMatchesForAssets = React.useMemo(() => getNewMatchesForLinks(page, nextMatches, matches, manifest, location, "assets"), [page, nextMatches, matches, manifest, location]);
-  let dataHrefs = React.useMemo(() => getDataLinkHrefs(page, newMatchesForData, manifest), [newMatchesForData, page, manifest]);
   let moduleHrefs = React.useMemo(() => getModuleLinkHrefs(newMatchesForAssets, manifest), [newMatchesForAssets, manifest]);
   // needs to be a hook with async behavior because we need the modules, not
   // just the manifest like the other links in here.
   let keyedPrefetchLinks = useKeyedPrefetchLinks(newMatchesForAssets);
   let linksToRender = null;
-  if (!future.unstable_singleFetch) {
-    // Non-single-fetch prefetching
-    linksToRender = dataHrefs.map(href => ( /*#__PURE__*/React.createElement("link", _extends({
-      key: href,
-      rel: "prefetch",
-      as: "fetch",
-      href: href
-    }, linkProps))));
-  } else if (newMatchesForData.length > 0) {
+  if (newMatchesForData.length > 0) {
     // Single-fetch with routes that require data
     let url = addRevalidationParam(manifest, routeModules, nextMatches.map(m => m.route), newMatchesForData.map(m => m.route), singleFetchUrl(page));
     if (url.searchParams.get("_routes") !== "") {
@@ -7277,7 +6946,7 @@ function PrefetchPageLinksImpl(_ref3) {
         href: url.pathname + url.search
       }, linkProps));
     }
-  } else ;
+  }
   return /*#__PURE__*/React.createElement(React.Fragment, null, linksToRender, moduleHrefs.map(href => ( /*#__PURE__*/React.createElement("link", _extends({
     key: href,
     rel: "modulepreload",
@@ -7450,10 +7119,7 @@ function Scripts(props) {
   let {
     manifest,
     serverHandoffString,
-    abortDelay,
-    serializeError,
     isSpaMode,
-    future,
     renderMeta
   } = useRemixContext();
   let {
@@ -7474,89 +7140,10 @@ function Scripts(props) {
   React.useEffect(() => {
     isHydrated = true;
   }, []);
-  let serializePreResolvedErrorImp = (key, error) => {
-    let toSerialize;
-    if (serializeError && error instanceof Error) {
-      toSerialize = serializeError(error);
-    } else {
-      toSerialize = error;
-    }
-    return JSON.stringify(key) + ":__remixContext.p(!1, " + escapeHtml(JSON.stringify(toSerialize)) + ")";
-  };
-  let serializePreresolvedDataImp = (routeId, key, data) => {
-    let serializedData;
-    try {
-      serializedData = JSON.stringify(data);
-    } catch (error) {
-      return serializePreResolvedErrorImp(key, error);
-    }
-    return JSON.stringify(key) + ":__remixContext.p(" + escapeHtml(serializedData) + ")";
-  };
-  let serializeErrorImp = (routeId, key, error) => {
-    let toSerialize;
-    if (serializeError && error instanceof Error) {
-      toSerialize = serializeError(error);
-    } else {
-      toSerialize = error;
-    }
-    return "__remixContext.r(" + JSON.stringify(routeId) + ", " + JSON.stringify(key) + ", !1, " + escapeHtml(JSON.stringify(toSerialize)) + ")";
-  };
-  let serializeDataImp = (routeId, key, data) => {
-    let serializedData;
-    try {
-      serializedData = JSON.stringify(data);
-    } catch (error) {
-      return serializeErrorImp(routeId, key, error);
-    }
-    return "__remixContext.r(" + JSON.stringify(routeId) + ", " + JSON.stringify(key) + ", " + escapeHtml(serializedData) + ")";
-  };
-  let deferredScripts = [];
   let initialScripts = React.useMemo(() => {
     var _manifest$hmr;
-    let streamScript = future.unstable_singleFetch ?
-    // prettier-ignore
-    "window.__remixContext.stream = new ReadableStream({" + "start(controller){" + "window.__remixContext.streamController = controller;" + "}" + "}).pipeThrough(new TextEncoderStream());" : "";
+    let streamScript = "window.__remixContext.stream = new ReadableStream({" + "start(controller){" + "window.__remixContext.streamController = controller;" + "}" + "}).pipeThrough(new TextEncoderStream());";
     let contextScript = staticContext ? "window.__remixContext = " + serverHandoffString + ";" + streamScript : " ";
-    // When single fetch is enabled, deferred is handled by turbo-stream
-    let activeDeferreds = future.unstable_singleFetch ? undefined : staticContext == null ? void 0 : staticContext.activeDeferreds;
-    // This sets up the __remixContext with utility functions used by the
-    // deferred scripts.
-    // - __remixContext.p is a function that takes a resolved value or error and returns a promise.
-    //   This is used for transmitting pre-resolved promises from the server to the client.
-    // - __remixContext.n is a function that takes a routeID and key to returns a promise for later
-    //   resolution by the subsequently streamed chunks.
-    // - __remixContext.r is a function that takes a routeID, key and value or error and resolves
-    //   the promise created by __remixContext.n.
-    // - __remixContext.t is a map or routeId to keys to an object containing `e` and `r` methods
-    //   to resolve or reject the promise created by __remixContext.n.
-    // - __remixContext.a is the active number of deferred scripts that should be rendered to match
-    //   the SSR tree for hydration on the client.
-    contextScript += !activeDeferreds ? "" : ["__remixContext.p = function(v,e,p,x) {", "  if (typeof e !== 'undefined') {", process.env.NODE_ENV === "development" ? "    x=new Error(e.message);\n    x.stack=e.stack;" : '    x=new Error("Unexpected Server Error");\n    x.stack=undefined;', "    p=Promise.reject(x);", "  } else {", "    p=Promise.resolve(v);", "  }", "  return p;", "};", "__remixContext.n = function(i,k) {", "  __remixContext.t = __remixContext.t || {};", "  __remixContext.t[i] = __remixContext.t[i] || {};", "  let p = new Promise((r, e) => {__remixContext.t[i][k] = {r:(v)=>{r(v);},e:(v)=>{e(v);}};});", typeof abortDelay === "number" ? "setTimeout(() => {if(typeof p._error !== \"undefined\" || typeof p._data !== \"undefined\"){return;} __remixContext.t[i][k].e(new Error(\"Server timeout.\"))}, " + abortDelay + ");" : "", "  return p;", "};", "__remixContext.r = function(i,k,v,e,p,x) {", "  p = __remixContext.t[i][k];", "  if (typeof e !== 'undefined') {", process.env.NODE_ENV === "development" ? "    x=new Error(e.message);\n    x.stack=e.stack;" : '    x=new Error("Unexpected Server Error");\n    x.stack=undefined;', "    p.e(x);", "  } else {", "    p.r(v);", "  }", "};"].join("\n") + Object.entries(activeDeferreds).map(_ref5 => {
-      let [routeId, deferredData] = _ref5;
-      let pendingKeys = new Set(deferredData.pendingKeys);
-      let promiseKeyValues = deferredData.deferredKeys.map(key => {
-        if (pendingKeys.has(key)) {
-          deferredScripts.push( /*#__PURE__*/React.createElement(DeferredHydrationScript, {
-            key: routeId + " | " + key,
-            deferredData: deferredData,
-            routeId: routeId,
-            dataKey: key,
-            scriptProps: props,
-            serializeData: serializeDataImp,
-            serializeError: serializeErrorImp
-          }));
-          return JSON.stringify(key) + ":__remixContext.n(" + JSON.stringify(routeId) + ", " + JSON.stringify(key) + ")";
-        } else {
-          let trackedPromise = deferredData.data[key];
-          if (typeof trackedPromise._error !== "undefined") {
-            return serializePreResolvedErrorImp(key, trackedPromise._error);
-          } else {
-            return serializePreresolvedDataImp(routeId, key, trackedPromise._data);
-          }
-        }
-      }).join(",\n");
-      return "Object.assign(__remixContext.state.loaderData[" + JSON.stringify(routeId) + "], {" + promiseKeyValues + "});";
-    }).join("\n") + (deferredScripts.length > 0 ? "__remixContext.a=" + deferredScripts.length + ";" : "");
     let routeModulesScript = !isStatic ? " " : ((_manifest$hmr = manifest.hmr) != null && _manifest$hmr.runtime ? "import " + JSON.stringify(manifest.hmr.runtime) + ";" : "") + "import " + JSON.stringify(manifest.url) + ";\n" + matches.map((match, index) => "import * as route" + index + " from " + JSON.stringify(manifest.routes[match.route.id].module) + ";").join("\n") + "\nwindow.__remixRouteModules = {" + matches.map((match, index) => JSON.stringify(match.route.id) + ":route" + index).join(",") + "};\n\nimport(" + JSON.stringify(manifest.entry.module) + ");";
     return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("script", _extends({}, props, {
       suppressHydrationWarning: true,
@@ -7573,16 +7160,6 @@ function Scripts(props) {
     // scripts as they were when the page first loaded
     // eslint-disable-next-line
   }, []);
-  if (!isStatic && typeof __remixContext === "object" && __remixContext.a) {
-    for (let i = 0; i < __remixContext.a; i++) {
-      deferredScripts.push( /*#__PURE__*/React.createElement(DeferredHydrationScript, {
-        key: i,
-        scriptProps: props,
-        serializeData: serializeDataImp,
-        serializeError: serializeErrorImp
-      }));
-    }
-  }
   // avoid waterfall when importing the next route module
   let nextMatches = React.useMemo(() => {
     if (navigation.location) {
@@ -7611,71 +7188,7 @@ function Scripts(props) {
     rel: "modulepreload",
     href: path,
     crossOrigin: props.crossOrigin
-  }))), initialScripts, deferredScripts));
-}
-function DeferredHydrationScript(_ref6) {
-  let {
-    dataKey,
-    deferredData,
-    routeId,
-    scriptProps,
-    serializeData,
-    serializeError
-  } = _ref6;
-  if (typeof document === "undefined" && deferredData && dataKey && routeId) {
-    !deferredData.pendingKeys.includes(dataKey) ? process.env.NODE_ENV !== "production" ? invariant(false, "Deferred data for route " + routeId + " with key " + dataKey + " was not pending but tried to render a script for it.") : invariant(false) : void 0;
-  }
-  return /*#__PURE__*/React.createElement(React.Suspense, {
-    fallback:
-    // This makes absolutely no sense. The server renders null as a fallback,
-    // but when hydrating, we need to render a script tag to avoid a hydration issue.
-    // To reproduce a hydration mismatch, just render null as a fallback.
-    typeof document === "undefined" && deferredData && dataKey && routeId ? null : ( /*#__PURE__*/React.createElement("script", _extends({}, scriptProps, {
-      async: true,
-      suppressHydrationWarning: true,
-      dangerouslySetInnerHTML: {
-        __html: " "
-      }
-    })))
-  }, typeof document === "undefined" && deferredData && dataKey && routeId ? ( /*#__PURE__*/React.createElement(Await, {
-    resolve: deferredData.data[dataKey],
-    errorElement: /*#__PURE__*/React.createElement(ErrorDeferredHydrationScript, {
-      dataKey: dataKey,
-      routeId: routeId,
-      scriptProps: scriptProps,
-      serializeError: serializeError
-    }),
-    children: data => {
-      return /*#__PURE__*/React.createElement("script", _extends({}, scriptProps, {
-        async: true,
-        suppressHydrationWarning: true,
-        dangerouslySetInnerHTML: {
-          __html: serializeData(routeId, dataKey, data)
-        }
-      }));
-    }
-  })) : ( /*#__PURE__*/React.createElement("script", _extends({}, scriptProps, {
-    async: true,
-    suppressHydrationWarning: true,
-    dangerouslySetInnerHTML: {
-      __html: " "
-    }
-  }))));
-}
-function ErrorDeferredHydrationScript(_ref7) {
-  let {
-    dataKey,
-    routeId,
-    scriptProps,
-    serializeError
-  } = _ref7;
-  let error = useAsyncError();
-  return /*#__PURE__*/React.createElement("script", _extends({}, scriptProps, {
-    suppressHydrationWarning: true,
-    dangerouslySetInnerHTML: {
-      __html: serializeError(routeId, dataKey, error)
-    }
-  }));
+  }))), initialScripts));
 }
 function dedupe(array) {
   return [...new Set(array)];
@@ -8641,7 +8154,7 @@ function useSubmit() {
     basename
   } = React.useContext(NavigationContext);
   let currentRouteId = useRouteId();
-  return React.useCallback(function (target, options) {
+  return React.useCallback(async function (target, options) {
     if (options === void 0) {
       options = {};
     }
@@ -8655,7 +8168,7 @@ function useSubmit() {
     } = getFormSubmissionInfo(target, basename);
     if (options.navigate === false) {
       let key = options.fetcherKey || getUniqueFetcherId();
-      router.fetch(key, currentRouteId, options.action || action, {
+      await router.fetch(key, currentRouteId, options.action || action, {
         preventScrollReset: options.preventScrollReset,
         formData,
         body,
@@ -8664,7 +8177,7 @@ function useSubmit() {
         unstable_flushSync: options.unstable_flushSync
       });
     } else {
-      router.navigate(options.action || action, {
+      await router.navigate(options.action || action, {
         preventScrollReset: options.preventScrollReset,
         formData,
         body,
@@ -8767,13 +8280,13 @@ function useFetcher(_temp3) {
     };
   }, [router, fetcherKey]);
   // Fetcher additions
-  let load = React.useCallback((href, opts) => {
+  let load = React.useCallback(async (href, opts) => {
     !routeId ? process.env.NODE_ENV !== "production" ? invariant$1(false, "No routeId available for fetcher.load()") : invariant$1(false) : void 0;
-    router.fetch(fetcherKey, routeId, href, opts);
+    await router.fetch(fetcherKey, routeId, href, opts);
   }, [fetcherKey, routeId, router]);
   let submitImpl = useSubmit();
-  let submit = React.useCallback((target, opts) => {
-    submitImpl(target, _extends({}, opts, {
+  let submit = React.useCallback(async (target, opts) => {
+    await submitImpl(target, _extends({}, opts, {
       navigate: false,
       fetcherKey
     }));
@@ -9610,26 +9123,19 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
   }
   return (routesByParentId[parentId] || []).map(route => {
     let routeModule = routeModulesCache[route.id];
-    // Fetch data from the server either via single fetch or the standard `?_data`
-    // request.  Unwrap it when called via `serverLoader`/`serverAction` in a
-    // client handler, otherwise return the raw response for the router to unwrap
-    async function fetchServerHandlerAndMaybeUnwrap(request, unwrap, singleFetch) {
-      if (typeof singleFetch === "function") {
-        let result = await singleFetch();
-        return result;
-      }
-      let result = await fetchServerHandler(request, route);
-      return unwrap ? unwrapServerResponse(result) : result;
+    function fetchServerHandler(singleFetch) {
+      !(typeof singleFetch === "function") ? process.env.NODE_ENV !== "production" ? invariant(false, "No single fetch function available for route handler") : invariant(false) : void 0;
+      return singleFetch();
     }
-    function fetchServerLoader(request, unwrap, singleFetch) {
+    function fetchServerLoader(singleFetch) {
       if (!route.hasLoader) return Promise.resolve(null);
-      return fetchServerHandlerAndMaybeUnwrap(request, unwrap, singleFetch);
+      return fetchServerHandler(singleFetch);
     }
-    function fetchServerAction(request, unwrap, singleFetch) {
+    function fetchServerAction(singleFetch) {
       if (!route.hasAction) {
         throw noActionDefinedError("action", route.id);
       }
-      return fetchServerHandlerAndMaybeUnwrap(request, unwrap, singleFetch);
+      return fetchServerHandler(singleFetch);
     }
     async function prefetchStylesAndCallHandler(handler) {
       // Only prefetch links if we exist in the routeModulesCache (critical modules
@@ -9670,7 +9176,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
             if (!routeModule.clientLoader) {
               if (isSpaMode) return null;
               // Call the server when no client loader exists
-              return fetchServerLoader(request, false, singleFetch);
+              return fetchServerLoader(singleFetch);
             }
             return routeModule.clientLoader({
               request,
@@ -9685,7 +9191,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
                   return initialData;
                 }
                 // Call the server loader for client-side navigations
-                return fetchServerLoader(request, true, singleFetch);
+                return fetchServerLoader(singleFetch);
               }
             });
           });
@@ -9709,14 +9215,14 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
             if (isSpaMode) {
               throw noActionDefinedError("clientAction", route.id);
             }
-            return fetchServerAction(request, false, singleFetch);
+            return fetchServerAction(singleFetch);
           }
           return routeModule.clientAction({
             request,
             params,
             async serverAction() {
               preventInvalidServerHandlerCall("action", route, isSpaMode);
-              return fetchServerAction(request, true, singleFetch);
+              return fetchServerAction(singleFetch);
             }
           });
         });
@@ -9727,25 +9233,19 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
       // loader/action as static props on the route
       if (!route.hasClientLoader) {
         dataRoute.loader = (_ref3, singleFetch) => {
-          let {
-            request
-          } = _ref3;
           return prefetchStylesAndCallHandler(() => {
             if (isSpaMode) return Promise.resolve(null);
-            return fetchServerLoader(request, false, singleFetch);
+            return fetchServerLoader(singleFetch);
           });
         };
       }
       if (!route.hasClientAction) {
         dataRoute.action = (_ref4, singleFetch) => {
-          let {
-            request
-          } = _ref4;
           return prefetchStylesAndCallHandler(() => {
             if (isSpaMode) {
               throw noActionDefinedError("clientAction", route.id);
             }
-            return fetchServerAction(request, false, singleFetch);
+            return fetchServerAction(singleFetch);
           });
         };
       }
@@ -9758,7 +9258,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
           lazyRoute.loader = (args, singleFetch) => clientLoader(_extends({}, args, {
             async serverLoader() {
               preventInvalidServerHandlerCall("loader", route, isSpaMode);
-              return fetchServerLoader(args.request, true, singleFetch);
+              return fetchServerLoader(singleFetch);
             }
           }));
         }
@@ -9767,7 +9267,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, future, i
           lazyRoute.action = (args, singleFetch) => clientAction(_extends({}, args, {
             async serverAction() {
               preventInvalidServerHandlerCall("action", route, isSpaMode);
-              return fetchServerAction(args.request, true, singleFetch);
+              return fetchServerAction(singleFetch);
             }
           }));
         }
@@ -9822,55 +9322,6 @@ async function loadRouteModuleWithBlockingLinks(route, routeModules) {
     shouldRevalidate: routeModule.shouldRevalidate
   };
 }
-async function fetchServerHandler(request, route) {
-  let result = await fetchData(request, route.id);
-  if (result instanceof Error) {
-    throw result;
-  }
-  if (isRedirectResponse(result)) {
-    throw getRedirect(result);
-  }
-  if (isCatchResponse(result)) {
-    throw result;
-  }
-  if (isDeferredResponse(result) && result.body) {
-    return await parseDeferredReadableStream(result.body);
-  }
-  return result;
-}
-function unwrapServerResponse(result) {
-  if (isDeferredData(result)) {
-    return result.data;
-  }
-  if (isResponse(result)) {
-    let contentType = result.headers.get("Content-Type");
-    // Check between word boundaries instead of startsWith() due to the last
-    // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
-    if (contentType && /\bapplication\/json\b/.test(contentType)) {
-      return result.json();
-    } else {
-      return result.text();
-    }
-  }
-  return result;
-}
-function getRedirect(response) {
-  let status = parseInt(response.headers.get("X-Remix-Status"), 10) || 302;
-  let url = response.headers.get("X-Remix-Redirect");
-  let headers = {};
-  let revalidate = response.headers.get("X-Remix-Revalidate");
-  if (revalidate) {
-    headers["X-Remix-Revalidate"] = revalidate;
-  }
-  let reloadDocument = response.headers.get("X-Remix-Reload-Document");
-  if (reloadDocument) {
-    headers["X-Remix-Reload-Document"] = reloadDocument;
-  }
-  return redirect(url, {
-    status,
-    headers
-  });
-}
 // Our compiler generates the default export as `{}` when no default is provided,
 // which can lead us to trying to use that as a Component in RR and calling
 // createElement on it.  Patching here as a quick fix and hoping it's no longer
@@ -9985,30 +9436,28 @@ function createHydratedRouter() {
   }
   // TODO: Do some testing to confirm it's OK to skip the hard reload check
   // now that all route.lazy stuff is wired up
-  // When single fetch is enabled, we need to suspend until the initial state
-  // snapshot is decoded into window.__remixContext.state
-  if (ssrInfo.context.future.unstable_singleFetch) {
-    let localSsrInfo = ssrInfo;
-    // Note: `stateDecodingPromise` is not coupled to `router` - we'll reach this
-    // code potentially many times waiting for our state to arrive, but we'll
-    // then only get past here and create the `router` one time
-    if (!ssrInfo.stateDecodingPromise) {
-      let stream = ssrInfo.context.stream;
-      !stream ? process.env.NODE_ENV !== "production" ? invariant(false, "No stream found for single fetch decoding") : invariant(false) : void 0;
-      ssrInfo.context.stream = undefined;
-      ssrInfo.stateDecodingPromise = decodeViaTurboStream(stream, window).then(value => {
-        ssrInfo.context.state = value.value;
-        localSsrInfo.stateDecodingPromise.value = true;
-      }).catch(e => {
-        localSsrInfo.stateDecodingPromise.error = e;
-      });
-    }
-    if (ssrInfo.stateDecodingPromise.error) {
-      throw ssrInfo.stateDecodingPromise.error;
-    }
-    if (!ssrInfo.stateDecodingPromise.value) {
-      throw ssrInfo.stateDecodingPromise;
-    }
+  // We need to suspend until the initial state snapshot is decoded into
+  // window.__remixContext.state
+  let localSsrInfo = ssrInfo;
+  // Note: `stateDecodingPromise` is not coupled to `router` - we'll reach this
+  // code potentially many times waiting for our state to arrive, but we'll
+  // then only get past here and create the `router` one time
+  if (!ssrInfo.stateDecodingPromise) {
+    let stream = ssrInfo.context.stream;
+    !stream ? process.env.NODE_ENV !== "production" ? invariant(false, "No stream found for single fetch decoding") : invariant(false) : void 0;
+    ssrInfo.context.stream = undefined;
+    ssrInfo.stateDecodingPromise = decodeViaTurboStream(stream, window).then(value => {
+      ssrInfo.context.state = value.value;
+      localSsrInfo.stateDecodingPromise.value = true;
+    }).catch(e => {
+      localSsrInfo.stateDecodingPromise.error = e;
+    });
+  }
+  if (ssrInfo.stateDecodingPromise.error) {
+    throw ssrInfo.stateDecodingPromise.error;
+  }
+  if (!ssrInfo.stateDecodingPromise.value) {
+    throw ssrInfo.stateDecodingPromise;
   }
   let routes = createClientRoutes(ssrInfo.manifest.routes, ssrInfo.routeModules, ssrInfo.context.state, ssrInfo.context.future, ssrInfo.context.isSpaMode);
   let hydrationData = undefined;
@@ -10063,11 +9512,11 @@ function createHydratedRouter() {
       v7_prependBasename: true,
       v7_relativeSplatPath: ssrInfo.context.future.v3_relativeSplatPath,
       // Single fetch enables this underlying behavior
-      unstable_skipActionErrorRevalidation: ssrInfo.context.future.unstable_singleFetch === true
+      unstable_skipActionErrorRevalidation: true
     },
     hydrationData,
     mapRouteProperties,
-    unstable_dataStrategy: ssrInfo.context.future.unstable_singleFetch ? getSingleFetchDataStrategy(ssrInfo.manifest, ssrInfo.routeModules) : undefined
+    unstable_dataStrategy: getSingleFetchDataStrategy(ssrInfo.manifest, ssrInfo.routeModules)
   });
   ssrInfo.router = router;
   // We can call initialize() immediately if the router doesn't have any
@@ -10140,7 +9589,7 @@ function HydratedRouter() {
       future: {
         v7_startTransition: true
       }
-    }))), ssrInfo.context.future.unstable_singleFetch ? /*#__PURE__*/React.createElement(React.Fragment, null) : null)
+    }))), /*#__PURE__*/React.createElement(React.Fragment, null))
   );
 }
 
@@ -10207,7 +9656,7 @@ function RemixServer(_ref) {
     router: router,
     context: context.staticHandlerContext,
     hydrate: false
-  }))), context.future.unstable_singleFetch && context.serverHandoffStream ? ( /*#__PURE__*/React.createElement(React.Suspense, null, /*#__PURE__*/React.createElement(StreamTransfer, {
+  }))), context.serverHandoffStream ? ( /*#__PURE__*/React.createElement(React.Suspense, null, /*#__PURE__*/React.createElement(StreamTransfer, {
     context: context,
     identifier: 0,
     reader: context.serverHandoffStream.getReader(),
@@ -10232,8 +9681,7 @@ function createRemixStub(routes, context) {
       remixContextRef.current = {
         future: {
           v3_fetcherPersist: (future == null ? void 0 : future.v3_fetcherPersist) === true,
-          v3_relativeSplatPath: (future == null ? void 0 : future.v3_relativeSplatPath) === true,
-          unstable_singleFetch: (future == null ? void 0 : future.unstable_singleFetch) === true
+          v3_relativeSplatPath: (future == null ? void 0 : future.v3_relativeSplatPath) === true
         },
         manifest: {
           routes: {},