react-router 0.0.0-experimental-c19b79d → 0.0.0-experimental-31a822c5f

package/dist/development/{chunk-AGOH44BE.mjs → chunk-FXUONXY4.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-c19b79d
+ * react-router v0.0.0-experimental-31a822c5f
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -22,13 +22,8 @@ import {
   SingleFetchRedirectSymbol,
   StaticRouterProvider,
   StreamTransfer,
-  UNSTABLE_TransitionEnabledRouterProvider,
   convertRoutesToDataRoutes,
-  createBrowserHistory,
-  createContext,
   createMemoryRouter,
-  createRequestInit,
-  createRouter,
   createServerRoutes,
   createStaticHandler,
   createStaticRouter,
@@ -36,31 +31,24 @@ import {
   encode,
   escapeHtml,
   getManifestPath,
-  getSingleFetchDataStrategyImpl,
   getStaticContextFromError,
-  invariant,
   isDataWithResponseInit,
-  isMutationMethod,
   isRedirectResponse,
   isRedirectStatusCode,
   isResponse,
   isRouteErrorResponse,
   matchRoutes,
-  noActionDefinedError,
   redirect,
   redirectDocument,
   replace,
-  setIsHydrated,
   shouldHydrateRouteLoader,
-  singleFetchUrl,
   stripBasename,
-  stripIndexParam,
   useRouteError,
   warnOnce,
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-IMKEG5CI.mjs";
+} from "./chunk-WTUOISGV.mjs";
 
 // lib/dom/ssr/server.tsx
 import * as React from "react";
@@ -515,7 +503,7 @@ function matchServerRoutes(routes, pathname, basename) {
 // lib/server-runtime/data.ts
 async function callRouteHandler(handler, args) {
   let result = await handler({
-    request: stripRoutesParam(stripIndexParam2(args.request)),
+    request: stripRoutesParam(stripIndexParam(args.request)),
     params: args.params,
     context: args.context
   });
@@ -524,7 +512,7 @@ async function callRouteHandler(handler, args) {
   }
   return result;
 }
-function stripIndexParam2(request) {
+function stripIndexParam(request) {
   let url = new URL(request.url);
   let indexValues = url.searchParams.getAll("index");
   url.searchParams.delete("index");
@@ -564,7 +552,7 @@ function stripRoutesParam(request) {
 }
 
 // lib/server-runtime/invariant.ts
-function invariant2(value, message) {
+function invariant(value, message) {
   if (value === false || value === null || typeof value === "undefined") {
     console.error(
       "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
@@ -630,7 +618,7 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
         );
         if (preRenderedData != null) {
           let encoded = preRenderedData ? decodeURI(preRenderedData) : preRenderedData;
-          invariant2(encoded, "Missing prerendered data for route");
+          invariant(encoded, "Missing prerendered data for route");
           let uint8array = new TextEncoder().encode(encoded);
           let stream = new ReadableStream({
             start(controller) {
@@ -651,12 +639,12 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
               throw redirect(result.redirect, init);
             }
           } else {
-            invariant2(
+            invariant(
               data2 && route.id in data2,
               "Unable to decode prerendered data"
             );
             let result = data2[route.id];
-            invariant2(
+            invariant(
               "data" in result,
               "Unable to process prerendered data"
             );
@@ -695,7 +683,7 @@ import { splitCookiesString } from "set-cookie-parser";
 function getDocumentHeaders(context, build) {
   return getDocumentHeadersImpl(context, (m) => {
     let route = build.routes[m.route.id];
-    invariant2(route, `Route with id "${m.route.id}" not found in build`);
+    invariant(route, `Route with id "${m.route.id}" not found in build`);
     return route.module.headers;
   });
 }
@@ -1674,41 +1662,95 @@ function href(path, ...args) {
   return result || "/";
 }
 
-// lib/rsc/browser.tsx
+// lib/rsc/server.ssr.tsx
 import * as React4 from "react";
-import * as ReactDOM from "react-dom";
 
-// lib/dom/ssr/hydration.tsx
-function getHydrationData({
-  state,
-  routes,
-  getRouteInfo,
-  location: location2,
-  basename,
-  isSpaMode
-}) {
-  let hydrationData = {
-    ...state,
-    loaderData: { ...state.loaderData }
-  };
-  let initialMatches = matchRoutes(routes, location2, basename);
-  if (initialMatches) {
-    for (let match of initialMatches) {
-      let routeId = match.route.id;
-      let routeInfo = getRouteInfo(routeId);
-      if (shouldHydrateRouteLoader(
-        routeId,
-        routeInfo.clientLoader,
-        routeInfo.hasLoader,
-        isSpaMode
-      ) && (routeInfo.hasHydrateFallback || !routeInfo.hasLoader)) {
-        delete hydrationData.loaderData[routeId];
-      } else if (!routeInfo.hasLoader) {
-        hydrationData.loaderData[routeId] = null;
+// lib/rsc/html-stream/server.ts
+var encoder2 = new TextEncoder();
+var trailer = "</body></html>";
+function injectRSCPayload(rscStream) {
+  let decoder = new TextDecoder();
+  let resolveFlightDataPromise;
+  let flightDataPromise = new Promise(
+    (resolve) => resolveFlightDataPromise = resolve
+  );
+  let startedRSC = false;
+  let buffered = [];
+  let timeout = null;
+  function flushBufferedChunks(controller) {
+    for (let chunk of buffered) {
+      let buf = decoder.decode(chunk, { stream: true });
+      if (buf.endsWith(trailer)) {
+        buf = buf.slice(0, -trailer.length);
       }
+      controller.enqueue(encoder2.encode(buf));
     }
+    buffered.length = 0;
+    timeout = null;
   }
-  return hydrationData;
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffered.push(chunk);
+      if (timeout) {
+        return;
+      }
+      timeout = setTimeout(async () => {
+        flushBufferedChunks(controller);
+        if (!startedRSC) {
+          startedRSC = true;
+          writeRSCStream(rscStream, controller).catch((err) => controller.error(err)).then(resolveFlightDataPromise);
+        }
+      }, 0);
+    },
+    async flush(controller) {
+      await flightDataPromise;
+      if (timeout) {
+        clearTimeout(timeout);
+        flushBufferedChunks(controller);
+      }
+      controller.enqueue(encoder2.encode("</body></html>"));
+    }
+  });
+}
+async function writeRSCStream(rscStream, controller) {
+  let decoder = new TextDecoder("utf-8", { fatal: true });
+  const reader = rscStream.getReader();
+  try {
+    let read;
+    while ((read = await reader.read()) && !read.done) {
+      const chunk = read.value;
+      try {
+        writeChunk(
+          JSON.stringify(decoder.decode(chunk, { stream: true })),
+          controller
+        );
+      } catch (err) {
+        let base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+        writeChunk(
+          `Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`,
+          controller
+        );
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  let remaining = decoder.decode();
+  if (remaining.length) {
+    writeChunk(JSON.stringify(remaining), controller);
+  }
+}
+function writeChunk(chunk, controller) {
+  controller.enqueue(
+    encoder2.encode(
+      `<script>${escapeScript(
+        `(self.__FLIGHT_DATA||=[]).push(${chunk})`
+      )}</script>`
+    )
+  );
+}
+function escapeScript(script) {
+  return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
 }
 
 // lib/rsc/errorBoundaries.tsx
@@ -1841,724 +1883,9 @@ function populateRSCRouteModules(routeModules, matches) {
 }
 var noopComponent = () => null;
 
-// lib/rsc/browser.tsx
-function createCallServer({
-  createFromReadableStream,
-  createTemporaryReferenceSet,
-  encodeReply,
-  fetch: fetchImplementation = fetch
-}) {
-  const globalVar = window;
-  let landedActionId = 0;
-  return async (id, args) => {
-    let actionId = globalVar.__routerActionID = (globalVar.__routerActionID ?? (globalVar.__routerActionID = 0)) + 1;
-    const temporaryReferences = createTemporaryReferenceSet();
-    const payloadPromise = fetchImplementation(
-      new Request(location.href, {
-        body: await encodeReply(args, { temporaryReferences }),
-        method: "POST",
-        headers: {
-          Accept: "text/x-component",
-          "rsc-action-id": id
-        }
-      })
-    ).then((response) => {
-      if (!response.body) {
-        throw new Error("No response body");
-      }
-      return createFromReadableStream(response.body, {
-        temporaryReferences
-      });
-    });
-    globalVar.__reactRouterDataRouter.__setPendingRerender(
-      Promise.resolve(payloadPromise).then(async (payload) => {
-        if (payload.type === "redirect") {
-          if (payload.reload || isExternalLocation(payload.location)) {
-            window.location.href = payload.location;
-            return () => {
-            };
-          }
-          return () => {
-            globalVar.__reactRouterDataRouter.navigate(payload.location, {
-              replace: payload.replace
-            });
-          };
-        }
-        if (payload.type !== "action") {
-          throw new Error("Unexpected payload type");
-        }
-        const rerender = await payload.rerender;
-        if (rerender && landedActionId < actionId && globalVar.__routerActionID <= actionId) {
-          if (rerender.type === "redirect") {
-            if (rerender.reload || isExternalLocation(rerender.location)) {
-              window.location.href = rerender.location;
-              return;
-            }
-            return () => {
-              globalVar.__reactRouterDataRouter.navigate(rerender.location, {
-                replace: rerender.replace
-              });
-            };
-          }
-          return () => {
-            let lastMatch;
-            for (const match of rerender.matches) {
-              globalVar.__reactRouterDataRouter.patchRoutes(
-                lastMatch?.id ?? null,
-                [createRouteFromServerManifest(match)],
-                true
-              );
-              lastMatch = match;
-            }
-            window.__reactRouterDataRouter._internalSetStateDoNotUseOrYouWillBreakYourApp(
-              {
-                loaderData: Object.assign(
-                  {},
-                  globalVar.__reactRouterDataRouter.state.loaderData,
-                  rerender.loaderData
-                ),
-                errors: rerender.errors ? Object.assign(
-                  {},
-                  globalVar.__reactRouterDataRouter.state.errors,
-                  rerender.errors
-                ) : null
-              }
-            );
-          };
-        }
-        return () => {
-        };
-      }).catch(() => {
-      })
-    );
-    return payloadPromise.then((payload) => {
-      if (payload.type !== "action" && payload.type !== "redirect") {
-        throw new Error("Unexpected payload type");
-      }
-      return payload.actionResult;
-    });
-  };
-}
-function createRouterFromPayload({
-  fetchImplementation,
-  createFromReadableStream,
-  getContext,
-  payload
-}) {
-  const globalVar = window;
-  if (globalVar.__reactRouterDataRouter && globalVar.__reactRouterRouteModules)
-    return {
-      router: globalVar.__reactRouterDataRouter,
-      routeModules: globalVar.__reactRouterRouteModules
-    };
-  if (payload.type !== "render") throw new Error("Invalid payload type");
-  globalVar.__reactRouterRouteModules = globalVar.__reactRouterRouteModules ?? {};
-  populateRSCRouteModules(globalVar.__reactRouterRouteModules, payload.matches);
-  let patches = /* @__PURE__ */ new Map();
-  payload.patches?.forEach((patch) => {
-    invariant(patch.parentId, "Invalid patch parentId");
-    if (!patches.has(patch.parentId)) {
-      patches.set(patch.parentId, []);
-    }
-    patches.get(patch.parentId)?.push(patch);
-  });
-  let routes = payload.matches.reduceRight((previous, match) => {
-    const route = createRouteFromServerManifest(
-      match,
-      payload
-    );
-    if (previous.length > 0) {
-      route.children = previous;
-      let childrenToPatch = patches.get(match.id);
-      if (childrenToPatch) {
-        route.children.push(
-          ...childrenToPatch.map((r) => createRouteFromServerManifest(r))
-        );
-      }
-    }
-    return [route];
-  }, []);
-  globalVar.__reactRouterDataRouter = createRouter({
-    routes,
-    getContext,
-    basename: payload.basename,
-    history: createBrowserHistory(),
-    hydrationData: getHydrationData({
-      state: {
-        loaderData: payload.loaderData,
-        actionData: payload.actionData,
-        errors: payload.errors
-      },
-      routes,
-      getRouteInfo: (routeId) => {
-        let match = payload.matches.find((m) => m.id === routeId);
-        invariant(match, "Route not found in payload");
-        return {
-          clientLoader: match.clientLoader,
-          hasLoader: match.hasLoader,
-          hasHydrateFallback: match.hydrateFallbackElement != null
-        };
-      },
-      location: payload.location,
-      basename: payload.basename,
-      isSpaMode: false
-    }),
-    async patchRoutesOnNavigation({ path, signal }) {
-      if (discoveredPaths.has(path)) {
-        return;
-      }
-      await fetchAndApplyManifestPatches(
-        [path],
-        createFromReadableStream,
-        fetchImplementation,
-        signal
-      );
-    },
-    // FIXME: Pass `build.ssr` into this function
-    dataStrategy: getRSCSingleFetchDataStrategy(
-      () => globalVar.__reactRouterDataRouter,
-      true,
-      payload.basename,
-      createFromReadableStream,
-      fetchImplementation
-    )
-  });
-  if (globalVar.__reactRouterDataRouter.state.initialized) {
-    globalVar.__routerInitialized = true;
-    globalVar.__reactRouterDataRouter.initialize();
-  } else {
-    globalVar.__routerInitialized = false;
-  }
-  let lastLoaderData = void 0;
-  globalVar.__reactRouterDataRouter.subscribe(({ loaderData, actionData }) => {
-    if (lastLoaderData !== loaderData) {
-      globalVar.__routerActionID = (globalVar.__routerActionID ?? (globalVar.__routerActionID = 0)) + 1;
-    }
-  });
-  globalVar.__reactRouterDataRouter._updateRoutesForHMR = (routeUpdateByRouteId) => {
-    const oldRoutes = window.__reactRouterDataRouter.routes;
-    const newRoutes = [];
-    function walkRoutes(routes2, parentId) {
-      return routes2.map((route) => {
-        const routeUpdate = routeUpdateByRouteId.get(route.id);
-        if (routeUpdate) {
-          const {
-            routeModule,
-            hasAction,
-            hasComponent,
-            hasErrorBoundary,
-            hasLoader
-          } = routeUpdate;
-          const newRoute = createRouteFromServerManifest({
-            clientAction: routeModule.clientAction,
-            clientLoader: routeModule.clientLoader,
-            element: route.element,
-            errorElement: route.errorElement,
-            handle: route.handle,
-            hasAction,
-            hasComponent,
-            hasErrorBoundary,
-            hasLoader,
-            hydrateFallbackElement: route.hydrateFallbackElement,
-            id: route.id,
-            index: route.index,
-            links: routeModule.links,
-            meta: routeModule.meta,
-            parentId,
-            path: route.path,
-            shouldRevalidate: routeModule.shouldRevalidate
-          });
-          if (route.children) {
-            newRoute.children = walkRoutes(route.children, route.id);
-          }
-          return newRoute;
-        }
-        const updatedRoute = { ...route };
-        if (route.children) {
-          updatedRoute.children = walkRoutes(route.children, route.id);
-        }
-        return updatedRoute;
-      });
-    }
-    newRoutes.push(
-      ...walkRoutes(oldRoutes, void 0)
-    );
-    window.__reactRouterDataRouter._internalSetRoutes(newRoutes);
-  };
-  return {
-    router: globalVar.__reactRouterDataRouter,
-    routeModules: globalVar.__reactRouterRouteModules
-  };
-}
-var renderedRoutesContext = createContext();
-function getRSCSingleFetchDataStrategy(getRouter, ssr, basename, createFromReadableStream, fetchImplementation) {
-  let dataStrategy = getSingleFetchDataStrategyImpl(
-    getRouter,
-    (match) => {
-      let M = match;
-      return {
-        hasLoader: M.route.hasLoader,
-        hasClientLoader: M.route.hasClientLoader,
-        hasComponent: M.route.hasComponent,
-        hasAction: M.route.hasAction,
-        hasClientAction: M.route.hasClientAction,
-        hasShouldRevalidate: M.route.hasShouldRevalidate
-      };
-    },
-    // pass map into fetchAndDecode so it can add payloads
-    getFetchAndDecodeViaRSC(createFromReadableStream, fetchImplementation),
-    ssr,
-    basename,
-    // If the route has a component but we don't have an element, we need to hit
-    // the server loader flow regardless of whether the client loader calls
-    // `serverLoader` or not, otherwise we'll have nothing to render.
-    (match) => {
-      let M = match;
-      return M.route.hasComponent && !M.route.element;
-    }
-  );
-  return async (args) => args.runClientMiddleware(async () => {
-    let context = args.context;
-    context.set(renderedRoutesContext, []);
-    let results = await dataStrategy(args);
-    const renderedRoutesById = /* @__PURE__ */ new Map();
-    for (const route of context.get(renderedRoutesContext)) {
-      if (!renderedRoutesById.has(route.id)) {
-        renderedRoutesById.set(route.id, []);
-      }
-      renderedRoutesById.get(route.id).push(route);
-    }
-    for (const match of args.matches) {
-      const renderedRoutes = renderedRoutesById.get(match.route.id);
-      if (renderedRoutes) {
-        for (const rendered of renderedRoutes) {
-          window.__reactRouterDataRouter.patchRoutes(
-            rendered.parentId ?? null,
-            [createRouteFromServerManifest(rendered)],
-            true
-          );
-        }
-      }
-    }
-    return results;
-  });
-}
-function getFetchAndDecodeViaRSC(createFromReadableStream, fetchImplementation) {
-  return async (args, basename, targetRoutes) => {
-    let { request, context } = args;
-    let url = singleFetchUrl(request.url, basename, "rsc");
-    if (request.method === "GET") {
-      url = stripIndexParam(url);
-      if (targetRoutes) {
-        url.searchParams.set("_routes", targetRoutes.join(","));
-      }
-    }
-    let res = await fetchImplementation(
-      new Request(url, await createRequestInit(request))
-    );
-    if (res.status >= 400 && !res.headers.has("X-Remix-Response")) {
-      throw new ErrorResponseImpl(res.status, res.statusText, await res.text());
-    }
-    invariant(res.body, "No response body to decode");
-    try {
-      const payload = await createFromReadableStream(res.body, {
-        temporaryReferences: void 0
-      });
-      if (payload.type === "redirect") {
-        return {
-          status: res.status,
-          data: {
-            redirect: {
-              redirect: payload.location,
-              reload: payload.reload,
-              replace: payload.replace,
-              revalidate: false,
-              status: payload.status
-            }
-          }
-        };
-      }
-      if (payload.type !== "render") {
-        throw new Error("Unexpected payload type");
-      }
-      context.get(renderedRoutesContext).push(...payload.matches);
-      let results = { routes: {} };
-      const dataKey = isMutationMethod(request.method) ? "actionData" : "loaderData";
-      for (let [routeId, data2] of Object.entries(payload[dataKey] || {})) {
-        results.routes[routeId] = { data: data2 };
-      }
-      if (payload.errors) {
-        for (let [routeId, error] of Object.entries(payload.errors)) {
-          results.routes[routeId] = { error };
-        }
-      }
-      return { status: res.status, data: results };
-    } catch (e) {
-      throw new Error("Unable to decode RSC response");
-    }
-  };
-}
-function RSCHydratedRouter({
-  createFromReadableStream,
-  fetch: fetchImplementation = fetch,
-  payload,
-  routeDiscovery = "eager",
-  getContext
-}) {
-  if (payload.type !== "render") throw new Error("Invalid payload type");
-  let { router, routeModules } = React4.useMemo(
-    () => createRouterFromPayload({
-      payload,
-      fetchImplementation,
-      getContext,
-      createFromReadableStream
-    }),
-    [createFromReadableStream, payload, fetchImplementation, getContext]
-  );
-  React4.useEffect(() => {
-    setIsHydrated();
-  }, []);
-  React4.useLayoutEffect(() => {
-    const globalVar = window;
-    if (!globalVar.__routerInitialized) {
-      globalVar.__routerInitialized = true;
-      globalVar.__reactRouterDataRouter.initialize();
-    }
-  }, []);
-  let [location2, setLocation] = React4.useState(router.state.location);
-  React4.useLayoutEffect(
-    () => router.subscribe((newState) => {
-      if (newState.location !== location2) {
-        setLocation(newState.location);
-      }
-    }),
-    [router, location2]
-  );
-  React4.useEffect(() => {
-    if (routeDiscovery === "lazy" || // @ts-expect-error - TS doesn't know about this yet
-    window.navigator?.connection?.saveData === true) {
-      return;
-    }
-    function registerElement(el) {
-      let path = el.tagName === "FORM" ? el.getAttribute("action") : el.getAttribute("href");
-      if (!path) {
-        return;
-      }
-      let pathname = el.tagName === "A" ? el.pathname : new URL(path, window.location.origin).pathname;
-      if (!discoveredPaths.has(pathname)) {
-        nextPaths.add(pathname);
-      }
-    }
-    async function fetchPatches() {
-      document.querySelectorAll("a[data-discover], form[data-discover]").forEach(registerElement);
-      let paths = Array.from(nextPaths.keys()).filter((path) => {
-        if (discoveredPaths.has(path)) {
-          nextPaths.delete(path);
-          return false;
-        }
-        return true;
-      });
-      if (paths.length === 0) {
-        return;
-      }
-      try {
-        await fetchAndApplyManifestPatches(
-          paths,
-          createFromReadableStream,
-          fetchImplementation
-        );
-      } catch (e) {
-        console.error("Failed to fetch manifest patches", e);
-      }
-    }
-    let debouncedFetchPatches = debounce(fetchPatches, 100);
-    fetchPatches();
-    let observer = new MutationObserver(() => debouncedFetchPatches());
-    observer.observe(document.documentElement, {
-      subtree: true,
-      childList: true,
-      attributes: true,
-      attributeFilter: ["data-discover", "href", "action"]
-    });
-  }, [routeDiscovery, createFromReadableStream, fetchImplementation]);
-  const frameworkContext = {
-    future: {
-      // These flags have no runtime impact so can always be false.  If we add
-      // flags that drive runtime behavior they'll need to be proxied through.
-      v8_middleware: false,
-      unstable_subResourceIntegrity: false
-    },
-    isSpaMode: false,
-    ssr: true,
-    criticalCss: "",
-    manifest: {
-      routes: {},
-      version: "1",
-      url: "",
-      entry: {
-        module: "",
-        imports: []
-      }
-    },
-    routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
-    routeModules
-  };
-  return /* @__PURE__ */ React4.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React4.createElement(RSCRouterGlobalErrorBoundary, { location: location2 }, /* @__PURE__ */ React4.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React4.createElement(UNSTABLE_TransitionEnabledRouterProvider, { router, flushSync: ReactDOM.flushSync }))));
-}
-function createRouteFromServerManifest(match, payload) {
-  let hasInitialData = payload && match.id in payload.loaderData;
-  let initialData = payload?.loaderData[match.id];
-  let hasInitialError = payload?.errors && match.id in payload.errors;
-  let initialError = payload?.errors?.[match.id];
-  let isHydrationRequest = match.clientLoader?.hydrate === true || !match.hasLoader || // If the route has a component but we don't have an element, we need to hit
-  // the server loader flow regardless of whether the client loader calls
-  // `serverLoader` or not, otherwise we'll have nothing to render.
-  match.hasComponent && !match.element;
-  invariant(window.__reactRouterRouteModules);
-  populateRSCRouteModules(window.__reactRouterRouteModules, match);
-  let dataRoute = {
-    id: match.id,
-    element: match.element,
-    errorElement: match.errorElement,
-    handle: match.handle,
-    hasErrorBoundary: match.hasErrorBoundary,
-    hydrateFallbackElement: match.hydrateFallbackElement,
-    index: match.index,
-    loader: match.clientLoader ? async (args, singleFetch) => {
-      try {
-        let result = await match.clientLoader({
-          ...args,
-          serverLoader: () => {
-            preventInvalidServerHandlerCall(
-              "loader",
-              match.id,
-              match.hasLoader
-            );
-            if (isHydrationRequest) {
-              if (hasInitialData) {
-                return initialData;
-              }
-              if (hasInitialError) {
-                throw initialError;
-              }
-            }
-            return callSingleFetch(singleFetch);
-          }
-        });
-        return result;
-      } finally {
-        isHydrationRequest = false;
-      }
-    } : (
-      // We always make the call in this RSC world since even if we don't
-      // have a `loader` we may need to get the `element` implementation
-      (_, singleFetch) => callSingleFetch(singleFetch)
-    ),
-    action: match.clientAction ? (args, singleFetch) => match.clientAction({
-      ...args,
-      serverAction: async () => {
-        preventInvalidServerHandlerCall(
-          "action",
-          match.id,
-          match.hasLoader
-        );
-        return await callSingleFetch(singleFetch);
-      }
-    }) : match.hasAction ? (_, singleFetch) => callSingleFetch(singleFetch) : () => {
-      throw noActionDefinedError("action", match.id);
-    },
-    path: match.path,
-    shouldRevalidate: match.shouldRevalidate,
-    // We always have a "loader" in this RSC world since even if we don't
-    // have a `loader` we may need to get the `element` implementation
-    hasLoader: true,
-    hasClientLoader: match.clientLoader != null,
-    hasAction: match.hasAction,
-    hasClientAction: match.clientAction != null,
-    hasShouldRevalidate: match.shouldRevalidate != null
-  };
-  if (typeof dataRoute.loader === "function") {
-    dataRoute.loader.hydrate = shouldHydrateRouteLoader(
-      match.id,
-      match.clientLoader,
-      match.hasLoader,
-      false
-    );
-  }
-  return dataRoute;
-}
-function callSingleFetch(singleFetch) {
-  invariant(typeof singleFetch === "function", "Invalid singleFetch parameter");
-  return singleFetch();
-}
-function preventInvalidServerHandlerCall(type, routeId, hasHandler) {
-  if (!hasHandler) {
-    let fn = type === "action" ? "serverAction()" : "serverLoader()";
-    let msg = `You are trying to call ${fn} on a route that does not have a server ${type} (routeId: "${routeId}")`;
-    console.error(msg);
-    throw new ErrorResponseImpl(400, "Bad Request", new Error(msg), true);
-  }
-}
-var nextPaths = /* @__PURE__ */ new Set();
-var discoveredPathsMaxSize = 1e3;
-var discoveredPaths = /* @__PURE__ */ new Set();
-var URL_LIMIT = 7680;
-function getManifestUrl(paths) {
-  if (paths.length === 0) {
-    return null;
-  }
-  if (paths.length === 1) {
-    return new URL(`${paths[0]}.manifest`, window.location.origin);
-  }
-  const globalVar = window;
-  let basename = (globalVar.__reactRouterDataRouter.basename ?? "").replace(
-    /^\/|\/$/g,
-    ""
-  );
-  let url = new URL(`${basename}/.manifest`, window.location.origin);
-  url.searchParams.set("paths", paths.sort().join(","));
-  return url;
-}
-async function fetchAndApplyManifestPatches(paths, createFromReadableStream, fetchImplementation, signal) {
-  let url = getManifestUrl(paths);
-  if (url == null) {
-    return;
-  }
-  if (url.toString().length > URL_LIMIT) {
-    nextPaths.clear();
-    return;
-  }
-  let response = await fetchImplementation(new Request(url, { signal }));
-  if (!response.body || response.status < 200 || response.status >= 300) {
-    throw new Error("Unable to fetch new route matches from the server");
-  }
-  let payload = await createFromReadableStream(response.body, {
-    temporaryReferences: void 0
-  });
-  if (payload.type !== "manifest") {
-    throw new Error("Failed to patch routes");
-  }
-  paths.forEach((p) => addToFifoQueue(p, discoveredPaths));
-  payload.patches.forEach((p) => {
-    window.__reactRouterDataRouter.patchRoutes(
-      p.parentId ?? null,
-      [createRouteFromServerManifest(p)]
-    );
-  });
-}
-function addToFifoQueue(path, queue) {
-  if (queue.size >= discoveredPathsMaxSize) {
-    let first = queue.values().next().value;
-    queue.delete(first);
-  }
-  queue.add(path);
-}
-function debounce(callback, wait) {
-  let timeoutId;
-  return (...args) => {
-    window.clearTimeout(timeoutId);
-    timeoutId = window.setTimeout(() => callback(...args), wait);
-  };
-}
-function isExternalLocation(location2) {
-  const newLocation = new URL(location2, window.location.href);
-  return newLocation.origin !== window.location.origin;
-}
-
-// lib/rsc/server.ssr.tsx
-import * as React5 from "react";
-
-// lib/rsc/html-stream/server.ts
-var encoder2 = new TextEncoder();
-var trailer = "</body></html>";
-function injectRSCPayload(rscStream) {
-  let decoder = new TextDecoder();
-  let resolveFlightDataPromise;
-  let flightDataPromise = new Promise(
-    (resolve) => resolveFlightDataPromise = resolve
-  );
-  let startedRSC = false;
-  let buffered = [];
-  let timeout = null;
-  function flushBufferedChunks(controller) {
-    for (let chunk of buffered) {
-      let buf = decoder.decode(chunk, { stream: true });
-      if (buf.endsWith(trailer)) {
-        buf = buf.slice(0, -trailer.length);
-      }
-      controller.enqueue(encoder2.encode(buf));
-    }
-    buffered.length = 0;
-    timeout = null;
-  }
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffered.push(chunk);
-      if (timeout) {
-        return;
-      }
-      timeout = setTimeout(async () => {
-        flushBufferedChunks(controller);
-        if (!startedRSC) {
-          startedRSC = true;
-          writeRSCStream(rscStream, controller).catch((err) => controller.error(err)).then(resolveFlightDataPromise);
-        }
-      }, 0);
-    },
-    async flush(controller) {
-      await flightDataPromise;
-      if (timeout) {
-        clearTimeout(timeout);
-        flushBufferedChunks(controller);
-      }
-      controller.enqueue(encoder2.encode("</body></html>"));
-    }
-  });
-}
-async function writeRSCStream(rscStream, controller) {
-  let decoder = new TextDecoder("utf-8", { fatal: true });
-  const reader = rscStream.getReader();
-  try {
-    let read;
-    while ((read = await reader.read()) && !read.done) {
-      const chunk = read.value;
-      try {
-        writeChunk(
-          JSON.stringify(decoder.decode(chunk, { stream: true })),
-          controller
-        );
-      } catch (err) {
-        let base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(
-          `Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`,
-          controller
-        );
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  let remaining = decoder.decode();
-  if (remaining.length) {
-    writeChunk(JSON.stringify(remaining), controller);
-  }
-}
-function writeChunk(chunk, controller) {
-  controller.enqueue(
-    encoder2.encode(
-      `<script>${escapeScript(
-        `(self.__FLIGHT_DATA||=[]).push(${chunk})`
-      )}</script>`
-    )
-  );
-}
-function escapeScript(script) {
-  return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
-}
-
 // lib/rsc/server.ssr.tsx
 var REACT_USE = "use";
-var useImpl = React5[REACT_USE];
+var useImpl = React4[REACT_USE];
 function useSafe(promise) {
   if (useImpl) {
     return useImpl(promise);
@@ -2829,7 +2156,7 @@ function RSCStaticRouter({ getPayload }) {
     routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
     routeModules: createRSCRouteModules(payload)
   };
-  return /* @__PURE__ */ React5.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React5.createElement(RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React5.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React5.createElement(
+  return /* @__PURE__ */ React4.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React4.createElement(RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React4.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React4.createElement(
     StaticRouterProvider,
     {
       context,
@@ -2846,41 +2173,6 @@ function isManifestRequest(url) {
   return url.pathname.endsWith(".manifest");
 }
 
-// lib/rsc/html-stream/browser.ts
-function getRSCStream() {
-  let encoder3 = new TextEncoder();
-  let streamController = null;
-  let rscStream = new ReadableStream({
-    start(controller) {
-      if (typeof window === "undefined") {
-        return;
-      }
-      let handleChunk = (chunk) => {
-        if (typeof chunk === "string") {
-          controller.enqueue(encoder3.encode(chunk));
-        } else {
-          controller.enqueue(chunk);
-        }
-      };
-      window.__FLIGHT_DATA || (window.__FLIGHT_DATA = []);
-      window.__FLIGHT_DATA.forEach(handleChunk);
-      window.__FLIGHT_DATA.push = (chunk) => {
-        handleChunk(chunk);
-        return 0;
-      };
-      streamController = controller;
-    }
-  });
-  if (typeof document !== "undefined" && document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", () => {
-      streamController?.close();
-    });
-  } else {
-    streamController?.close();
-  }
-  return rscStream;
-}
-
 // lib/dom/ssr/errors.ts
 function deserializeErrors(errors) {
   if (!errors) return null;
@@ -2918,6 +2210,39 @@ function deserializeErrors(errors) {
   return serialized;
 }
 
+// lib/dom/ssr/hydration.tsx
+function getHydrationData({
+  state,
+  routes,
+  getRouteInfo,
+  location,
+  basename,
+  isSpaMode
+}) {
+  let hydrationData = {
+    ...state,
+    loaderData: { ...state.loaderData }
+  };
+  let initialMatches = matchRoutes(routes, location, basename);
+  if (initialMatches) {
+    for (let match of initialMatches) {
+      let routeId = match.route.id;
+      let routeInfo = getRouteInfo(routeId);
+      if (shouldHydrateRouteLoader(
+        routeId,
+        routeInfo.clientLoader,
+        routeInfo.hasLoader,
+        isSpaMode
+      ) && (routeInfo.hasHydrateFallback || !routeInfo.hasLoader)) {
+        delete hydrationData.loaderData[routeId];
+      } else if (!routeInfo.hasLoader) {
+        hydrationData.loaderData[routeId] = null;
+      }
+    }
+  }
+  return hydrationData;
+}
+
 export {
   ServerRouter,
   createRoutesStub,
@@ -2932,12 +2257,11 @@ export {
   createCookieSessionStorage,
   createMemorySessionStorage,
   href,
-  getHydrationData,
+  RSCRouterGlobalErrorBoundary,
   RSCDefaultRootErrorBoundary,
-  createCallServer,
-  RSCHydratedRouter,
+  populateRSCRouteModules,
   routeRSCServerRequest,
   RSCStaticRouter,
-  getRSCStream,
-  deserializeErrors
+  deserializeErrors,
+  getHydrationData
 };