react-router 0.0.0-experimental-3d7dcee → 0.0.0-experimental-426e5caec

package/dist/development/{chunk-WJ2QP6HN.mjs → chunk-5HELVQDL.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-3d7dcee
+ * react-router v0.0.0-experimental-426e5caec
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -362,13 +362,13 @@ function createBrowserURLImpl(to, isAbsolute = false) {
 }
 
 // lib/router/utils.ts
-function unstable_createContext(defaultValue) {
+function createContext(defaultValue) {
   return { defaultValue };
 }
 var _map;
-var unstable_RouterContextProvider = class {
+var RouterContextProvider = class {
   /**
-   * Create a new `unstable_RouterContextProvider` instance
+   * Create a new `RouterContextProvider` instance
    * @param init An optional initial context map to populate the provider with
    */
   constructor(init) {
@@ -428,7 +428,7 @@ var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "path",
   "id",
   "index",
-  "unstable_middleware",
+  "middleware",
   "children"
 ]);
 function isUnsupportedLazyRouteFunctionKey(key) {
@@ -699,7 +699,7 @@ function generatePath(originalPath, params = {}) {
       const [, key, optional] = keyMatch;
       let param = params[key];
       invariant(optional === "?" || param != null, `Missing ":${key}" param`);
-      return stringify2(param);
+      return encodeURIComponent(stringify2(param));
     }
     return segment.replace(/\?$/g, "");
   }).filter((segment) => !!segment);
@@ -1004,9 +1004,11 @@ function createRouter(init) {
   );
   let inFlightDataRoutes;
   let basename = init.basename || "/";
+  if (!basename.startsWith("/")) {
+    basename = `/${basename}`;
+  }
   let dataStrategyImpl = init.dataStrategy || defaultDataStrategyWithMiddleware;
   let future = {
-    unstable_middleware: false,
     ...init.future
   };
   let unlistenHistory = null;
@@ -1464,7 +1466,7 @@ function createRouter(init) {
       pendingNavigationController.signal,
       opts && opts.submission
     );
-    let scopedContext = init.unstable_getContext ? await init.unstable_getContext() : new unstable_RouterContextProvider();
+    let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
     let pendingActionResult;
     if (opts && opts.pendingError) {
       pendingActionResult = [
@@ -1553,6 +1555,19 @@ function createRouter(init) {
       if (discoverResult.type === "aborted") {
         return { shortCircuited: true };
       } else if (discoverResult.type === "error") {
+        if (discoverResult.partialMatches.length === 0) {
+          let { matches: matches2, route } = getShortCircuitMatches(dataRoutes);
+          return {
+            matches: matches2,
+            pendingActionResult: [
+              route.id,
+              {
+                type: "error" /* error */,
+                error: discoverResult.error
+              }
+            ]
+          };
+        }
         let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
         return {
           matches: discoverResult.partialMatches,
@@ -1684,6 +1699,16 @@ function createRouter(init) {
       if (discoverResult.type === "aborted") {
         return { shortCircuited: true };
       } else if (discoverResult.type === "error") {
+        if (discoverResult.partialMatches.length === 0) {
+          let { matches: matches2, route } = getShortCircuitMatches(dataRoutes);
+          return {
+            matches: matches2,
+            loaderData: {},
+            errors: {
+              [route.id]: discoverResult.error
+            }
+          };
+        }
         let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
         return {
           matches: discoverResult.partialMatches,
@@ -1731,7 +1756,7 @@ function createRouter(init) {
       pendingActionResult
     );
     pendingNavigationLoadId = ++incrementingLoadId;
-    if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some((m) => m.route.unstable_middleware) && revalidatingFetchers.length === 0) {
+    if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some((m) => m.route.middleware) && revalidatingFetchers.length === 0) {
       let updatedFetchers2 = markFetchRedirectsDone();
       completeNavigation(
         location,
@@ -1885,7 +1910,7 @@ function createRouter(init) {
       setFetcherError(key, routeId, error, { flushSync });
       return;
     }
-    let scopedContext = init.unstable_getContext ? await init.unstable_getContext() : new unstable_RouterContextProvider();
+    let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
     let preventScrollReset = (opts && opts.preventScrollReset) === true;
     if (submission && isMutationMethod(submission.formMethod)) {
       await handleFetcherAction(
@@ -2736,13 +2761,13 @@ function createStaticHandler(routes, opts) {
     skipLoaderErrorBubbling,
     skipRevalidation,
     dataStrategy,
-    unstable_generateMiddlewareResponse: generateMiddlewareResponse
+    generateMiddlewareResponse
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
-    requestContext = requestContext != null ? requestContext : new unstable_RouterContextProvider();
+    requestContext = requestContext != null ? requestContext : new RouterContextProvider();
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, { method });
       let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
@@ -2780,8 +2805,8 @@ function createStaticHandler(routes, opts) {
     }
     if (generateMiddlewareResponse) {
       invariant(
-        requestContext instanceof unstable_RouterContextProvider,
-        "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
+        requestContext instanceof RouterContextProvider,
+        "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `RouterContextProvider`"
       );
       try {
         await loadLazyMiddlewareForMatches(
@@ -2801,7 +2826,7 @@ function createStaticHandler(routes, opts) {
           },
           async () => {
             let res = await generateMiddlewareResponse(
-              async (revalidationRequest) => {
+              async (revalidationRequest, opts2 = {}) => {
                 let result2 = await queryImpl(
                   revalidationRequest,
                   location,
@@ -2810,7 +2835,7 @@ function createStaticHandler(routes, opts) {
                   dataStrategy || null,
                   skipLoaderErrorBubbling === true,
                   null,
-                  filterMatchesToLoad || null,
+                  "filterMatchesToLoad" in opts2 ? opts2.filterMatchesToLoad ?? null : null,
                   skipRevalidation === true
                 );
                 if (isResponse(result2)) {
@@ -2823,9 +2848,23 @@ function createStaticHandler(routes, opts) {
             return res;
           },
           async (error, routeId) => {
-            if (isResponse(error)) {
+            if (isRedirectResponse(error)) {
               return error;
             }
+            if (isResponse(error)) {
+              try {
+                error = new ErrorResponseImpl(
+                  error.status,
+                  error.statusText,
+                  await parseResponseBody(error)
+                );
+              } catch (e) {
+                error = e;
+              }
+            }
+            if (isDataWithResponseInit(error)) {
+              error = dataWithResponseInitToErrorResponse(error);
+            }
             if (renderedStaticContext) {
               if (routeId in renderedStaticContext.loaderData) {
                 renderedStaticContext.loaderData[routeId] = void 0;
@@ -2894,13 +2933,13 @@ function createStaticHandler(routes, opts) {
     routeId,
     requestContext,
     dataStrategy,
-    unstable_generateMiddlewareResponse: generateMiddlewareResponse
+    generateMiddlewareResponse
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
-    requestContext = requestContext != null ? requestContext : new unstable_RouterContextProvider();
+    requestContext = requestContext != null ? requestContext : new RouterContextProvider();
     if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
       throw getInternalRouterError(405, { method });
     } else if (!matches) {
@@ -2917,8 +2956,8 @@ function createStaticHandler(routes, opts) {
     }
     if (generateMiddlewareResponse) {
       invariant(
-        requestContext instanceof unstable_RouterContextProvider,
-        "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
+        requestContext instanceof RouterContextProvider,
+        "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `RouterContextProvider`"
       );
       await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2);
       let response = await runServerMiddlewarePipeline(
@@ -2951,8 +2990,8 @@ function createStaticHandler(routes, opts) {
           return res;
         },
         (error) => {
-          if (isRouteErrorResponse(error)) {
-            return Promise.resolve(errorResponseToResponse(error));
+          if (isDataWithResponseInit(error)) {
+            return Promise.resolve(dataWithResponseInitToResponse(error));
           }
           if (isResponse(error)) {
             return Promise.resolve(error);
@@ -3281,8 +3320,12 @@ function createStaticHandler(routes, opts) {
             basename
           );
         }
-        if (isResponse(result.result) && isRouteRequest) {
-          throw result;
+        if (isRouteRequest) {
+          if (isResponse(result.result)) {
+            throw result;
+          } else if (isDataWithResponseInit(result.result)) {
+            throw dataWithResponseInitToResponse(result.result);
+          }
         }
         dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
       })
@@ -3904,11 +3947,11 @@ function isNonNullable(value) {
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
-    if (typeof route.lazy !== "object" || !route.lazy.unstable_middleware) {
+    if (typeof route.lazy !== "object" || !route.lazy.middleware) {
       return void 0;
     }
     return loadLazyRouteProperty({
-      key: "unstable_middleware",
+      key: "middleware",
       route,
       manifest,
       mapRouteProperties: mapRouteProperties2
@@ -3926,214 +3969,124 @@ async function defaultDataStrategy(args) {
   return keyedResults;
 }
 async function defaultDataStrategyWithMiddleware(args) {
-  if (!args.matches.some((m) => m.route.unstable_middleware)) {
+  if (!args.matches.some((m) => m.route.middleware)) {
     return defaultDataStrategy(args);
   }
-  let didCallHandler = false;
-  return runClientMiddlewarePipeline(
+  return runClientMiddlewarePipeline(args, () => defaultDataStrategy(args));
+}
+function runServerMiddlewarePipeline(args, handler, errorHandler) {
+  return runMiddlewarePipeline(
     args,
-    () => {
-      didCallHandler = true;
-      return defaultDataStrategy(args);
-    },
-    (error, routeId) => clientMiddlewareErrorHandler(
-      error,
-      routeId,
-      args.matches,
-      didCallHandler
-    )
+    handler,
+    processResult,
+    isResponse,
+    errorHandler
   );
-}
-function clientMiddlewareErrorHandler(error, routeId, matches, didCallHandler) {
-  if (didCallHandler) {
-    return {
-      [routeId]: { type: "error", result: error }
-    };
-  } else {
-    let maxBoundaryIdx = Math.min(
-      // Throwing route
-      matches.findIndex((m) => m.route.id === routeId) || 0,
-      // or the shallowest route that needs to load data
-      matches.findIndex((m) => m.unstable_shouldCallHandler()) || 0
-    );
-    let boundaryRouteId = findNearestBoundary(
-      matches,
-      matches[maxBoundaryIdx].route.id
-    ).route.id;
-    return {
-      [boundaryRouteId]: { type: "error", result: error }
-    };
+  function processResult(result) {
+    return isDataWithResponseInit(result) ? dataWithResponseInitToResponse(result) : result;
   }
 }
-async function runServerMiddlewarePipeline(args, handler, errorHandler) {
-  let { matches, request, params, context } = args;
-  let tuples = matches.flatMap(
-    (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
-  );
-  let result = await callServerRouteMiddleware(
-    { request, params, context },
-    tuples,
+function runClientMiddlewarePipeline(args, handler) {
+  return runMiddlewarePipeline(
+    args,
     handler,
+    (r) => r,
+    // No post-processing needed on the client
+    isDataStrategyResults,
     errorHandler
   );
-  if (isResponse(result)) {
-    return result;
-  }
-  invariant(false, `Expected a Response to be returned from route middleware`);
-}
-async function callServerRouteMiddleware(args, middlewares, handler, errorHandler, idx = 0) {
-  let { request } = args;
-  if (request.signal.aborted) {
-    if (request.signal.reason) {
-      throw request.signal.reason;
-    }
-    throw new Error(
-      `Request aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`
-    );
-  }
-  let tuple = middlewares[idx];
-  if (!tuple) {
-    let result = await handler();
-    return result;
-  }
-  let [routeId, middleware] = tuple;
-  let nextCalled = false;
-  let nextResult = void 0;
-  let next = async () => {
-    if (nextCalled) {
-      throw new Error("You may only call `next()` once per middleware");
-    }
-    nextCalled = true;
-    try {
-      let result = await callServerRouteMiddleware(
-        args,
-        middlewares,
-        handler,
-        errorHandler,
-        idx + 1
-      );
-      if (isDataWithResponseInit(result)) {
-        result = dataWithResponseInitToResponse(result);
-      }
-      nextResult = result;
-      return nextResult;
-    } catch (e) {
-      nextResult = await errorHandler(
-        // Convert thrown data() values to ErrorResponses
-        isDataWithResponseInit(e) ? dataWithResponseInitToErrorResponse(e) : e,
-        routeId
+  function errorHandler(error, routeId, nextResult) {
+    if (nextResult) {
+      return Promise.resolve(
+        Object.assign(nextResult.value, {
+          [routeId]: { type: "error", result: error }
+        })
       );
-      return nextResult;
-    }
-  };
-  try {
-    let result = await middleware(
-      {
-        request: args.request,
-        params: args.params,
-        context: args.context
-      },
-      next
-    );
-    if (isDataWithResponseInit(result)) {
-      result = dataWithResponseInitToResponse(result);
-    }
-    if (nextCalled) {
-      return typeof result === "undefined" ? nextResult : result;
-    } else if (isResponse(result)) {
-      return result;
     } else {
-      nextResult = await next();
-      return nextResult;
+      let { matches } = args;
+      let maxBoundaryIdx = Math.min(
+        // Throwing route
+        matches.findIndex((m) => m.route.id === routeId) || 0,
+        // or the shallowest route that needs to load data
+        matches.findIndex((m) => m.unstable_shouldCallHandler()) || 0
+      );
+      let boundaryRouteId = findNearestBoundary(
+        matches,
+        matches[maxBoundaryIdx].route.id
+      ).route.id;
+      return Promise.resolve({
+        [boundaryRouteId]: { type: "error", result: error }
+      });
     }
-  } catch (e) {
-    let response = await errorHandler(
-      // Convert thrown data() values to ErrorResponses
-      isDataWithResponseInit(e) ? dataWithResponseInitToErrorResponse(e) : e,
-      routeId
-    );
-    return response;
   }
 }
-async function runClientMiddlewarePipeline(args, handler, errorHandler) {
+async function runMiddlewarePipeline(args, handler, processResult, isResult, errorHandler) {
   let { matches, request, params, context } = args;
   let tuples = matches.flatMap(
-    (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
+    (m) => m.route.middleware ? m.route.middleware.map((fn) => [m.route.id, fn]) : []
   );
-  let handlerResult = {};
-  await callClientRouteMiddleware(
+  let result = await callRouteMiddleware(
     { request, params, context },
     tuples,
     handler,
-    errorHandler,
-    handlerResult
+    processResult,
+    isResult,
+    errorHandler
   );
-  return handlerResult;
+  return result;
 }
-async function callClientRouteMiddleware(args, middlewares, handler, errorHandler, handlerResult = {}, idx = 0) {
+async function callRouteMiddleware(args, middlewares, handler, processResult, isResult, errorHandler, idx = 0) {
   let { request } = args;
   if (request.signal.aborted) {
-    if (request.signal.reason) {
-      throw request.signal.reason;
-    }
-    throw new Error(
-      `Request aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`
-    );
+    throw request.signal.reason ?? new Error(`Request aborted: ${request.method} ${request.url}`);
   }
   let tuple = middlewares[idx];
   if (!tuple) {
     let result = await handler();
-    Object.assign(handlerResult, result);
-    return;
+    return result;
   }
   let [routeId, middleware] = tuple;
-  let nextCalled = false;
+  let nextResult;
   let next = async () => {
-    if (nextCalled) {
+    if (nextResult) {
       throw new Error("You may only call `next()` once per middleware");
     }
-    nextCalled = true;
     try {
-      let result = await callClientRouteMiddleware(
+      let result = await callRouteMiddleware(
         args,
         middlewares,
         handler,
+        processResult,
+        isResult,
         errorHandler,
-        handlerResult,
         idx + 1
       );
-      Object.assign(handlerResult, result);
-    } catch (e) {
-      let result = await errorHandler(e, routeId);
-      Object.assign(handlerResult, result);
+      nextResult = { value: result };
+      return nextResult.value;
+    } catch (error) {
+      nextResult = { value: await errorHandler(error, routeId, nextResult) };
+      return nextResult.value;
     }
   };
   try {
-    let result = await middleware(
-      {
-        request: args.request,
-        params: args.params,
-        context: args.context
-      },
-      next
-    );
-    if (typeof result !== "undefined") {
-      console.warn(
-        "client middlewares are not intended to return values, the value will be ignored",
-        result
-      );
-    }
-    if (!nextCalled) {
-      await next();
+    let value = await middleware(args, next);
+    let result = value != null ? processResult(value) : void 0;
+    if (isResult(result)) {
+      return result;
+    } else if (nextResult) {
+      return result ?? nextResult.value;
+    } else {
+      nextResult = { value: await next() };
+      return nextResult.value;
     }
   } catch (error) {
-    let result = await errorHandler(error, routeId);
-    Object.assign(handlerResult, result);
+    let response = await errorHandler(error, routeId, nextResult);
+    return response;
   }
 }
 function getDataStrategyMatchLazyPromises(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip) {
   let lazyMiddlewarePromise = loadLazyRouteProperty({
-    key: "unstable_middleware",
+    key: "middleware",
     route: match.route,
     manifest,
     mapRouteProperties: mapRouteProperties2
@@ -4233,39 +4186,28 @@ async function callDataStrategyImpl(dataStrategyImpl, request, matches, fetcherK
     context: scopedContext,
     matches
   };
-  let unstable_runClientMiddleware = isStaticHandler ? () => {
+  let runClientMiddleware = isStaticHandler ? () => {
     throw new Error(
-      "You cannot call `unstable_runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`"
+      "You cannot call `runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`"
     );
   } : (cb) => {
     let typedDataStrategyArgs = dataStrategyArgs;
-    let didCallHandler = false;
-    return runClientMiddlewarePipeline(
-      typedDataStrategyArgs,
-      () => {
-        didCallHandler = true;
-        return cb({
-          ...typedDataStrategyArgs,
-          fetcherKey,
-          unstable_runClientMiddleware: () => {
-            throw new Error(
-              "Cannot call `unstable_runClientMiddleware()` from within an `unstable_runClientMiddleware` handler"
-            );
-          }
-        });
-      },
-      (error, routeId) => clientMiddlewareErrorHandler(
-        error,
-        routeId,
-        matches,
-        didCallHandler
-      )
-    );
+    return runClientMiddlewarePipeline(typedDataStrategyArgs, () => {
+      return cb({
+        ...typedDataStrategyArgs,
+        fetcherKey,
+        runClientMiddleware: () => {
+          throw new Error(
+            "Cannot call `runClientMiddleware()` from within an `runClientMiddleware` handler"
+          );
+        }
+      });
+    });
   };
   let results = await dataStrategyImpl({
     ...dataStrategyArgs,
     fetcherKey,
-    unstable_runClientMiddleware
+    runClientMiddleware
   });
   try {
     await Promise.all(
@@ -4377,21 +4319,19 @@ async function callLoaderOrAction({
   }
   return result;
 }
+async function parseResponseBody(response) {
+  let contentType = response.headers.get("Content-Type");
+  if (contentType && /\bapplication\/json\b/.test(contentType)) {
+    return response.body == null ? null : response.json();
+  }
+  return response.text();
+}
 async function convertDataStrategyResultToDataResult(dataStrategyResult) {
   let { result, type } = dataStrategyResult;
   if (isResponse(result)) {
     let data2;
     try {
-      let contentType = result.headers.get("Content-Type");
-      if (contentType && /\bapplication\/json\b/.test(contentType)) {
-        if (result.body == null) {
-          data2 = null;
-        } else {
-          data2 = await result.json();
-        }
-      } else {
-        data2 = await result.text();
-      }
+      data2 = await parseResponseBody(result);
     } catch (e) {
       return { type: "error" /* error */, error: e };
     }
@@ -4721,10 +4661,7 @@ function isHashChangeOnly(a, b) {
   return false;
 }
 function dataWithResponseInitToResponse(data2) {
-  return new Response(
-    typeof data2.data === "string" ? data2.data : JSON.stringify(data2.data),
-    data2.init || void 0
-  );
+  return Response.json(data2.data, data2.init ?? void 0);
 }
 function dataWithResponseInitToErrorResponse(data2) {
   return new ErrorResponseImpl(
@@ -4733,13 +4670,9 @@ function dataWithResponseInitToErrorResponse(data2) {
     data2.data
   );
 }
-function errorResponseToResponse(error) {
-  return new Response(
-    typeof error.data === "string" ? error.data : JSON.stringify(error.data),
-    {
-      status: error.status,
-      statusText: error.statusText
-    }
+function isDataStrategyResults(result) {
+  return result != null && typeof result === "object" && Object.entries(result).every(
+    ([key, value]) => typeof key === "string" && isDataStrategyResult(value)
   );
 }
 function isDataStrategyResult(result) {
@@ -5660,7 +5593,7 @@ var hydrationRouteProperties = [
 function createMemoryRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
-    unstable_getContext: opts?.unstable_getContext,
+    getContext: opts?.getContext,
     future: opts?.future,
     history: createMemoryHistory({
       initialEntries: opts?.initialEntries,
@@ -7164,7 +7097,7 @@ function getTurboStreamSingleFetchDataStrategy(getRouter, manifest, routeModules
     ssr,
     basename
   );
-  return async (args) => args.unstable_runClientMiddleware(dataStrategy);
+  return async (args) => args.runClientMiddleware(dataStrategy);
 }
 function getSingleFetchDataStrategyImpl(getRouter, getRouteInfo, fetchAndDecode, ssr, basename, shouldAllowOptOut = () => true) {
   return async (args) => {
@@ -7960,7 +7893,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
       Object.assign(dataRoute, {
         ...dataRoute,
         ...getRouteComponents(route, routeModule, isSpaMode),
-        unstable_middleware: routeModule.unstable_clientMiddleware,
+        middleware: routeModule.clientMiddleware,
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
           dataRoute.path,
@@ -8102,17 +8035,14 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
             }
           });
         } : void 0,
-        unstable_middleware: route.hasClientMiddleware ? async () => {
-          let { unstable_clientMiddleware } = route.clientMiddlewareModule ? await import(
+        middleware: route.hasClientMiddleware ? async () => {
+          let { clientMiddleware } = route.clientMiddlewareModule ? await import(
             /* @vite-ignore */
             /* webpackIgnore: true */
             route.clientMiddlewareModule
           ) : await getLazyRoute();
-          invariant2(
-            unstable_clientMiddleware,
-            "No `unstable_clientMiddleware` export found"
-          );
-          return unstable_clientMiddleware;
+          invariant2(clientMiddleware, "No `clientMiddleware` export found");
+          return clientMiddleware;
         } : void 0,
         shouldRevalidate: async () => {
           let lazyRoute = await getLazyRoute();
@@ -8193,7 +8123,7 @@ async function loadRouteModuleWithBlockingLinks(route, routeModules) {
   return {
     Component: getRouteModuleComponent(routeModule),
     ErrorBoundary: routeModule.ErrorBoundary,
-    unstable_clientMiddleware: routeModule.unstable_clientMiddleware,
+    clientMiddleware: routeModule.clientMiddleware,
     clientAction: routeModule.clientAction,
     clientLoader: routeModule.clientLoader,
     handle: routeModule.handle,
@@ -9036,14 +8966,14 @@ var isBrowser = typeof window !== "undefined" && typeof window.document !== "und
 try {
   if (isBrowser) {
     window.__reactRouterVersion = // @ts-expect-error
-    "0.0.0-experimental-3d7dcee";
+    "0.0.0-experimental-426e5caec";
   }
 } catch (e) {
 }
 function createBrowserRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
-    unstable_getContext: opts?.unstable_getContext,
+    getContext: opts?.getContext,
     future: opts?.future,
     history: createBrowserHistory({ window: opts?.window }),
     hydrationData: opts?.hydrationData || parseHydrationData(),
@@ -9058,7 +8988,7 @@ function createBrowserRouter(routes, opts) {
 function createHashRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
-    unstable_getContext: opts?.unstable_getContext,
+    getContext: opts?.getContext,
     future: opts?.future,
     history: createHashHistory({ window: opts?.window }),
     hydrationData: opts?.hydrationData || parseHydrationData(),
@@ -10027,7 +9957,7 @@ function createStaticRouter(routes, context, opts = {}) {
     },
     get future() {
       return {
-        unstable_middleware: false,
+        v8_middleware: false,
         ...opts?.future
       };
     },
@@ -10133,8 +10063,8 @@ export {
   invariant,
   createPath,
   parsePath,
-  unstable_createContext,
-  unstable_RouterContextProvider,
+  createContext,
+  RouterContextProvider,
   convertRoutesToDataRoutes,
   matchRoutes,
   generatePath,