@react-router/dev 7.6.0 → 7.6.1-pre.0

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v7.6.0
+ * @react-router/dev v7.6.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -59,10 +59,9 @@ var import_picocolors3 = __toESM(require("picocolors"));
 var import_kebabCase = __toESM(require("lodash/kebabCase"));
 
 // typegen/index.ts
-var import_node_fs2 = __toESM(require("fs"));
-var import_dedent2 = __toESM(require("dedent"));
-var Path5 = __toESM(require("pathe"));
-var import_picocolors2 = __toESM(require("picocolors"));
+var import_promises = __toESM(require("fs/promises"));
+var Path4 = __toESM(require("pathe"));
+var import_picocolors2 = require("picocolors");
 
 // config/config.ts
 var import_node_fs = __toESM(require("fs"));
@@ -414,7 +413,7 @@ async function resolveConfig({
   );
   let {
     appDirectory: userAppDirectory,
-    basename: basename2,
+    basename: basename3,
     buildDirectory: userBuildDirectory,
     buildEnd,
     prerender,
@@ -529,7 +528,7 @@ async function resolveConfig({
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
-    basename: basename2,
+    basename: basename3,
     buildDirectory,
     buildEnd,
     future,
@@ -592,11 +591,11 @@ async function createConfigLoader({
         fsWatcher = import_chokidar.default.watch([root, appDirectory], {
           ignoreInitial: true,
           ignored: (path6) => {
-            let dirname5 = import_pathe3.default.dirname(path6);
-            return !dirname5.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
+            let dirname4 = import_pathe3.default.dirname(path6);
+            return !dirname4.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
             // that are at the root level, not nested in subdirectories
             path6 !== root && // Watch the root directory itself
-            dirname5 !== root;
+            dirname4 !== root;
           }
         });
         fsWatcher.on("all", async (...args) => {
@@ -736,15 +735,15 @@ function omitRoutes(config) {
   };
 }
 var entryExts = [".js", ".jsx", ".ts", ".tsx"];
-function isEntryFile(entryBasename, filename3) {
-  return entryExts.some((ext) => filename3 === `${entryBasename}${ext}`);
+function isEntryFile(entryBasename, filename2) {
+  return entryExts.some((ext) => filename2 === `${entryBasename}${ext}`);
 }
-function findEntry(dir, basename2, options) {
+function findEntry(dir, basename3, options) {
   let currentDir = import_pathe3.default.resolve(dir);
   let { root } = import_pathe3.default.parse(currentDir);
   while (true) {
     for (let ext of options?.extensions ?? entryExts) {
-      let file = import_pathe3.default.resolve(currentDir, basename2 + ext);
+      let file = import_pathe3.default.resolve(currentDir, basename3 + ext);
       if (import_node_fs.default.existsSync(file)) {
         return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
       }
@@ -784,6 +783,30 @@ function isEntryFileDependency(moduleGraph, entryFilepath, filepath, visited = /
   return false;
 }
 
+// typegen/context.ts
+async function createContext2({
+  rootDirectory,
+  watch: watch2,
+  mode
+}) {
+  const configLoader = await createConfigLoader({ rootDirectory, mode, watch: watch2 });
+  const configResult = await configLoader.getConfig();
+  if (!configResult.ok) {
+    throw new Error(configResult.error);
+  }
+  const config = configResult.value;
+  return {
+    configLoader,
+    rootDirectory,
+    config
+  };
+}
+
+// typegen/generate.ts
+var import_dedent = __toESM(require("dedent"));
+var Path3 = __toESM(require("pathe"));
+var Pathe = __toESM(require("pathe/utils"));
+
 // vite/babel.ts
 var babel_exports = {};
 __export(babel_exports, {
@@ -797,26 +820,6 @@ var t = __toESM(require("@babel/types"));
 var traverse = require("@babel/traverse").default;
 var generate = require("@babel/generator").default;
 
-// typegen/generate.ts
-var import_dedent = __toESM(require("dedent"));
-var Path4 = __toESM(require("pathe"));
-var Pathe2 = __toESM(require("pathe/utils"));
-
-// typegen/paths.ts
-var Path3 = __toESM(require("pathe"));
-var Pathe = __toESM(require("pathe/utils"));
-function getTypesDir(ctx) {
-  return Path3.join(ctx.rootDirectory, ".react-router/types");
-}
-function getTypesPath(ctx, route) {
-  return Path3.join(
-    getTypesDir(ctx),
-    Path3.relative(ctx.rootDirectory, ctx.config.appDirectory),
-    Path3.dirname(route.file),
-    "+types/" + Pathe.filename(route.file) + ".ts"
-  );
-}
-
 // typegen/params.ts
 function parse2(fullpath2) {
   const result = {};
@@ -846,97 +849,367 @@ function lineage(routes, route) {
   return result;
 }
 function fullpath(lineage2) {
-  if (lineage2.length === 1 && lineage2[0].id === "root") return "/";
-  return "/" + lineage2.map((route) => route.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path6) => path6 !== void 0 && path6 !== "").join("/");
+  const route = lineage2.at(-1);
+  if (lineage2.length === 1 && route?.id === "root") return "/";
+  const isLayout = route && route.index !== true && route.path === void 0;
+  if (isLayout) return void 0;
+  return "/" + lineage2.map((route2) => route2.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path6) => path6 !== void 0 && path6 !== "").join("/");
 }
 
 // typegen/generate.ts
-function generate2(ctx, route) {
-  const lineage2 = lineage(ctx.config.routes, route);
-  const fullpath2 = fullpath(lineage2);
-  const typesPath = getTypesPath(ctx, route);
-  const parents = lineage2.slice(0, -1);
-  const parentTypeImports = parents.map((parent, i) => {
-    const rel = Path4.relative(
-      Path4.dirname(typesPath),
-      getTypesPath(ctx, parent)
-    );
-    const indent = i === 0 ? "" : "  ".repeat(2);
-    let source = noExtension(rel);
-    if (!source.startsWith("../")) source = "./" + source;
-    return `${indent}import type { Info as Parent${i} } from "${source}.js"`;
-  }).join("\n");
-  return import_dedent.default`
-    // React Router generated types for route:
-    // ${route.file}
-
-    import type * as T from "react-router/route-module"
+function typesDirectory(ctx) {
+  return Path3.join(ctx.rootDirectory, ".react-router/types");
+}
+function generateFuture(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+future.ts");
+  const content = import_dedent.default`
+    // Generated by React Router
 
-    ${parentTypeImports}
+    import "react-router";
 
-    type Module = typeof import("../${Pathe2.filename(route.file)}.js")
+    declare module "react-router" {
+      interface Future {
+        unstable_middleware: ${ctx.config.future.unstable_middleware}
+      }
+    }
+  `;
+  return { filename: filename2, content };
+}
+function generateServerBuild(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+server-build.d.ts");
+  const content = import_dedent.default`
+    // Generated by React Router
 
-    export type Info = {
-      parents: [${parents.map((_, i) => `Parent${i}`).join(", ")}],
-      id: "${route.id}"
-      file: "${route.file}"
-      path: "${route.path}"
-      params: {${formatParamProperties(
-    fullpath2
-  )}} & { [key: string]: string | undefined }
-      module: Module
-      loaderData: T.CreateLoaderData<Module>
-      actionData: T.CreateActionData<Module>
+    declare module "virtual:react-router/server-build" {
+      import { ServerBuild } from "react-router";
+      export const assets: ServerBuild["assets"];
+      export const assetsBuildDirectory: ServerBuild["assetsBuildDirectory"];
+      export const basename: ServerBuild["basename"];
+      export const entry: ServerBuild["entry"];
+      export const future: ServerBuild["future"];
+      export const isSpaMode: ServerBuild["isSpaMode"];
+      export const prerender: ServerBuild["prerender"];
+      export const publicPath: ServerBuild["publicPath"];
+      export const routeDiscovery: ServerBuild["routeDiscovery"];
+      export const routes: ServerBuild["routes"];
+      export const ssr: ServerBuild["ssr"];
+      export const unstable_getCriticalCss: ServerBuild["unstable_getCriticalCss"];
+    }
+  `;
+  return { filename: filename2, content };
+}
+var { t: t2 } = babel_exports;
+function generateRoutes(ctx) {
+  const fileToRoutes = /* @__PURE__ */ new Map();
+  const lineages = /* @__PURE__ */ new Map();
+  const allPages = /* @__PURE__ */ new Set();
+  const routeToPages = /* @__PURE__ */ new Map();
+  for (const route of Object.values(ctx.config.routes)) {
+    let routeIds = fileToRoutes.get(route.file);
+    if (!routeIds) {
+      routeIds = /* @__PURE__ */ new Set();
+      fileToRoutes.set(route.file, routeIds);
     }
+    routeIds.add(route.id);
+    const lineage2 = lineage(ctx.config.routes, route);
+    lineages.set(route.id, lineage2);
+    const fullpath2 = fullpath(lineage2);
+    if (!fullpath2) continue;
+    const pages = explodeOptionalSegments(fullpath2);
+    pages.forEach((page) => allPages.add(page));
+    lineage2.forEach(({ id }) => {
+      let routePages = routeToPages.get(id);
+      if (!routePages) {
+        routePages = /* @__PURE__ */ new Set();
+        routeToPages.set(id, routePages);
+      }
+      pages.forEach((page) => routePages.add(page));
+    });
+  }
+  const routesTs = {
+    filename: Path3.join(typesDirectory(ctx), "+routes.ts"),
+    content: import_dedent.default`
+        // Generated by React Router
 
-    export namespace Route {
-      export type LinkDescriptors = T.LinkDescriptors
-      export type LinksFunction = () => LinkDescriptors
+        import "react-router"
 
-      export type MetaArgs = T.CreateMetaArgs<Info>
-      export type MetaDescriptors = T.MetaDescriptors
-      export type MetaFunction = (args: MetaArgs) => MetaDescriptors
+        declare module "react-router" {
+          interface Register {
+            pages: Pages
+            routeFiles: RouteFiles
+          }
+        }
+      ` + "\n\n" + generate(pagesType(allPages)).code + "\n\n" + generate(routeFilesType({ fileToRoutes, routeToPages })).code
+  };
+  const allAnnotations = Array.from(fileToRoutes.entries()).filter(([file]) => isInAppDirectory(ctx, file)).map(
+    ([file, routeIds]) => getRouteAnnotations({ ctx, file, routeIds, lineages })
+  );
+  return [routesTs, ...allAnnotations];
+}
+function pagesType(pages) {
+  return t2.tsTypeAliasDeclaration(
+    t2.identifier("Pages"),
+    null,
+    t2.tsTypeLiteral(
+      Array.from(pages).map((page) => {
+        return t2.tsPropertySignature(
+          t2.stringLiteral(page),
+          t2.tsTypeAnnotation(
+            t2.tsTypeLiteral([
+              t2.tsPropertySignature(
+                t2.identifier("params"),
+                t2.tsTypeAnnotation(paramsType(page))
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+}
+function routeFilesType({
+  fileToRoutes,
+  routeToPages
+}) {
+  return t2.tsTypeAliasDeclaration(
+    t2.identifier("RouteFiles"),
+    null,
+    t2.tsTypeLiteral(
+      Array.from(fileToRoutes).map(
+        ([file, routeIds]) => t2.tsPropertySignature(
+          t2.stringLiteral(file),
+          t2.tsTypeAnnotation(
+            t2.tsUnionType(
+              Array.from(routeIds).map((routeId) => {
+                const pages = routeToPages.get(routeId) ?? /* @__PURE__ */ new Set();
+                return t2.tsTypeLiteral([
+                  t2.tsPropertySignature(
+                    t2.identifier("id"),
+                    t2.tsTypeAnnotation(
+                      t2.tsLiteralType(t2.stringLiteral(routeId))
+                    )
+                  ),
+                  t2.tsPropertySignature(
+                    t2.identifier("page"),
+                    t2.tsTypeAnnotation(
+                      pages ? t2.tsUnionType(
+                        Array.from(pages).map(
+                          (page) => t2.tsLiteralType(t2.stringLiteral(page))
+                        )
+                      ) : t2.tsNeverKeyword()
+                    )
+                  )
+                ]);
+              })
+            )
+          )
+        )
+      )
+    )
+  );
+}
+function isInAppDirectory(ctx, routeFile) {
+  const path6 = Path3.resolve(ctx.config.appDirectory, routeFile);
+  return path6.startsWith(ctx.config.appDirectory);
+}
+function getRouteAnnotations({
+  ctx,
+  file,
+  routeIds,
+  lineages
+}) {
+  const filename2 = Path3.join(
+    typesDirectory(ctx),
+    Path3.relative(ctx.rootDirectory, ctx.config.appDirectory),
+    Path3.dirname(file),
+    "+types",
+    Pathe.filename(file) + ".ts"
+  );
+  const matchesType = t2.tsTypeAliasDeclaration(
+    t2.identifier("Matches"),
+    null,
+    t2.tsUnionType(
+      Array.from(routeIds).map((routeId) => {
+        const lineage2 = lineages.get(routeId);
+        return t2.tsTupleType(
+          lineage2.map(
+            (route) => t2.tsTypeLiteral([
+              t2.tsPropertySignature(
+                t2.identifier("id"),
+                t2.tsTypeAnnotation(t2.tsLiteralType(t2.stringLiteral(route.id)))
+              ),
+              t2.tsPropertySignature(
+                t2.identifier("module"),
+                t2.tsTypeAnnotation(
+                  t2.tsTypeQuery(
+                    t2.tsImportType(
+                      t2.stringLiteral(
+                        relativeImportSource(
+                          rootDirsPath(ctx, filename2),
+                          Path3.resolve(ctx.config.appDirectory, route.file)
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+  const routeImportSource = relativeImportSource(
+    rootDirsPath(ctx, filename2),
+    Path3.resolve(ctx.config.appDirectory, file)
+  );
+  const content = import_dedent.default`
+      // Generated by React Router
 
-      export type HeadersArgs = T.HeadersArgs
-      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
+      import type { GetInfo, GetAnnotations } from "react-router/internal";
 
-      export type unstable_MiddlewareFunction = T.CreateServerMiddlewareFunction<Info>
-      export type unstable_ClientMiddlewareFunction = T.CreateClientMiddlewareFunction<Info>
-      export type LoaderArgs = T.CreateServerLoaderArgs<Info>
-      export type ClientLoaderArgs = T.CreateClientLoaderArgs<Info>
-      export type ActionArgs = T.CreateServerActionArgs<Info>
-      export type ClientActionArgs = T.CreateClientActionArgs<Info>
+      type Module = typeof import("${routeImportSource}")
 
-      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Info>
-      export type ComponentProps = T.CreateComponentProps<Info>
-      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Info>
-    }
-  `;
+      type Info = GetInfo<{
+        file: "${file}",
+        module: Module
+      }>
+    ` + "\n\n" + generate(matchesType).code + "\n\n" + import_dedent.default`
+      type Annotations = GetAnnotations<Info & { module: Module, matches: Matches }>;
+
+      export namespace Route {
+        // links
+        export type LinkDescriptors = Annotations["LinkDescriptors"];
+        export type LinksFunction = Annotations["LinksFunction"];
+
+        // meta
+        export type MetaArgs = Annotations["MetaArgs"];
+        export type MetaDescriptors = Annotations["MetaDescriptors"];
+        export type MetaFunction = Annotations["MetaFunction"];
+
+        // headers
+        export type HeadersArgs = Annotations["HeadersArgs"];
+        export type HeadersFunction = Annotations["HeadersFunction"];
+
+        // unstable_middleware
+        export type unstable_MiddlewareFunction = Annotations["unstable_MiddlewareFunction"];
+
+        // unstable_clientMiddleware
+        export type unstable_ClientMiddlewareFunction = Annotations["unstable_ClientMiddlewareFunction"];
+
+        // loader
+        export type LoaderArgs = Annotations["LoaderArgs"];
+
+        // clientLoader
+        export type ClientLoaderArgs = Annotations["ClientLoaderArgs"];
+
+        // action
+        export type ActionArgs = Annotations["ActionArgs"];
+
+        // clientAction
+        export type ClientActionArgs = Annotations["ClientActionArgs"];
+
+        // HydrateFallback
+        export type HydrateFallbackProps = Annotations["HydrateFallbackProps"];
+
+        // Component
+        export type ComponentProps = Annotations["ComponentProps"];
+
+        // ErrorBoundary
+        export type ErrorBoundaryProps = Annotations["ErrorBoundaryProps"];
+      }
+    `;
+  return { filename: filename2, content };
 }
-var noExtension = (path6) => Path4.join(Path4.dirname(path6), Pathe2.filename(path6));
-function formatParamProperties(fullpath2) {
-  const params = parse2(fullpath2);
-  const properties = Object.entries(params).map(
-    ([name, isRequired]) => isRequired ? `"${name}": string` : `"${name}"?: string`
+function relativeImportSource(from, to) {
+  let path6 = Path3.relative(Path3.dirname(from), to);
+  path6 = Path3.join(Path3.dirname(path6), Pathe.filename(path6));
+  if (!path6.startsWith("../")) path6 = "./" + path6;
+  return path6 + ".js";
+}
+function rootDirsPath(ctx, typesPath) {
+  const rel = Path3.relative(typesDirectory(ctx), typesPath);
+  return Path3.join(ctx.rootDirectory, rel);
+}
+function paramsType(path6) {
+  const params = parse2(path6);
+  return t2.tsTypeLiteral(
+    Object.entries(params).map(([param, isRequired]) => {
+      const property = t2.tsPropertySignature(
+        t2.stringLiteral(param),
+        t2.tsTypeAnnotation(t2.tsStringKeyword())
+      );
+      property.optional = !isRequired;
+      return property;
+    })
+  );
+}
+function explodeOptionalSegments(path6) {
+  let segments = path6.split("/");
+  if (segments.length === 0) return [];
+  let [first, ...rest] = segments;
+  let isOptional = first.endsWith("?");
+  let required = first.replace(/\?$/, "");
+  if (rest.length === 0) {
+    return isOptional ? [required, ""] : [required];
+  }
+  let restExploded = explodeOptionalSegments(rest.join("/"));
+  let result = [];
+  result.push(
+    ...restExploded.map(
+      (subpath) => subpath === "" ? required : [required, subpath].join("/")
+    )
+  );
+  if (isOptional) {
+    result.push(...restExploded);
+  }
+  return result.map(
+    (exploded) => path6.startsWith("/") && exploded === "" ? "/" : exploded
   );
-  return properties.join("; ");
 }
 
 // typegen/index.ts
+async function clearRouteModuleAnnotations(ctx) {
+  await import_promises.default.rm(
+    Path4.join(typesDirectory(ctx), Path4.basename(ctx.config.appDirectory)),
+    { recursive: true, force: true }
+  );
+}
+async function write(...files) {
+  return Promise.all(
+    files.map(async ({ filename: filename2, content }) => {
+      await import_promises.default.mkdir(Path4.dirname(filename2), { recursive: true });
+      await import_promises.default.writeFile(filename2, content);
+    })
+  );
+}
 async function watch(rootDirectory, { mode, logger }) {
   const ctx = await createContext2({ rootDirectory, mode, watch: true });
-  await writeAll(ctx);
-  logger?.info(import_picocolors2.default.green("generated types"), { timestamp: true, clear: true });
+  await import_promises.default.rm(typesDirectory(ctx), { recursive: true, force: true });
+  await write(
+    generateFuture(ctx),
+    generateServerBuild(ctx),
+    ...generateRoutes(ctx)
+  );
+  logger?.info((0, import_picocolors2.green)("generated types"), { timestamp: true, clear: true });
   ctx.configLoader.onChange(
     async ({ result, configChanged, routeConfigChanged }) => {
       if (!result.ok) {
-        logger?.error(import_picocolors2.default.red(result.error), { timestamp: true, clear: true });
+        logger?.error((0, import_picocolors2.red)(result.error), { timestamp: true, clear: true });
         return;
       }
       ctx.config = result.value;
-      if (configChanged || routeConfigChanged) {
-        await writeAll(ctx);
-        logger?.info(import_picocolors2.default.green("regenerated types"), {
+      if (configChanged) {
+        await write(generateFuture(ctx));
+        logger?.info((0, import_picocolors2.green)("regenerated types"), {
+          timestamp: true,
+          clear: true
+        });
+      }
+      if (routeConfigChanged) {
+        await clearRouteModuleAnnotations(ctx);
+        await write(...generateRoutes(ctx));
+        logger?.info((0, import_picocolors2.green)("regenerated types"), {
           timestamp: true,
           clear: true
         });
@@ -947,102 +1220,6 @@ async function watch(rootDirectory, { mode, logger }) {
     close: async () => await ctx.configLoader.close()
   };
 }
-async function createContext2({
-  rootDirectory,
-  watch: watch2,
-  mode
-}) {
-  const configLoader = await createConfigLoader({ rootDirectory, mode, watch: watch2 });
-  const configResult = await configLoader.getConfig();
-  if (!configResult.ok) {
-    throw new Error(configResult.error);
-  }
-  const config = configResult.value;
-  return {
-    configLoader,
-    rootDirectory,
-    config
-  };
-}
-async function writeAll(ctx) {
-  const typegenDir = getTypesDir(ctx);
-  import_node_fs2.default.rmSync(typegenDir, { recursive: true, force: true });
-  Object.values(ctx.config.routes).forEach((route) => {
-    const typesPath = getTypesPath(ctx, route);
-    const content = generate2(ctx, route);
-    import_node_fs2.default.mkdirSync(Path5.dirname(typesPath), { recursive: true });
-    import_node_fs2.default.writeFileSync(typesPath, content);
-  });
-  const registerPath = Path5.join(typegenDir, "+register.ts");
-  import_node_fs2.default.writeFileSync(registerPath, register(ctx));
-  const virtualPath = Path5.join(typegenDir, "+virtual.d.ts");
-  import_node_fs2.default.writeFileSync(virtualPath, virtual);
-}
-function register(ctx) {
-  const register2 = import_dedent2.default`
-    import "react-router";
-
-    declare module "react-router" {
-      interface Register {
-        params: Params;
-      }
-
-      interface Future {
-        unstable_middleware: ${ctx.config.future.unstable_middleware}
-      }
-    }
-  `;
-  const { t: t2 } = babel_exports;
-  const fullpaths = /* @__PURE__ */ new Set();
-  Object.values(ctx.config.routes).forEach((route) => {
-    if (route.id !== "root" && !route.path) return;
-    const lineage2 = lineage(ctx.config.routes, route);
-    const fullpath2 = fullpath(lineage2);
-    fullpaths.add(fullpath2);
-  });
-  const typeParams = t2.tsTypeAliasDeclaration(
-    t2.identifier("Params"),
-    null,
-    t2.tsTypeLiteral(
-      Array.from(fullpaths).map((fullpath2) => {
-        const params = parse2(fullpath2);
-        return t2.tsPropertySignature(
-          t2.stringLiteral(fullpath2),
-          t2.tsTypeAnnotation(
-            t2.tsTypeLiteral(
-              Object.entries(params).map(([param, isRequired]) => {
-                const property = t2.tsPropertySignature(
-                  t2.stringLiteral(param),
-                  t2.tsTypeAnnotation(t2.tsStringKeyword())
-                );
-                property.optional = !isRequired;
-                return property;
-              })
-            )
-          )
-        );
-      })
-    )
-  );
-  return [register2, generate(typeParams).code].join("\n\n");
-}
-var virtual = import_dedent2.default`
-  declare module "virtual:react-router/server-build" {
-    import { ServerBuild } from "react-router";
-    export const assets: ServerBuild["assets"];
-    export const assetsBuildDirectory: ServerBuild["assetsBuildDirectory"];
-    export const basename: ServerBuild["basename"];
-    export const entry: ServerBuild["entry"];
-    export const future: ServerBuild["future"];
-    export const isSpaMode: ServerBuild["isSpaMode"];
-    export const prerender: ServerBuild["prerender"];
-    export const publicPath: ServerBuild["publicPath"];
-    export const routeDiscovery: ServerBuild["routeDiscovery"];
-    export const routes: ServerBuild["routes"];
-    export const ssr: ServerBuild["ssr"];
-    export const unstable_getCriticalCss: ServerBuild["unstable_getCriticalCss"];
-  }
-`;
 
 // vite/node-adapter.ts
 var import_node_events = require("events");
@@ -2030,7 +2207,7 @@ function getRouteChunkNameFromModuleId(id) {
 }
 
 // vite/with-props.ts
-var import_dedent3 = __toESM(require("dedent"));
+var import_dedent2 = __toESM(require("dedent"));
 var vmod = create("with-props");
 var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
 var plugin = {
@@ -2041,7 +2218,7 @@ var plugin = {
   },
   async load(id) {
     if (id !== vmod.resolvedId) return;
-    return import_dedent3.default`
+    return import_dedent2.default`
       import { createElement as h } from "react";
       import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
 
@@ -2201,7 +2378,7 @@ var isRouteVirtualModule = (id) => {
   return isRouteEntryModuleId(id) || isRouteChunkModuleId(id);
 };
 var isServerBuildVirtualModuleId = (id) => {
-  return id.split("?")[0] === virtual2.serverBuild.id;
+  return id.split("?")[0] === virtual.serverBuild.id;
 };
 var getServerBuildFile = (viteManifest) => {
   let serverBuildIds = Object.keys(viteManifest).filter(
@@ -2231,13 +2408,13 @@ var resolveRelativeRouteFilePath = (route, reactRouterConfig) => {
   let fullPath = path5.resolve(reactRouterConfig.appDirectory, file);
   return vite2.normalizePath(fullPath);
 };
-var virtual2 = {
+var virtual = {
   serverBuild: create("server-build"),
   serverManifest: create("server-manifest"),
   browserManifest: create("browser-manifest")
 };
 var invalidateVirtualModules = (viteDevServer) => {
-  Object.values(virtual2).forEach((vmod2) => {
+  Object.values(virtual).forEach((vmod2) => {
     let mod = viteDevServer.moduleGraph.getModuleById(vmod2.resolvedId);
     if (mod) {
       viteDevServer.moduleGraph.invalidateModule(mod);
@@ -2412,7 +2589,7 @@ var defaultEntriesDir = path5.resolve(
   "config",
   "defaults"
 );
-var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path5.join(defaultEntriesDir, filename3));
+var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path5.join(defaultEntriesDir, filename2));
 invariant(defaultEntries.length > 0, "No default entries found");
 var reactRouterDevLoadContext = () => void 0;
 var reactRouterVitePlugin = () => {
@@ -2508,7 +2685,7 @@ var reactRouterVitePlugin = () => {
       }
     }).join("\n")}
       export { default as assets } from ${JSON.stringify(
-      virtual2.serverManifest.id
+      virtual.serverManifest.id
     )};
       export const assetsBuildDirectory = ${JSON.stringify(
       path5.relative(
@@ -2578,10 +2755,11 @@ var reactRouterVitePlugin = () => {
     let sriManifest = {};
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".js")) {
+        const entryNormalizedPath = "parentPath" in entry && typeof entry.parentPath === "string" ? entry.parentPath : entry.path;
         let contents;
         try {
           contents = await fse.readFile(
-            path5.join(entry.path, entry.name),
+            path5.join(entryNormalizedPath, entry.name),
             "utf-8"
           );
         } catch (e) {
@@ -2590,7 +2768,10 @@ var reactRouterVitePlugin = () => {
         }
         let hash = (0, import_node_crypto.createHash)("sha384").update(contents).digest().toString("base64");
         let filepath = getVite().normalizePath(
-          path5.relative(clientBuildDirectory, path5.join(entry.path, entry.name))
+          path5.relative(
+            clientBuildDirectory,
+            path5.join(entryNormalizedPath, entry.name)
+          )
         );
         sriManifest[`${ctx2.publicPath}${filepath}`] = `sha384-${hash}`;
       }
@@ -2790,7 +2971,7 @@ var reactRouterVitePlugin = () => {
     let sri = void 0;
     let reactRouterManifestForDev = {
       version: String(Math.random()),
-      url: combineURLs(ctx.publicPath, virtual2.browserManifest.url),
+      url: combineURLs(ctx.publicPath, virtual.browserManifest.url),
       hmr: {
         runtime: combineURLs(ctx.publicPath, virtualInjectHmrRuntime.url)
       },
@@ -3171,11 +3352,11 @@ var reactRouterVitePlugin = () => {
                     return;
                   }
                   build = await ssrEnvironment.runner.import(
-                    virtual2.serverBuild.id
+                    virtual.serverBuild.id
                   );
                 } else {
                   build = await viteDevServer.ssrLoadModule(
-                    virtual2.serverBuild.id
+                    virtual.serverBuild.id
                   );
                 }
                 let handler = (0, import_react_router2.createRequestHandler)(build, "development");
@@ -3210,36 +3391,82 @@ var reactRouterVitePlugin = () => {
           let serverBuildDirectory = future.unstable_viteEnvironmentApi ? this.environment.config?.build?.outDir : ctx.environmentBuildContext?.options.build?.outDir ?? getServerBuildDirectory(ctx.reactRouterConfig);
           let ssrViteManifest = await loadViteManifest(serverBuildDirectory);
           let ssrAssetPaths = getViteManifestAssetPaths(ssrViteManifest);
+          let userSsrEmitAssets = (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.ssrEmitAssets ?? viteUserConfig.environments?.ssr?.build?.emitAssets : null) ?? viteUserConfig.build?.ssrEmitAssets ?? false;
           let movedAssetPaths = [];
+          let removedAssetPaths = [];
+          let copiedAssetPaths = [];
           for (let ssrAssetPath of ssrAssetPaths) {
             let src = path5.join(serverBuildDirectory, ssrAssetPath);
             let dest = path5.join(clientBuildDirectory, ssrAssetPath);
-            if (!fse.existsSync(dest)) {
-              await fse.move(src, dest);
-              movedAssetPaths.push(dest);
-            } else {
-              await fse.remove(src);
+            if (!userSsrEmitAssets) {
+              if (!fse.existsSync(dest)) {
+                await fse.move(src, dest);
+                movedAssetPaths.push(dest);
+              } else {
+                await fse.remove(src);
+                removedAssetPaths.push(dest);
+              }
+            } else if (!fse.existsSync(dest)) {
+              await fse.copy(src, dest);
+              copiedAssetPaths.push(dest);
             }
           }
-          let ssrCssPaths = Object.values(ssrViteManifest).flatMap(
-            (chunk) => chunk.css ?? []
-          );
+          if (!userSsrEmitAssets) {
+            let ssrCssPaths = Object.values(ssrViteManifest).flatMap(
+              (chunk) => chunk.css ?? []
+            );
+            await Promise.all(
+              ssrCssPaths.map(async (cssPath) => {
+                let src = path5.join(serverBuildDirectory, cssPath);
+                await fse.remove(src);
+                removedAssetPaths.push(src);
+              })
+            );
+          }
+          let cleanedAssetPaths = [...removedAssetPaths, ...movedAssetPaths];
+          let handledAssetPaths = [...cleanedAssetPaths, ...copiedAssetPaths];
+          let cleanedAssetDirs = new Set(cleanedAssetPaths.map(path5.dirname));
           await Promise.all(
-            ssrCssPaths.map(
-              (cssPath) => fse.remove(path5.join(serverBuildDirectory, cssPath))
-            )
+            Array.from(cleanedAssetDirs).map(async (dir) => {
+              try {
+                const files = await fse.readdir(dir);
+                if (files.length === 0) {
+                  await fse.remove(dir);
+                }
+              } catch {
+              }
+            })
           );
-          if (movedAssetPaths.length) {
-            viteConfig.logger.info(
-              [
-                "",
-                `${import_picocolors3.default.green("\u2713")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from React Router server build to client assets.`,
-                ...movedAssetPaths.map(
-                  (movedAssetPath) => import_picocolors3.default.dim(path5.relative(ctx.rootDirectory, movedAssetPath))
-                ),
-                ""
-              ].join("\n")
-            );
+          if (handledAssetPaths.length) {
+            viteConfig.logger.info("");
+          }
+          function logHandledAssets(paths, message) {
+            invariant(viteConfig);
+            if (paths.length) {
+              viteConfig.logger.info(
+                [
+                  `${import_picocolors3.default.green("\u2713")} ${message}`,
+                  ...paths.map(
+                    (assetPath) => import_picocolors3.default.dim(path5.relative(ctx.rootDirectory, assetPath))
+                  )
+                ].join("\n")
+              );
+            }
+          }
+          logHandledAssets(
+            removedAssetPaths,
+            `${removedAssetPaths.length} asset${removedAssetPaths.length > 1 ? "s" : ""} cleaned from React Router server build.`
+          );
+          logHandledAssets(
+            movedAssetPaths,
+            `${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from React Router server build to client assets.`
+          );
+          logHandledAssets(
+            copiedAssetPaths,
+            `${copiedAssetPaths.length} asset${copiedAssetPaths.length > 1 ? "s" : ""} copied from React Router server build to client assets.`
+          );
+          if (handledAssetPaths.length) {
+            viteConfig.logger.info("");
           }
           process.env.IS_RR_BUILD_REQUEST = "yes";
           if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
@@ -3400,16 +3627,16 @@ var reactRouterVitePlugin = () => {
       name: "react-router:virtual-modules",
       enforce: "pre",
       resolveId(id) {
-        const vmod2 = Object.values(virtual2).find((vmod3) => vmod3.id === id);
+        const vmod2 = Object.values(virtual).find((vmod3) => vmod3.id === id);
         if (vmod2) return vmod2.resolvedId;
       },
       async load(id) {
         switch (id) {
-          case virtual2.serverBuild.resolvedId: {
+          case virtual.serverBuild.resolvedId: {
             let routeIds = getServerBundleRouteIds(this, ctx);
             return await getServerEntry({ routeIds });
           }
-          case virtual2.serverManifest.resolvedId: {
+          case virtual.serverManifest.resolvedId: {
             let routeIds = getServerBundleRouteIds(this, ctx);
             let reactRouterManifest = viteCommand === "build" ? (await generateReactRouterManifestsForBuild({
               routeIds
@@ -3427,7 +3654,7 @@ var reactRouterVitePlugin = () => {
               es6: true
             })};`;
           }
-          case virtual2.browserManifest.resolvedId: {
+          case virtual.browserManifest.resolvedId: {
             if (viteCommand === "build") {
               throw new Error("This module only exists in development");
             }
@@ -3858,16 +4085,16 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
   let response = await handler(request);
   let html = await response.text();
   let isPrerenderSpaFallback = build.prerender.includes("/");
-  let filename3 = isPrerenderSpaFallback ? "__spa-fallback.html" : "index.html";
+  let filename2 = isPrerenderSpaFallback ? "__spa-fallback.html" : "index.html";
   if (response.status !== 200) {
     if (isPrerenderSpaFallback) {
       throw new Error(
-        `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename3}\` file.
+        `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename2}\` file.
 ` + html
       );
     } else {
       throw new Error(
-        `SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename3}\` file.
+        `SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename2}\` file.
 ` + html
       );
     }
@@ -3877,9 +4104,9 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
       "SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`."
     );
   }
-  await fse.writeFile(path5.join(clientBuildDirectory, filename3), html);
+  await fse.writeFile(path5.join(clientBuildDirectory, filename2), html);
   let prettyDir = path5.relative(process.cwd(), clientBuildDirectory);
-  let prettyPath = path5.join(prettyDir, filename3);
+  let prettyPath = path5.join(prettyDir, filename2);
   if (build.prerender.length > 0) {
     viteConfig.logger.info(
       `Prerender (html): SPA Fallback -> ${import_picocolors3.default.bold(prettyPath)}`
@@ -4485,7 +4712,7 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
         copyPublicDir: false,
         // Assets in the public directory are only used by the client
         rollupOptions: {
-          input: (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.rollupOptions?.input : viteUserConfig.build?.rollupOptions?.input) ?? virtual2.serverBuild.id,
+          input: (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.rollupOptions?.input : viteUserConfig.build?.rollupOptions?.input) ?? virtual.serverBuild.id,
           output: {
             entryFileNames: serverBuildFile,
             format: serverModuleFormat