vite-plugin-vercel 0.1.2 → 0.1.5

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { ResolvedConfig, Plugin } from 'vite';
 import { StdinOptions, BuildOptions } from 'esbuild';
 import { z } from 'zod';
+import { VercelConfig } from '@vercel/routing-utils';
 
 /**
  * Schema definition for `.vercel/output/config.json`
@@ -513,6 +514,12 @@ declare const vercelOutputPrerenderConfigSchema: z.ZodObject<{
 }>;
 declare type VercelOutputPrerenderConfig = z.infer<typeof vercelOutputPrerenderConfigSchema>;
 
+declare type ViteVercelRewrite = NonNullable<VercelConfig['rewrites']>[number] & {
+    enforce?: 'pre' | 'post';
+};
+declare type ViteVercelRedirect = NonNullable<VercelConfig['redirects']>[number] & {
+    enforce?: 'pre' | 'post';
+};
 interface ViteVercelConfig {
     /**
      * How long Functions should be allowed to run for every request in seconds.
@@ -552,6 +559,10 @@ interface ViteVercelConfig {
      * }
      * ```
      */
+    rewrites?: ViteVercelRewrite[];
+    redirects?: ViteVercelRedirect[];
+    cleanUrls?: VercelConfig['cleanUrls'];
+    trailingSlash?: VercelConfig['trailingSlash'];
     additionalEndpoints?: ViteVercelApiEntry[];
     /**
      * Advanced configuration to override .vercel/output/config.json
@@ -581,7 +592,7 @@ interface ViteVercelConfig {
      */
     isr?: Record<string, VercelOutputIsr> | (() => Promise<Record<string, VercelOutputIsr>> | Record<string, VercelOutputIsr>);
     /**
-     * Defaults to `.vercel/output`. Mostly useful for testing prupose
+     * Defaults to `.vercel/output`. Mostly useful for testing purpose
      * @protected
      */
     outDir?: string;
@@ -608,8 +619,17 @@ interface ViteVercelApiEntry {
      * Override esbuild options
      */
     buildOptions?: BuildOptions;
+    /**
+     * Automatically add a route for the function (mimics defaults Vercel behavior)
+     * Set to `false` to disable
+     */
+    addRoute?: boolean;
+    /**
+     * Set to `true` to mark this function as an Edge Function
+     */
+    edge?: boolean;
 }
 
 declare function allPlugins(): Plugin[];
 
-export { VercelOutputConfig, VercelOutputIsr, VercelOutputPrerenderConfig, VercelOutputVcConfig, ViteVercelApiEntry, ViteVercelConfig, ViteVercelPrerenderFn, ViteVercelPrerenderRoute, allPlugins as default };
+export { VercelOutputConfig, VercelOutputIsr, VercelOutputPrerenderConfig, VercelOutputVcConfig, ViteVercelApiEntry, ViteVercelConfig, ViteVercelPrerenderFn, ViteVercelPrerenderRoute, ViteVercelRedirect, ViteVercelRewrite, allPlugins as default };

package/dist/index.js

@@ -1,67 +1,26 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-
 // src/index.ts
-import fs5 from "fs/promises";
+import fs4 from "fs/promises";
 
 // src/utils.ts
 import { normalizePath } from "vite";
 import path from "path";
-import fs from "fs/promises";
 function getRoot(config) {
   return normalizePath(config.root || process.cwd());
 }
-function getOutDir(config, force) {
-  const p = normalizePath(config.build.outDir);
-  if (!force)
-    return p;
-  return path.join(path.dirname(p), force);
-}
 function getOutput(config, suffix) {
   var _a, _b;
-  return path.join(((_a = config.vercel) == null ? void 0 : _a.outDir) ? "" : getRoot(config), ((_b = config.vercel) == null ? void 0 : _b.outDir) ?? ".vercel/output", suffix ?? "");
+  return path.join(
+    ((_a = config.vercel) == null ? void 0 : _a.outDir) ? "" : getRoot(config),
+    ((_b = config.vercel) == null ? void 0 : _b.outDir) ?? ".vercel/output",
+    suffix ?? ""
+  );
 }
-function pathRelativeToApi(filePath, config) {
-  const root = getRoot(config);
-  return normalizePath(path.relative(path.join(root, "api"), filePath));
+function getPublic(config) {
+  return path.join(getRoot(config), config.publicDir || "public");
 }
-async function copyDir(src, dest) {
-  await fs.mkdir(dest, { recursive: true });
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    entry.isDirectory() ? await copyDir(srcPath, destPath) : await fs.copyFile(srcPath, destPath);
-  }
+function pathRelativeTo(filePath, config, rel) {
+  const root = getRoot(config);
+  return normalizePath(path.relative(path.join(root, rel), filePath));
 }
 
 // src/config.ts
@@ -69,60 +28,64 @@ import path2 from "path";
 
 // src/schemas/config/config.ts
 import { z } from "zod";
-var HasOrMissing = z.array(z.union([
-  z.object({
-    type: z.literal("host"),
-    value: z.string()
-  }).strict(),
-  z.object({
-    type: z.literal("header"),
-    key: z.string(),
-    value: z.string().optional()
-  }).strict(),
-  z.object({
-    type: z.literal("cookie"),
-    key: z.string(),
-    value: z.string().optional()
-  }).strict(),
-  z.object({
-    type: z.literal("query"),
-    key: z.string(),
-    value: z.string().optional()
-  }).strict()
-])).optional();
-var vercelOutputConfigSchema = z.object({
-  version: z.literal(3),
-  routes: z.array(z.union([
+var HasOrMissing = z.array(
+  z.union([
+    z.object({
+      type: z.literal("host"),
+      value: z.string()
+    }).strict(),
     z.object({
-      src: z.string(),
-      dest: z.string().optional(),
-      headers: z.record(z.string()).optional(),
-      methods: z.array(z.string()).optional(),
-      status: z.number().int().positive().optional(),
-      continue: z.boolean().optional(),
-      check: z.boolean().optional(),
-      missing: HasOrMissing,
-      has: HasOrMissing,
-      locale: z.object({
-        redirect: z.record(z.string()).optional(),
-        cookie: z.string().optional()
-      }).strict().optional(),
-      middlewarePath: z.string().optional()
+      type: z.literal("header"),
+      key: z.string(),
+      value: z.string().optional()
     }).strict(),
     z.object({
-      handle: z.union([
-        z.literal("rewrite"),
-        z.literal("filesystem"),
-        z.literal("resource"),
-        z.literal("miss"),
-        z.literal("hit"),
-        z.literal("error")
-      ]),
-      src: z.string().optional(),
-      dest: z.string().optional(),
-      status: z.number().optional()
+      type: z.literal("cookie"),
+      key: z.string(),
+      value: z.string().optional()
+    }).strict(),
+    z.object({
+      type: z.literal("query"),
+      key: z.string(),
+      value: z.string().optional()
     }).strict()
-  ])).optional(),
+  ])
+).optional();
+var vercelOutputConfigSchema = z.object({
+  version: z.literal(3),
+  routes: z.array(
+    z.union([
+      z.object({
+        src: z.string(),
+        dest: z.string().optional(),
+        headers: z.record(z.string()).optional(),
+        methods: z.array(z.string()).optional(),
+        status: z.number().int().positive().optional(),
+        continue: z.boolean().optional(),
+        check: z.boolean().optional(),
+        missing: HasOrMissing,
+        has: HasOrMissing,
+        locale: z.object({
+          redirect: z.record(z.string()).optional(),
+          cookie: z.string().optional()
+        }).strict().optional(),
+        middlewarePath: z.string().optional()
+      }).strict(),
+      z.object({
+        handle: z.union([
+          z.literal("rewrite"),
+          z.literal("filesystem"),
+          z.literal("resource"),
+          z.literal("miss"),
+          z.literal("hit"),
+          z.literal("error")
+        ]),
+        src: z.string().optional(),
+        dest: z.string().optional(),
+        status: z.number().optional()
+      }).strict()
+    ])
+  ).optional(),
   images: z.object({
     sizes: z.tuple([
       z.number().int().positive(),
@@ -134,43 +97,79 @@ var vercelOutputConfigSchema = z.object({
     dangerouslyAllowSVG: z.boolean().optional(),
     contentSecurityPolicy: z.string().optional()
   }).strict().optional(),
-  wildcard: z.array(z.object({
-    domain: z.string(),
-    value: z.string()
-  }).strict()).optional(),
-  overrides: z.record(z.object({
-    path: z.string().optional(),
-    contentType: z.string().optional()
-  }).strict()).optional(),
+  wildcard: z.array(
+    z.object({
+      domain: z.string(),
+      value: z.string()
+    }).strict()
+  ).optional(),
+  overrides: z.record(
+    z.object({
+      path: z.string().optional(),
+      contentType: z.string().optional()
+    }).strict()
+  ).optional(),
   cache: z.array(z.string()).optional()
 }).strict();
 
 // src/config.ts
-import fs2 from "fs/promises";
+import fs from "fs/promises";
 import { getTransformedRoutes } from "@vercel/routing-utils";
-function getConfig(resolvedConfig, config) {
-  var _a, _b, _c, _d, _e;
-  const { routes } = getTransformedRoutes({
+function reorderEnforce(arr) {
+  return [
+    ...arr.filter((r) => r.enforce === "pre"),
+    ...arr.filter((r) => !r.enforce),
+    ...arr.filter((r) => r.enforce === "post")
+  ];
+}
+function getConfig(resolvedConfig, rewrites, overrides) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const _rewrites = [
+    ...((_a = resolvedConfig.vercel) == null ? void 0 : _a.rewrites) ?? [],
+    ...rewrites ?? []
+  ];
+  const { routes, error } = getTransformedRoutes({
     nowConfig: {
-      cleanUrls: true
+      cleanUrls: ((_b = resolvedConfig.vercel) == null ? void 0 : _b.cleanUrls) ?? true,
+      trailingSlash: (_c = resolvedConfig.vercel) == null ? void 0 : _c.trailingSlash,
+      rewrites: reorderEnforce(_rewrites),
+      redirects: ((_d = resolvedConfig.vercel) == null ? void 0 : _d.redirects) ? reorderEnforce((_e = resolvedConfig.vercel) == null ? void 0 : _e.redirects) : void 0
     }
   });
-  return vercelOutputConfigSchema.parse(__spreadProps(__spreadValues({
-    version: 3
-  }, (_a = resolvedConfig.vercel) == null ? void 0 : _a.config), {
+  if (error) {
+    throw error;
+  }
+  if (((_g = (_f = resolvedConfig.vercel) == null ? void 0 : _f.config) == null ? void 0 : _g.routes) && resolvedConfig.vercel.config.routes.length > 0) {
+    console.warn(
+      "It is discouraged to use `vercel.config.routes` to override routes. Prefer using `vercel.rewrites` and `vercel.redirects`."
+    );
+  }
+  return vercelOutputConfigSchema.parse({
+    version: 3,
+    ...(_h = resolvedConfig.vercel) == null ? void 0 : _h.config,
     routes: [
       ...routes ?? [],
-      ...(config == null ? void 0 : config.routes) ?? [],
-      ...((_c = (_b = resolvedConfig.vercel) == null ? void 0 : _b.config) == null ? void 0 : _c.routes) ?? []
+      ...((_j = (_i = resolvedConfig.vercel) == null ? void 0 : _i.config) == null ? void 0 : _j.routes) ?? []
     ],
-    overrides: __spreadValues(__spreadValues({}, (_e = (_d = resolvedConfig.vercel) == null ? void 0 : _d.config) == null ? void 0 : _e.overrides), config == null ? void 0 : config.overrides)
-  }));
+    overrides: {
+      ...(_l = (_k = resolvedConfig.vercel) == null ? void 0 : _k.config) == null ? void 0 : _l.overrides,
+      ...overrides
+    }
+  });
 }
 function getConfigDestination(resolvedConfig) {
   return path2.join(getOutput(resolvedConfig), "config.json");
 }
-async function writeConfig(resolvedConfig, config) {
-  await fs2.writeFile(getConfigDestination(resolvedConfig), JSON.stringify(getConfig(resolvedConfig, config), void 0, 2), "utf-8");
+async function writeConfig(resolvedConfig, rewrites, overrides) {
+  await fs.writeFile(
+    getConfigDestination(resolvedConfig),
+    JSON.stringify(
+      getConfig(resolvedConfig, rewrites, overrides),
+      void 0,
+      2
+    ),
+    "utf-8"
+  );
 }
 
 // src/build.ts
@@ -217,23 +216,35 @@ var vercelOutputVcConfigSchema = z2.union([
 ]);
 
 // src/build.ts
-import fs3 from "fs/promises";
+import fs2 from "fs/promises";
 function getAdditionalEndpoints(resolvedConfig) {
   var _a;
-  return (((_a = resolvedConfig.vercel) == null ? void 0 : _a.additionalEndpoints) ?? []).map((e) => __spreadProps(__spreadValues({}, e), {
-    destination: e.destination + ".func"
+  return (((_a = resolvedConfig.vercel) == null ? void 0 : _a.additionalEndpoints) ?? []).map((e) => ({
+    ...e,
+    addRoute: e.addRoute ?? true,
+    destination: path3.resolve("/", e.destination) + ".func"
   }));
 }
 function getEntries(resolvedConfig) {
   const apiEntries = glob.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !path3.basename(filepath).startsWith("_"));
-  return apiEntries.reduce((entryPoints, filePath) => {
-    const outFilePath = pathRelativeToApi(filePath, resolvedConfig);
+  if (apiEntries.length > 0) {
+    console.warn(
+      "@vercel/build is currently force building /api files itself, with no way to disable it. In order to avoid double compilation, you should temporarily rename /api to /_api while using this plugin. /_api functions are compiled under .vercel/output/functions/api/*.func as if they were in /api."
+    );
+  }
+  const otherApiEntries = glob.sync(`${getRoot(resolvedConfig)}/_api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !path3.basename(filepath).startsWith("_"));
+  return [...apiEntries, ...otherApiEntries].reduce((entryPoints, filePath) => {
+    const outFilePath = pathRelativeTo(
+      filePath,
+      resolvedConfig,
+      filePath.includes("/_api/") ? "_api" : "api"
+    );
     const parsed = path3.parse(outFilePath);
-    const entry = {
+    entryPoints.push({
       source: filePath,
-      destination: `api/${path3.posix.join(parsed.dir, parsed.name)}.func`
-    };
-    entryPoints.push(entry);
+      destination: `api/${path3.posix.join(parsed.dir, parsed.name)}.func`,
+      addRoute: true
+    });
     return entryPoints;
   }, getAdditionalEndpoints(resolvedConfig));
 }
@@ -246,8 +257,15 @@ var standardBuildOptions = {
   minify: true
 };
 async function buildFn(resolvedConfig, entry, buildOptions) {
-  assert(entry.destination.length > 0, `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`);
-  const outfile = path3.join(getOutput(resolvedConfig, "functions"), entry.destination, "index.js");
+  assert(
+    entry.destination.length > 0,
+    `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`
+  );
+  const outfile = path3.join(
+    getOutput(resolvedConfig, "functions"),
+    entry.destination,
+    "index.js"
+  );
   const options = Object.assign({}, standardBuildOptions, { outfile });
   if (buildOptions) {
     Object.assign(options, buildOptions);
@@ -256,30 +274,63 @@ async function buildFn(resolvedConfig, entry, buildOptions) {
     if (typeof entry.source === "string") {
       options.entryPoints = [entry.source];
     } else {
-      assert(typeof entry.source === "object", `\`{ source }\` must be a string or an object`);
-      assert(typeof entry.source.contents === "string", `\`{ contents }\` must be a string`);
+      assert(
+        typeof entry.source === "object",
+        `\`{ source }\` must be a string or an object`
+      );
+      assert(
+        typeof entry.source.contents === "string",
+        `\`{ contents }\` must be a string`
+      );
       options.stdin = entry.source;
     }
   }
   await build(options);
-  await writeVcConfig(resolvedConfig, entry.destination);
+  await writeVcConfig(resolvedConfig, entry.destination, Boolean(entry.edge));
 }
-async function writeVcConfig(resolvedConfig, destination) {
+async function writeVcConfig(resolvedConfig, destination, edge) {
   var _a;
-  const vcConfig = path3.join(getOutput(resolvedConfig, "functions"), destination, ".vc-config.json");
-  await fs3.writeFile(vcConfig, JSON.stringify(vercelOutputVcConfigSchema.parse({
-    runtime: "nodejs16.x",
-    handler: "index.js",
-    maxDuration: (_a = resolvedConfig.vercel) == null ? void 0 : _a.defaultMaxDuration,
-    launcherType: "Nodejs",
-    shouldAddHelpers: true
-  }), void 0, 2), "utf-8");
+  const vcConfig = path3.join(
+    getOutput(resolvedConfig, "functions"),
+    destination,
+    ".vc-config.json"
+  );
+  await fs2.writeFile(
+    vcConfig,
+    JSON.stringify(
+      vercelOutputVcConfigSchema.parse(
+        edge ? {
+          runtime: "edge",
+          entrypoint: "index.js"
+        } : {
+          runtime: "nodejs16.x",
+          handler: "index.js",
+          maxDuration: (_a = resolvedConfig.vercel) == null ? void 0 : _a.defaultMaxDuration,
+          launcherType: "Nodejs",
+          shouldAddHelpers: true
+        }
+      ),
+      void 0,
+      2
+    ),
+    "utf-8"
+  );
+}
+function getSourceAndDestination(destination) {
+  if (destination.startsWith("api/")) {
+    return path3.posix.resolve("/", destination);
+  }
+  return path3.posix.resolve("/", destination, ":match*");
 }
 async function buildEndpoints(resolvedConfig) {
   const entries = getEntries(resolvedConfig);
   for (const entry of entries) {
     await buildFn(resolvedConfig, entry);
   }
+  return entries.filter((e) => e.addRoute !== false).map((e) => e.destination.replace(/\.func$/, "")).map((destination) => ({
+    source: getSourceAndDestination(destination),
+    destination: getSourceAndDestination(destination)
+  }));
 }
 
 // src/prerender.ts
@@ -296,7 +347,7 @@ var vercelOutputPrerenderConfigSchema = z3.object({
 }).strict();
 
 // src/prerender.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 function execPrerender(resolvedConfig) {
   var _a;
   const prerender = (_a = resolvedConfig.vercel) == null ? void 0 : _a.prerender;
@@ -308,40 +359,76 @@ function execPrerender(resolvedConfig) {
 var group = 1;
 async function writePrerenderConfig(resolvedConfig, destination, isr) {
   const parsed = path4.parse(destination);
-  const outfile = path4.join(getOutput(resolvedConfig, "functions"), parsed.dir, parsed.name + ".prerender-config.json");
-  await fs4.mkdir(path4.join(getOutput(resolvedConfig, "functions"), parsed.dir), { recursive: true });
-  await fs4.writeFile(outfile, JSON.stringify(vercelOutputPrerenderConfigSchema.parse(__spreadValues({
-    group: group++
-  }, isr)), void 0, 2), "utf-8");
+  const outfile = path4.join(
+    getOutput(resolvedConfig, "functions"),
+    parsed.dir,
+    parsed.name + ".prerender-config.json"
+  );
+  await fs3.mkdir(
+    path4.join(getOutput(resolvedConfig, "functions"), parsed.dir),
+    { recursive: true }
+  );
+  await fs3.writeFile(
+    outfile,
+    JSON.stringify(
+      vercelOutputPrerenderConfigSchema.parse({
+        group: group++,
+        ...isr
+      }),
+      void 0,
+      2
+    ),
+    "utf-8"
+  );
 }
 function getPrerenderSymlinkInfo(resolvedConfig, destination, target) {
   const parsed = path4.parse(destination);
   const targetParsed = path4.parse(target);
   return {
-    target: path4.join(getOutput(resolvedConfig, "functions"), targetParsed.dir, targetParsed.name + ".func"),
-    link: path4.join(getOutput(resolvedConfig, "functions"), parsed.dir, parsed.name + ".func")
+    target: path4.join(
+      getOutput(resolvedConfig, "functions"),
+      targetParsed.dir,
+      targetParsed.name + ".func"
+    ),
+    link: path4.join(
+      getOutput(resolvedConfig, "functions"),
+      parsed.dir,
+      parsed.name + ".func"
+    )
   };
 }
 async function buildPrerenderConfigs(resolvedConfig) {
   const isr = await getIsrConfig(resolvedConfig);
   const entries = Object.entries(isr);
   const rewrites = [];
-  for (const _a of entries) {
-    const [destination, _b] = _a, _c = _b, { symlink, route } = _c, isr2 = __objRest(_c, ["symlink", "route"]);
+  for (const [destination, { symlink, route, ...isr2 }] of entries) {
     await writePrerenderConfig(resolvedConfig, destination, isr2);
     if (symlink) {
-      const info = getPrerenderSymlinkInfo(resolvedConfig, destination, symlink);
+      const info = getPrerenderSymlinkInfo(
+        resolvedConfig,
+        destination,
+        symlink
+      );
       await copyDir(info.target, info.link);
     }
     if (route) {
       rewrites.push({
-        src: `(${route})`,
-        dest: `${destination}/?__original_path=$1`
+        source: `(${route})`,
+        destination: `${destination}/?__original_path=$1`
       });
     }
   }
   return rewrites;
 }
+async function copyDir(src, dest) {
+  await fs3.mkdir(dest, { recursive: true });
+  const entries = await fs3.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    entry.isDirectory() ? await copyDir(srcPath, destPath) : await fs3.copyFile(srcPath, destPath);
+  }
+}
 async function getIsrConfig(resolvedConfig) {
   var _a;
   const isr = ((_a = resolvedConfig.vercel) == null ? void 0 : _a.isr) ?? {};
@@ -364,41 +451,42 @@ function vercelPlugin() {
     },
     async buildStart() {
       if (process.env.VERCEL_ENV === "production" && !process.env.ENABLE_VC_BUILD) {
-        throw new Error("Missing ENABLE_VC_BUILD=1 to your environment variables in your project settings");
-      }
-      if (!resolvedConfig.build.ssr) {
-        await cleanOutputDirectory(resolvedConfig);
-      } else {
-        await copyDistClientToOutputStatic(resolvedConfig);
+        throw new Error(
+          "Missing ENABLE_VC_BUILD=1 to your environment variables in your project settings"
+        );
       }
     },
     async writeBundle() {
       var _a;
-      if (!((_a = resolvedConfig.build) == null ? void 0 : _a.ssr))
+      if (!((_a = resolvedConfig.build) == null ? void 0 : _a.ssr)) {
+        await cleanOutputDirectory(resolvedConfig);
         return;
-      const userOverrides = await computeStaticHtmlOverrides(resolvedConfig);
+      }
       const overrides = await execPrerender(resolvedConfig);
-      await buildEndpoints(resolvedConfig);
-      const rewrites = await buildPrerenderConfigs(resolvedConfig);
-      await writeConfig(resolvedConfig, {
-        routes: [{ handle: "filesystem" }, ...rewrites],
-        overrides: __spreadValues(__spreadValues({}, userOverrides), overrides)
+      const userOverrides = await computeStaticHtmlOverrides(resolvedConfig);
+      const rewrites = await buildEndpoints(resolvedConfig);
+      rewrites.push(...await buildPrerenderConfigs(resolvedConfig));
+      await writeConfig(resolvedConfig, rewrites, {
+        ...userOverrides,
+        ...overrides
       });
     }
   };
 }
-async function copyDistClientToOutputStatic(resolvedConfig) {
-  await copyDir(getOutDir(resolvedConfig, "client"), getOutput(resolvedConfig, "static"));
-}
 async function cleanOutputDirectory(resolvedConfig) {
-  await fs5.rm(getOutput(resolvedConfig), {
+  await fs4.rm(getOutput(resolvedConfig), {
     recursive: true,
     force: true
   });
 }
 async function computeStaticHtmlOverrides(resolvedConfig) {
   const staticAbsolutePath = getOutput(resolvedConfig, "static");
-  const files = await getStaticHtmlFiles(resolvedConfig, staticAbsolutePath);
+  const files = await getStaticHtmlFiles(staticAbsolutePath);
+  const publicDir = getPublic(resolvedConfig);
+  const publicFiles = await getStaticHtmlFiles(publicDir);
+  files.push(
+    ...publicFiles.map((f) => f.replace(publicDir, staticAbsolutePath))
+  );
   return files.reduce((acc, curr) => {
     const relPath = path5.relative(staticAbsolutePath, curr);
     const parsed = path5.parse(relPath);
@@ -409,12 +497,17 @@ async function computeStaticHtmlOverrides(resolvedConfig) {
     return acc;
   }, {});
 }
-async function getStaticHtmlFiles(resolvedConfig, src) {
-  const entries = await fs5.readdir(src, { withFileTypes: true });
+async function getStaticHtmlFiles(src) {
+  try {
+    await fs4.stat(src);
+  } catch (e) {
+    return [];
+  }
+  const entries = await fs4.readdir(src, { withFileTypes: true });
   const htmlFiles = [];
   for (const entry of entries) {
     const srcPath = path5.join(src, entry.name);
-    entry.isDirectory() ? htmlFiles.push(...await getStaticHtmlFiles(resolvedConfig, srcPath)) : srcPath.endsWith(".html") ? htmlFiles.push(srcPath) : void 0;
+    entry.isDirectory() ? htmlFiles.push(...await getStaticHtmlFiles(srcPath)) : srcPath.endsWith(".html") ? htmlFiles.push(srcPath) : void 0;
   }
   return htmlFiles;
 }