@react-router/dev 0.0.0-experimental-aecfb0db1 → 0.0.0-experimental-5bbc45fb6

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * @react-router/dev v0.0.0-experimental-aecfb0db1
+ * @react-router/dev v0.0.0-experimental-5bbc45fb6
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -357,7 +357,7 @@ async function resolveConfig({
   );
   let {
     appDirectory: userAppDirectory,
-    basename: basename2,
+    basename: basename3,
     buildDirectory: userBuildDirectory,
     buildEnd,
     prerender,
@@ -472,7 +472,7 @@ async function resolveConfig({
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
-    basename: basename2,
+    basename: basename3,
     buildDirectory,
     buildEnd,
     future,
@@ -535,11 +535,11 @@ async function createConfigLoader({
         fsWatcher = import_chokidar.default.watch([root, appDirectory], {
           ignoreInitial: true,
           ignored: (path8) => {
-            let dirname6 = import_pathe3.default.dirname(path8);
-            return !dirname6.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
+            let dirname5 = import_pathe3.default.dirname(path8);
+            return !dirname5.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
             // that are at the root level, not nested in subdirectories
             path8 !== root && // Watch the root directory itself
-            dirname6 !== root;
+            dirname5 !== root;
           }
         });
         fsWatcher.on("all", async (...args) => {
@@ -634,15 +634,15 @@ function omitRoutes(config) {
     routes: {}
   };
 }
-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);
       }
@@ -780,6 +780,31 @@ var init_profiler = __esm({
   }
 });
 
+// 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
+  };
+}
+var init_context = __esm({
+  "typegen/context.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
 // vite/babel.ts
 var babel_exports = {};
 __export(babel_exports, {
@@ -799,27 +824,6 @@ var init_babel = __esm({
   }
 });
 
-// typegen/paths.ts
-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"
-  );
-}
-var Path3, Pathe;
-var init_paths = __esm({
-  "typegen/paths.ts"() {
-    "use strict";
-    Path3 = __toESM(require("pathe"));
-    Pathe = __toESM(require("pathe/utils"));
-  }
-});
-
 // typegen/params.ts
 function parse2(fullpath2) {
   const result = {};
@@ -864,108 +868,335 @@ var init_route = __esm({
 });
 
 // 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"
-
-    ${parentTypeImports}
-
-    type Module = typeof import("../${Pathe2.filename(route.file)}.js")
-
-    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>
+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
+
+    import "react-router";
+
+    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
+
+    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 };
+}
+function generatePages(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+pages.ts");
+  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 pagesType = t2.tsTypeAliasDeclaration(
+    t2.identifier("Pages"),
+    null,
+    t2.tsTypeLiteral(
+      Array.from(fullpaths).map((fullpath2) => {
+        return t2.tsPropertySignature(
+          t2.stringLiteral(fullpath2),
+          t2.tsTypeAnnotation(
+            t2.tsTypeLiteral([
+              t2.tsPropertySignature(
+                t2.identifier("params"),
+                t2.tsTypeAnnotation(paramsType(fullpath2))
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+  const 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
+        }
+      }
+    ` + "\n\n" + generate(pagesType).code;
+  return { filename: filename2, content };
+}
+function generateRoutes(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+routes-pre.ts");
+  const routesType = t2.tsTypeAliasDeclaration(
+    t2.identifier("routesPre"),
+    null,
+    t2.tsTypeLiteral(
+      Object.values(ctx.config.routes).map((route) => {
+        return t2.tsPropertySignature(
+          t2.stringLiteral(route.id),
+          t2.tsTypeAnnotation(
+            t2.tsTypeLiteral([
+              t2.tsPropertySignature(
+                t2.identifier("parentId"),
+                t2.tsTypeAnnotation(
+                  route.parentId ? t2.tsLiteralType(t2.stringLiteral(route.parentId)) : t2.tsUndefinedKeyword()
+                )
+              ),
+              t2.tsPropertySignature(
+                t2.identifier("path"),
+                t2.tsTypeAnnotation(
+                  route.path ? t2.tsLiteralType(t2.stringLiteral(route.path)) : t2.tsUndefinedKeyword()
+                )
+              ),
+              t2.tsPropertySignature(
+                t2.identifier("params"),
+                t2.tsTypeAnnotation(paramsType(route.path ?? ""))
+              ),
+              t2.tsPropertySignature(
+                t2.identifier("index"),
+                t2.tsTypeAnnotation(
+                  t2.tsLiteralType(t2.booleanLiteral(route.index ?? false))
+                )
+              ),
+              t2.tsPropertySignature(
+                t2.identifier("file"),
+                t2.tsTypeAnnotation(t2.tsLiteralType(t2.stringLiteral(route.file)))
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+  const content = import_dedent.default`
+      // Generated by React Router
 
-      export type HeadersArgs = T.HeadersArgs
-      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
+      import "react-router"
 
-      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>
+      declare module "react-router" {
+        interface Register {
+          routesPre: routesPre
+        }
+      }
+    ` + "\n\n" + generate(routesType).code;
+  return { filename: filename2, content };
+}
+function generateRouteModuleAnnotations(ctx) {
+  return Object.values(ctx.config.routes).map((route) => {
+    const filename2 = getRouteModuleAnnotationsFilepath(ctx, route);
+    const parents = getParents(ctx, route);
+    const content = import_dedent.default`
+      // Generated by React Router
 
-      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Info>
-      export type ComponentProps = T.CreateComponentProps<Info>
-      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Info>
-    }
-  `;
+      import type {
+        Params,
+        RouteModuleAnnotations,
+        CreateLoaderData,
+        CreateActionData,
+      } from "react-router/internal";
+
+      ${parents.map((parent) => parent.import).join("\n" + "  ".repeat(3))}
+      type Parents = [${parents.map((parent) => parent.name).join(", ")}]
+
+      type Id = "${route.id}"
+      type Module = typeof import("../${Pathe.filename(route.file)}.js")
+
+      export type unstable_Props = {
+        params: Params[Id]
+        loaderData: CreateLoaderData<Module>
+        actionData: CreateActionData<Module>
+      }
+
+      type Annotations = RouteModuleAnnotations<unstable_Props & {
+        parents: Parents,
+        module: Module,
+      }>;
+
+      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 };
+  });
+}
+function getRouteModuleAnnotationsFilepath(ctx, route) {
+  return Path3.join(
+    typesDirectory(ctx),
+    Path3.relative(ctx.rootDirectory, ctx.config.appDirectory),
+    Path3.dirname(route.file),
+    "+types/" + Pathe.filename(route.file) + ".ts"
+  );
 }
-function formatParamProperties(fullpath2) {
-  const params = parse2(fullpath2);
-  const properties = Object.entries(params).map(
-    ([name, isRequired]) => isRequired ? `"${name}": string` : `"${name}"?: string`
+function getParents(ctx, route) {
+  const typesPath = getRouteModuleAnnotationsFilepath(ctx, route);
+  const lineage2 = lineage(ctx.config.routes, route);
+  const parents = lineage2.slice(0, -1);
+  return parents.map((parent, i) => {
+    const rel = Path3.relative(
+      Path3.dirname(typesPath),
+      getRouteModuleAnnotationsFilepath(ctx, parent)
+    );
+    let source = noExtension(rel);
+    if (!source.startsWith("../")) source = "./" + source;
+    const name = `Parent${i}`;
+    return {
+      name,
+      import: `import type { unstable_Props as ${name} } from "${source}.js"`
+    };
+  });
+}
+function noExtension(path8) {
+  return Path3.join(Path3.dirname(path8), Pathe.filename(path8));
+}
+function paramsType(path8) {
+  const params = parse2(path8);
+  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;
+    })
   );
-  return properties.join("; ");
 }
-var import_dedent, Path4, Pathe2, noExtension;
+var import_dedent, Path3, Pathe, t2;
 var init_generate = __esm({
   "typegen/generate.ts"() {
     "use strict";
     import_dedent = __toESM(require("dedent"));
-    Path4 = __toESM(require("pathe"));
-    Pathe2 = __toESM(require("pathe/utils"));
-    init_paths();
+    Path3 = __toESM(require("pathe"));
+    Pathe = __toESM(require("pathe/utils"));
+    init_babel();
     init_params();
     init_route();
-    noExtension = (path8) => Path4.join(Path4.dirname(path8), Pathe2.filename(path8));
+    ({ t: t2 } = babel_exports);
   }
 });
 
 // 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 run(rootDirectory, { mode }) {
   const ctx = await createContext2({ rootDirectory, mode, watch: false });
-  await writeAll(ctx);
+  await clearRouteModuleAnnotations(ctx);
+  await write(
+    generateFuture(ctx),
+    generatePages(ctx),
+    generateRoutes(ctx),
+    generateServerBuild(ctx),
+    ...generateRouteModuleAnnotations(ctx)
+  );
 }
 async function watch(rootDirectory, { mode, logger }) {
   const ctx = await createContext2({ rootDirectory, mode, watch: true });
-  await writeAll(ctx);
-  logger?.info(import_picocolors3.default.green("generated types"), { timestamp: true, clear: true });
+  await clearRouteModuleAnnotations(ctx);
+  await write(
+    generateFuture(ctx),
+    generatePages(ctx),
+    generateRoutes(ctx),
+    generateServerBuild(ctx),
+    ...generateRouteModuleAnnotations(ctx)
+  );
+  logger?.info((0, import_picocolors3.green)("generated types"), { timestamp: true, clear: true });
   ctx.configLoader.onChange(
     async ({ result, configChanged, routeConfigChanged }) => {
       if (!result.ok) {
-        logger?.error(import_picocolors3.default.red(result.error), { timestamp: true, clear: true });
+        logger?.error((0, import_picocolors3.red)(result.error), { timestamp: true, clear: true });
         return;
       }
       ctx.config = result.value;
-      if (configChanged || routeConfigChanged) {
-        await writeAll(ctx);
-        logger?.info(import_picocolors3.default.green("regenerated types"), {
+      if (configChanged) {
+        await write(generateFuture(ctx));
+        logger?.info((0, import_picocolors3.green)("regenerated types"), {
+          timestamp: true,
+          clear: true
+        });
+      }
+      if (routeConfigChanged) {
+        await clearRouteModuleAnnotations(ctx);
+        await write(
+          generatePages(ctx),
+          generateRoutes(ctx),
+          ...generateRouteModuleAnnotations(ctx)
+        );
+        logger?.info((0, import_picocolors3.green)("regenerated types"), {
           timestamp: true,
           clear: true
         });
@@ -976,116 +1207,15 @@ 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_fs3.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_fs3.default.mkdirSync(Path5.dirname(typesPath), { recursive: true });
-    import_node_fs3.default.writeFileSync(typesPath, content);
-  });
-  const registerPath = Path5.join(typegenDir, "+register.ts");
-  import_node_fs3.default.writeFileSync(registerPath, register(ctx));
-  const virtualPath = Path5.join(typegenDir, "+virtual.d.ts");
-  import_node_fs3.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 import_node_fs3, import_dedent2, Path5, import_picocolors3, virtual;
+var import_promises, Path4, import_picocolors3;
 var init_typegen = __esm({
   "typegen/index.ts"() {
     "use strict";
-    import_node_fs3 = __toESM(require("fs"));
-    import_dedent2 = __toESM(require("dedent"));
-    Path5 = __toESM(require("pathe"));
-    import_picocolors3 = __toESM(require("picocolors"));
-    init_config();
-    init_babel();
+    import_promises = __toESM(require("fs/promises"));
+    Path4 = __toESM(require("pathe"));
+    import_picocolors3 = require("picocolors");
+    init_context();
     init_generate();
-    init_paths();
-    init_params();
-    init_route();
-    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"];
-  }
-`;
   }
 });
 
@@ -1214,11 +1344,11 @@ var init_route_chunks = __esm({
 });
 
 // vite/with-props.ts
-var import_dedent3, vmod;
+var import_dedent2, vmod;
 var init_with_props = __esm({
   "vite/with-props.ts"() {
     "use strict";
-    import_dedent3 = __toESM(require("dedent"));
+    import_dedent2 = __toESM(require("dedent"));
     init_babel();
     init_virtual_module();
     vmod = create("with-props");
@@ -1366,7 +1496,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
@@ -1457,7 +1587,7 @@ function resolveEnvironmentsOptions(environmentResolvers, resolverOptions) {
 function isNonNullable(x) {
   return x != null;
 }
-var import_node_crypto, fs4, path6, url, fse, babel2, import_react_router2, import_es_module_lexer, import_pick3, import_jsesc, import_picocolors4, import_kebabCase, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS, BUILD_CLIENT_ROUTE_QUERY_STRING, SSR_BUNDLE_PREFIX, virtualHmrRuntime, virtualInjectHmrRuntime, virtual2, getServerBuildDirectory, getClientBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER;
+var import_node_crypto, fs4, path6, url, fse, babel2, import_react_router2, import_es_module_lexer, import_pick3, import_jsesc, import_picocolors4, import_kebabCase, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS, BUILD_CLIENT_ROUTE_QUERY_STRING, SSR_BUNDLE_PREFIX, virtualHmrRuntime, virtualInjectHmrRuntime, virtual, getServerBuildDirectory, getClientBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER;
 var init_plugin = __esm({
   "vite/plugin.ts"() {
     "use strict";
@@ -1507,7 +1637,7 @@ var init_plugin = __esm({
     SSR_BUNDLE_PREFIX = "ssrBundle_";
     virtualHmrRuntime = create("hmr-runtime");
     virtualInjectHmrRuntime = create("inject-hmr-runtime");
-    virtual2 = {
+    virtual = {
       serverBuild: create("server-build"),
       serverManifest: create("server-manifest"),
       browserManifest: create("browser-manifest")
@@ -1524,7 +1654,7 @@ var init_plugin = __esm({
       "config",
       "defaults"
     );
-    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path6.join(defaultEntriesDir, filename3));
+    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path6.join(defaultEntriesDir, filename2));
     invariant(defaultEntries.length > 0, "No default entries found");
     REACT_REFRESH_HEADER = `
 import RefreshRuntime from "${virtualHmrRuntime.id}";
@@ -2009,8 +2139,8 @@ async function checkForEntry(rootDirectory, appDirectory, entries2) {
     let entryPath = path7.resolve(appDirectory, entry);
     let exists = await import_fs_extra.default.pathExists(entryPath);
     if (exists) {
-      let relative8 = path7.relative(rootDirectory, entryPath);
-      console.error(import_picocolors7.default.red(`Entry file ${relative8} already exists.`));
+      let relative7 = path7.relative(rootDirectory, entryPath);
+      console.error(import_picocolors7.default.red(`Entry file ${relative7} already exists.`));
       return process.exit(1);
     }
   }