one 1.14.4 → 1.15.0

package/dist/esm/cli/build.mjs

@@ -28,309 +28,388 @@ const {
   writeJSON
 } = FSExtra;
 function normalizeDeploy(deploy) {
-  if (deploy) return typeof deploy == "string" ? {
+  if (!deploy) return void 0;
+  if (typeof deploy === "string") return {
     target: deploy
-  } : deploy;
+  };
+  return deploy;
 }
 async function getCloudflareProjectName(root) {
   try {
     const pkg = JSON.parse(await FSExtra.readFile(join(root, "package.json"), "utf-8"));
-    if (pkg.name) return pkg.name.replace(/^@[^/]+\//, "");
+    if (pkg.name) {
+      return pkg.name.replace(/^@[^/]+\//, "");
+    }
   } catch {}
   return "one-app";
 }
 process.env.ONE_CACHE_KEY = constants.CACHE_KEY;
 const BUILD_CONCURRENCY = process.env.ONE_BUILD_CONCURRENCY ? Math.max(1, parseInt(process.env.ONE_BUILD_CONCURRENCY, 10)) : Math.max(1, Math.min(cpus().length, 8));
 function shouldUseWorkers(oneOptions) {
-  return process.env.ONE_BUILD_WORKERS === "0" ? !1 : process.env.ONE_BUILD_WORKERS === "1" ? !0 : oneOptions?.build?.workers !== !1;
+  if (process.env.ONE_BUILD_WORKERS === "0") return false;
+  if (process.env.ONE_BUILD_WORKERS === "1") return true;
+  return oneOptions?.build?.workers !== false;
 }
 process.on("uncaughtException", err => {
   console.error(err?.message || err);
 });
 const HOOK_KEYS = ["resolveId", "load", "transform", "renderChunk", "generateBundle", "writeBundle", "buildStart", "buildEnd", "moduleParsed"];
 function clonePluginHooks(config) {
-  return config.plugins ? {
+  if (!config.plugins) return config;
+  return {
     ...config,
     plugins: config.plugins.map(p => {
-      if (!p || typeof p != "object") return p;
+      if (!p || typeof p !== "object") return p;
       const cloned = {
         ...p
       };
-      for (const key of HOOK_KEYS) cloned[key] && typeof cloned[key] == "object" && "handler" in cloned[key] && (cloned[key] = {
-        ...cloned[key]
-      });
+      for (const key of HOOK_KEYS) {
+        if (cloned[key] && typeof cloned[key] === "object" && "handler" in cloned[key]) {
+          cloned[key] = {
+            ...cloned[key]
+          };
+        }
+      }
       return cloned;
     })
-  } : config;
+  };
 }
 async function build(args) {
-  process.env.IS_VXRN_CLI = "true", process.env.NODE_ENV ? process.env.NODE_ENV !== "production" && console.warn(`
+  process.env.IS_VXRN_CLI = "true";
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "production";
+  } else if (process.env.NODE_ENV !== "production") {
+    console.warn(`
  \u26A0\uFE0F  Warning: NODE_ENV is set to "${process.env.NODE_ENV}" (builds default to "production")
-`) : process.env.NODE_ENV = "production", labelProcess("build"), checkNodeVersion(), setServerGlobals();
+`);
+  }
+  labelProcess("build");
+  checkNodeVersion();
+  setServerGlobals();
   const {
-      oneOptions,
-      config: viteLoadedConfig
-    } = await loadUserOneOptions("build"),
-    routerRoot = getRouterRootFromOneOptions(oneOptions);
-  oneOptions.web?.defaultRenderMode && (process.env.ONE_DEFAULT_RENDER_MODE = oneOptions.web.defaultRenderMode);
+    oneOptions,
+    config: viteLoadedConfig
+  } = await loadUserOneOptions("build");
+  const routerRoot = getRouterRootFromOneOptions(oneOptions);
+  if (oneOptions.web?.defaultRenderMode) {
+    process.env.ONE_DEFAULT_RENDER_MODE = oneOptions.web.defaultRenderMode;
+  }
   const deployConfig = normalizeDeploy(oneOptions.web?.deploy);
   if (!process.env.ONE_SERVER_URL && deployConfig) {
     const url = deployConfig.url ?? (deployConfig.target === "cloudflare" ? `https://${await getCloudflareProjectName(process.cwd())}.workers.dev` : void 0);
-    url && (process.env.ONE_SERVER_URL = url, console.info(`
+    if (url) {
+      process.env.ONE_SERVER_URL = url;
+      console.info(`
  \u2601\uFE0F ONE_SERVER_URL: ${url}
-`));
+`);
+    }
   }
-  const outDir = viteLoadedConfig?.config?.build?.outDir ?? "dist",
-    manifest = getManifest({
-      routerRoot,
-      ignoredRouteFiles: oneOptions.router?.ignoredRouteFiles
-    }),
-    serverOutputFormat = oneOptions.build?.server === !1 ? "esm" : oneOptions.build?.server?.outputFormat ?? "esm",
-    buildStartTime = performance.now(),
-    vxrnOutput = await vxrnBuild({
-      skipEnv: args.skipEnv ?? oneOptions.skipEnv,
-      server: oneOptions.server,
-      build: {
-        analyze: !0,
-        server: oneOptions.build?.server === !1 ? !1 : {
-          outputFormat: serverOutputFormat
-        }
+  const outDir = viteLoadedConfig?.config?.build?.outDir ?? "dist";
+  const manifest = getManifest({
+    routerRoot,
+    ignoredRouteFiles: oneOptions.router?.ignoredRouteFiles
+  });
+  const serverOutputFormat = oneOptions.build?.server === false ? "esm" : oneOptions.build?.server?.outputFormat ?? "esm";
+  const buildStartTime = performance.now();
+  const vxrnOutput = await vxrnBuild({
+    skipEnv: args.skipEnv ?? oneOptions.skipEnv,
+    server: oneOptions.server,
+    build: {
+      analyze: true,
+      server: oneOptions.build?.server === false ? false : {
+        outputFormat: serverOutputFormat
       }
-    }, args),
-    bundleTime = performance.now() - buildStartTime;
-  if (console.info(`
+    }
+  }, args);
+  const bundleTime = performance.now() - buildStartTime;
+  console.info(`
  \u23F1\uFE0F vite bundle: ${(bundleTime / 1e3).toFixed(2)}s
-`), !vxrnOutput || args.platform !== "web") return;
+`);
+  if (!vxrnOutput || args.platform !== "web") {
+    return;
+  }
   const options = await fillOptions(vxrnOutput.options, {
-      mode: "prod"
-    }),
-    {
-      optimizeDeps
-    } = getOptimizeDeps("build"),
-    {
-      rolldownOptions: _rolldownOptions,
-      ...optimizeDepsNoRolldown
-    } = optimizeDeps,
-    clonedWebBuildConfig = clonePluginHooks(vxrnOutput.webBuildConfig),
-    apiBuildConfig = mergeConfig(
-    // feels like this should build off the *server* build config not web
-    clonedWebBuildConfig, {
-      configFile: !1,
-      appType: "custom",
-      optimizeDeps: optimizeDepsNoRolldown,
-      environments: {
-        client: {
-          optimizeDeps: {
-            rolldownOptions: _rolldownOptions
-          }
+    mode: "prod"
+  });
+  const {
+    optimizeDeps
+  } = getOptimizeDeps("build");
+  const {
+    rolldownOptions: _rolldownOptions,
+    ...optimizeDepsNoRolldown
+  } = optimizeDeps;
+  const clonedWebBuildConfig = clonePluginHooks(vxrnOutput.webBuildConfig);
+  const apiBuildConfig = mergeConfig(
+  // feels like this should build off the *server* build config not web
+  clonedWebBuildConfig, {
+    configFile: false,
+    appType: "custom",
+    optimizeDeps: optimizeDepsNoRolldown,
+    environments: {
+      client: {
+        optimizeDeps: {
+          rolldownOptions: _rolldownOptions
         }
       }
-    });
+    }
+  });
   async function buildCustomRoutes(subFolder, routes) {
     const input = routes.reduce((entries, {
-        page,
-        file
-      }) => (entries[page.slice(1) + ".js"] = join(routerRoot, file), entries), {}),
-      outputFormat = oneOptions?.build?.api?.outputFormat ?? serverOutputFormat,
-      treeshake = oneOptions?.build?.api?.treeshake,
-      mergedConfig = mergeConfig(apiBuildConfig, {
-        appType: "custom",
-        configFile: !1,
-        // plugins: [
-        //   nodeExternals({
-        //     exclude: optimizeDeps.include,
-        //   }) as any,
-        // ],
-        define: vxrnOutput.processEnvDefines,
+      page,
+      file
+    }) => {
+      entries[page.slice(1) + ".js"] = join(routerRoot, file);
+      return entries;
+    }, {});
+    const outputFormat = oneOptions?.build?.api?.outputFormat ?? serverOutputFormat;
+    const treeshake = oneOptions?.build?.api?.treeshake;
+    const mergedConfig = mergeConfig(apiBuildConfig, {
+      appType: "custom",
+      configFile: false,
+      // plugins: [
+      //   nodeExternals({
+      //     exclude: optimizeDeps.include,
+      //   }) as any,
+      // ],
+      define: vxrnOutput.processEnvDefines,
+      ssr: {
+        noExternal: true,
+        external: ["react", "react-dom"],
+        optimizeDeps: optimizeDepsNoRolldown
+      },
+      environments: {
         ssr: {
-          noExternal: !0,
-          external: ["react", "react-dom"],
-          optimizeDeps: optimizeDepsNoRolldown
-        },
-        environments: {
-          ssr: {
-            optimizeDeps: {
-              rolldownOptions: _rolldownOptions
-            }
+          optimizeDeps: {
+            rolldownOptions: _rolldownOptions
           }
-        },
-        build: {
-          ssr: !0,
-          emptyOutDir: !1,
-          outDir: `${outDir}/${subFolder}`,
-          copyPublicDir: !1,
-          minify: !1,
-          rolldownOptions: {
-            treeshake: treeshake ?? {
-              moduleSideEffects: !1
-            },
-            plugins: [
-            // otherwise rollup is leaving commonjs-only top level imports...
-            outputFormat === "esm" ? rollupRemoveUnusedImportsPlugin : null].filter(Boolean),
-            // too many issues
-            // treeshake: {
-            //   moduleSideEffects: false,
-            // },
-            // prevents it from shaking out the exports
-            preserveEntrySignatures: "strict",
-            input,
-            external: [],
-            output: {
-              entryFileNames: "[name]",
-              exports: "auto",
-              ...(outputFormat === "esm" ? {
-                format: "esm",
-                esModule: !0
-              } : {
-                format: "cjs",
-                // Preserve folder structure and use .cjs extension
-                entryFileNames: chunkInfo => chunkInfo.name.replace(/\.js$/, ".cjs"),
-                chunkFileNames: chunkInfo => {
-                  const dir = Path.dirname(chunkInfo.name),
-                    name = Path.basename(chunkInfo.name, Path.extname(chunkInfo.name));
-                  return Path.join(dir, `${name}-[hash].cjs`);
-                },
-                assetFileNames: assetInfo => {
-                  const name = assetInfo.name ?? "",
-                    dir = Path.dirname(name),
-                    baseName = Path.basename(name, Path.extname(name)),
-                    ext = Path.extname(name);
-                  return Path.join(dir, `${baseName}-[hash]${ext}`);
-                }
-              })
-            }
+        }
+      },
+      build: {
+        ssr: true,
+        emptyOutDir: false,
+        outDir: `${outDir}/${subFolder}`,
+        copyPublicDir: false,
+        minify: false,
+        rolldownOptions: {
+          treeshake: treeshake ?? {
+            moduleSideEffects: false
+          },
+          plugins: [
+          // otherwise rollup is leaving commonjs-only top level imports...
+          outputFormat === "esm" ? rollupRemoveUnusedImportsPlugin : null].filter(Boolean),
+          // too many issues
+          // treeshake: {
+          //   moduleSideEffects: false,
+          // },
+          // prevents it from shaking out the exports
+          preserveEntrySignatures: "strict",
+          input,
+          external: [],
+          output: {
+            entryFileNames: "[name]",
+            exports: "auto",
+            ...(outputFormat === "esm" ? {
+              format: "esm",
+              esModule: true
+            } : {
+              format: "cjs",
+              // Preserve folder structure and use .cjs extension
+              entryFileNames: chunkInfo => {
+                const name = chunkInfo.name.replace(/\.js$/, ".cjs");
+                return name;
+              },
+              chunkFileNames: chunkInfo => {
+                const dir = Path.dirname(chunkInfo.name);
+                const name = Path.basename(chunkInfo.name, Path.extname(chunkInfo.name));
+                return Path.join(dir, `${name}-[hash].cjs`);
+              },
+              assetFileNames: assetInfo => {
+                const name = assetInfo.name ?? "";
+                const dir = Path.dirname(name);
+                const baseName = Path.basename(name, Path.extname(name));
+                const ext = Path.extname(name);
+                return Path.join(dir, `${baseName}-[hash]${ext}`);
+              }
+            })
           }
         }
-      }),
-      userApiBuildConf = oneOptions.build?.api?.config,
-      finalApiBuildConf = userApiBuildConf ? mergeConfig(mergedConfig, userApiBuildConf) : mergedConfig;
-    return await viteBuild(
+      }
+    });
+    const userApiBuildConf = oneOptions.build?.api?.config;
+    const finalApiBuildConf = userApiBuildConf ? mergeConfig(mergedConfig, userApiBuildConf) : mergedConfig;
+    const output = await viteBuild(
     // allow user merging api build config
     finalApiBuildConf);
+    return output;
   }
-  const builtMiddlewares = {},
-    apiPromise = manifest.apiRoutes.length ? (console.info(`
+  const builtMiddlewares = {};
+  const apiPromise = manifest.apiRoutes.length ? (console.info(`
  \u{1F528} build api routes
-`), buildCustomRoutes("api", manifest.apiRoutes)) : Promise.resolve(null),
-    middlewarePromise = manifest.middlewareRoutes.length ? (console.info(`
+`), buildCustomRoutes("api", manifest.apiRoutes)) : Promise.resolve(null);
+  const middlewarePromise = manifest.middlewareRoutes.length ? (console.info(`
  \u{1F528} build middlewares
-`), buildCustomRoutes("middlewares", manifest.middlewareRoutes)) : Promise.resolve(null),
-    [apiOutput, middlewareBuildInfo] = await Promise.all([apiPromise, middlewarePromise]);
-  if (middlewareBuildInfo) for (const middleware of manifest.middlewareRoutes) {
-    const absoluteRoot = resolve(process.cwd(), options.root),
-      fullPath = join(absoluteRoot, routerRoot, middleware.file),
-      chunk = middlewareBuildInfo.output.filter(x => x.type === "chunk").find(x => x.facadeModuleId === fullPath);
-    if (!chunk) throw new Error("internal err finding middleware");
-    builtMiddlewares[middleware.file] = join(outDir, "middlewares", chunk.fileName);
+`), buildCustomRoutes("middlewares", manifest.middlewareRoutes)) : Promise.resolve(null);
+  const [apiOutput, middlewareBuildInfo] = await Promise.all([apiPromise, middlewarePromise]);
+  if (middlewareBuildInfo) {
+    for (const middleware of manifest.middlewareRoutes) {
+      const absoluteRoot = resolve(process.cwd(), options.root);
+      const fullPath = join(absoluteRoot, routerRoot, middleware.file);
+      const outChunks = middlewareBuildInfo.output.filter(x => x.type === "chunk");
+      const chunk = outChunks.find(x => x.facadeModuleId === fullPath);
+      if (!chunk) throw new Error(`internal err finding middleware`);
+      builtMiddlewares[middleware.file] = join(outDir, "middlewares", chunk.fileName);
+    }
   }
-  globalThis.require = createRequire(join(import.meta.url, ".."));
-  const assets = [],
-    builtRoutes = [],
-    sitemapData = [],
-    collectImportsCache = /* @__PURE__ */new Map(),
-    cssFileContentsCache = /* @__PURE__ */new Map(),
-    criticalCSSOutputPaths = getCriticalCSSOutputPaths(vxrnOutput.clientManifest),
-    limit = pLimit(BUILD_CONCURRENCY),
-    useWorkers = shouldUseWorkers(oneOptions),
-    workerPool = useWorkers ? getWorkerPool(BUILD_CONCURRENCY) : null;
+  globalThis["require"] = createRequire(join(import.meta.url, ".."));
+  const assets = [];
+  const builtRoutes = [];
+  const sitemapData = [];
+  const collectImportsCache = /* @__PURE__ */new Map();
+  const cssFileContentsCache = /* @__PURE__ */new Map();
+  const criticalCSSOutputPaths = getCriticalCSSOutputPaths(vxrnOutput.clientManifest);
+  const limit = pLimit(BUILD_CONCURRENCY);
+  const useWorkers = shouldUseWorkers(oneOptions);
+  const workerPool = useWorkers ? getWorkerPool(BUILD_CONCURRENCY) : null;
   if (workerPool) {
-    const serializableOptions = JSON.parse(JSON.stringify(oneOptions, (_key, value) => typeof value == "function" ? void 0 : value));
+    const serializableOptions = JSON.parse(JSON.stringify(oneOptions, (_key, value) => typeof value === "function" ? void 0 : value));
     await workerPool.initialize(serializableOptions);
   }
-  const staticStartTime = performance.now(),
-    modeLabel = useWorkers ? `workers: ${workerPool?.size}` : `concurrency: ${BUILD_CONCURRENCY}`;
+  const staticStartTime = performance.now();
+  const modeLabel = useWorkers ? `workers: ${workerPool?.size}` : `concurrency: ${BUILD_CONCURRENCY}`;
   console.info(`
  \u{1F528} build static routes (${modeLabel})
 `);
-  const staticDir = join(`${outDir}/static`),
-    clientDir = join(`${outDir}/client`);
-  if (await ensureDir(staticDir), !vxrnOutput.serverOutput) throw new Error("No server output");
+  const staticDir = join(`${outDir}/static`);
+  const clientDir = join(`${outDir}/client`);
+  await ensureDir(staticDir);
+  if (!vxrnOutput.serverOutput) {
+    throw new Error(`No server output`);
+  }
   const clientChunksBySource = /* @__PURE__ */new Map();
-  if (vxrnOutput.clientOutput) for (const chunk of vxrnOutput.clientOutput) chunk.type === "chunk" && chunk.facadeModuleId && clientChunksBySource.set(chunk.facadeModuleId, {
-    fileName: chunk.fileName,
-    imports: chunk.imports || []
-  });
-  const outputEntries = [...vxrnOutput.serverOutput.entries()],
-    layoutServerPaths = /* @__PURE__ */new Map();
+  if (vxrnOutput.clientOutput) {
+    for (const chunk of vxrnOutput.clientOutput) {
+      if (chunk.type === "chunk" && chunk.facadeModuleId) {
+        clientChunksBySource.set(chunk.facadeModuleId, {
+          fileName: chunk.fileName,
+          imports: chunk.imports || []
+        });
+      }
+    }
+  }
+  const outputEntries = [...vxrnOutput.serverOutput.entries()];
+  const layoutServerPaths = /* @__PURE__ */new Map();
   for (const [, output] of outputEntries) {
     if (output.type === "asset") continue;
     const id = output.facadeModuleId || "";
-    if (Path.basename(id).startsWith("_layout") && id.includes(`/${routerRoot}/`)) {
-      const contextKey = `./${relative(process.cwd(), id).replace(`${routerRoot}/`, "")}`;
+    const file = Path.basename(id);
+    if (file.startsWith("_layout") && id.includes(`/${routerRoot}/`)) {
+      const relativePath = relative(process.cwd(), id).replace(`${routerRoot}/`, "");
+      const contextKey = `./${relativePath}`;
       layoutServerPaths.set(contextKey, output.fileName);
     }
   }
   const routeByPath = /* @__PURE__ */new Map();
-  for (const route of manifest.pageRoutes) if (route.file) {
-    const routePath = `${routerRoot}${route.file.slice(1)}`;
-    routeByPath.set(routePath, route);
+  for (const route of manifest.pageRoutes) {
+    if (route.file) {
+      const routePath = `${routerRoot}${route.file.slice(1)}`;
+      routeByPath.set(routePath, route);
+    }
+  }
+  for (const [, output] of outputEntries) {
+    if (output.type === "asset") {
+      assets.push(output);
+    }
   }
-  for (const [, output] of outputEntries) output.type === "asset" && assets.push(output);
   const moduleIdToServerChunk = /* @__PURE__ */new Map();
   for (const [, output] of outputEntries) {
     if (output.type === "asset") continue;
     const moduleIds = output.moduleIds || (output.facadeModuleId ? [output.facadeModuleId] : []);
-    for (const moduleId of moduleIds) moduleIdToServerChunk.set(moduleId, output.fileName);
+    for (const moduleId of moduleIds) {
+      moduleIdToServerChunk.set(moduleId, output.fileName);
+    }
   }
   for (const foundRoute of manifest.pageRoutes) {
     let collectImports = function (entry, {
       type = "js"
     } = {}) {
       const {
-          imports = [],
-          css
-        } = entry,
-        cacheKey = `${entry.file || imports.join(",")}:${type}`,
-        cached = collectImportsCache.get(cacheKey);
+        imports = [],
+        css
+      } = entry;
+      const cacheKey = `${entry.file || imports.join(",")}:${type}`;
+      const cached = collectImportsCache.get(cacheKey);
       if (cached) return cached;
       const result = [...new Set([...(type === "js" ? imports : css || []), ...imports.flatMap(name => {
         const found = vxrnOutput.clientManifest[name];
-        return found || console.warn("No found imports", name, vxrnOutput.clientManifest), collectImports(found, {
+        if (!found) {
+          console.warn(`No found imports`, name, vxrnOutput.clientManifest);
+        }
+        return collectImports(found, {
           type
         });
-      })].flat().filter(x => x && (type === "css" || x.endsWith(".js"))).map(x => type === "css" || x.startsWith("assets/") ? x : `assets/${x.slice(1)}`))];
-      return collectImportsCache.set(cacheKey, result), result;
+      })].flat().filter(x => x && (type === "css" || x.endsWith(".js"))).map(x => type === "css" ? x : x.startsWith("assets/") ? x : `assets/${x.slice(1)}`))];
+      collectImportsCache.set(cacheKey, result);
+      return result;
     };
-    if (!foundRoute.file) continue;
-    const routeModulePath = join(resolve(process.cwd(), options.root), routerRoot, foundRoute.file.slice(2)),
-      serverFileName = moduleIdToServerChunk.get(routeModulePath);
+    if (!foundRoute.file) {
+      continue;
+    }
+    const routeModulePath = join(resolve(process.cwd(), options.root), routerRoot, foundRoute.file.slice(2));
+    const serverFileName = moduleIdToServerChunk.get(routeModulePath);
     if (!serverFileName) {
-      if (foundRoute.type === "spa") continue;
+      if (foundRoute.type === "spa") {
+        continue;
+      }
       console.warn(`[one] No server chunk found for route: ${foundRoute.file}`);
       continue;
     }
     const onlyBuild = vxrnOutput.buildArgs?.only;
     if (onlyBuild) {
       const relativeId2 = foundRoute.file.slice(1);
-      if (!MicroMatch.contains(relativeId2, onlyBuild)) continue;
+      if (!MicroMatch.contains(relativeId2, onlyBuild)) {
+        continue;
+      }
     }
-    const clientChunk = clientChunksBySource.get(routeModulePath),
-      manifestKey = `${routerRoot}${foundRoute.file.slice(1)}`,
-      clientManifestEntry = vxrnOutput.clientManifest[manifestKey];
+    const clientChunk = clientChunksBySource.get(routeModulePath);
+    const manifestKey = `${routerRoot}${foundRoute.file.slice(1)}`;
+    const clientManifestEntry = vxrnOutput.clientManifest[manifestKey];
     if (!clientChunk && foundRoute.type !== "spa" && foundRoute.type !== "ssg") {
       console.warn(`No client chunk found for route: ${routeModulePath}`);
       continue;
     }
     foundRoute.loaderServerPath = serverFileName;
     const relativeId = foundRoute.file.replace(/^\.\//, "/");
-    if (foundRoute.layouts) for (const layout of foundRoute.layouts) {
-      const serverPath = layoutServerPaths.get(layout.contextKey);
-      serverPath && (layout.loaderServerPath = serverPath);
-    }
-    const entryImports = collectImports(clientManifestEntry || {}),
-      layoutEntries = foundRoute.layouts?.flatMap(layout => {
-        const clientKey = `${routerRoot}${layout.contextKey.slice(1)}`,
-          found = vxrnOutput.clientManifest[clientKey];
-        return found || [];
-      }) ?? [],
-      layoutImports = layoutEntries.flatMap(entry => [entry.file, ...collectImports(entry)]),
-      routePreloads = {},
-      rootLayoutKey = `${routerRoot}/_layout.tsx`,
-      rootLayoutEntry = vxrnOutput.clientManifest[rootLayoutKey];
-    if (rootLayoutEntry && (routePreloads[`/${rootLayoutKey}`] = `/${rootLayoutEntry.file}`), foundRoute.layouts) for (const layout of foundRoute.layouts) {
-      const clientKey = `${routerRoot}${layout.contextKey.slice(1)}`,
-        entry = vxrnOutput.clientManifest[clientKey];
-      entry && (routePreloads[`/${clientKey}`] = `/${entry.file}`);
+    if (foundRoute.layouts) {
+      for (const layout of foundRoute.layouts) {
+        const serverPath = layoutServerPaths.get(layout.contextKey);
+        if (serverPath) {
+          layout.loaderServerPath = serverPath;
+        }
+      }
+    }
+    const entryImports = collectImports(clientManifestEntry || {});
+    const layoutEntries = foundRoute.layouts?.flatMap(layout => {
+      const clientKey = `${routerRoot}${layout.contextKey.slice(1)}`;
+      const found = vxrnOutput.clientManifest[clientKey];
+      return found ? found : [];
+    }) ?? [];
+    const layoutImports = layoutEntries.flatMap(entry => {
+      return [entry.file, ...collectImports(entry)];
+    });
+    const routePreloads = {};
+    const rootLayoutKey = `${routerRoot}/_layout.tsx`;
+    const rootLayoutEntry = vxrnOutput.clientManifest[rootLayoutKey];
+    if (rootLayoutEntry) {
+      routePreloads[`/${rootLayoutKey}`] = `/${rootLayoutEntry.file}`;
+    }
+    if (foundRoute.layouts) {
+      for (const layout of foundRoute.layouts) {
+        const clientKey = `${routerRoot}${layout.contextKey.slice(1)}`;
+        const entry = vxrnOutput.clientManifest[clientKey];
+        if (entry) {
+          routePreloads[`/${clientKey}`] = `/${entry.file}`;
+        }
+      }
     }
     if (clientChunk) {
       const routeKey = `/${routerRoot}${foundRoute.file.slice(1)}`;
@@ -340,74 +419,93 @@ async function build(args) {
       routePreloads[routeKey] = `/${clientManifestEntry.file}`;
     }
     const preloadSetupFilePreloads = (() => {
-        if (!oneOptions.setupFile) return [];
-        const clientSetupFile = typeof oneOptions.setupFile == "string" ? oneOptions.setupFile : oneOptions.setupFile.client;
-        if (!clientSetupFile) return [];
-        const needle = clientSetupFile.replace(/^\.\//, "");
-        for (const file in vxrnOutput.clientManifest) if (file === needle) return [vxrnOutput.clientManifest[file].file
-        // getting 404s for preloading the imports as well?
-        // ...(entry.imports as string[])
-        ];
-        return [];
-      })(),
-      allPreloads = [... /* @__PURE__ */new Set([...preloadSetupFilePreloads,
-      // add the route entry js (like ./app/index.ts) - prefer direct chunk lookup
-      ...(clientChunk ? [clientChunk.fileName] : clientManifestEntry ? [clientManifestEntry.file] : []),
-      // add the virtual entry
-      vxrnOutput.clientManifest["virtual:one-entry"].file, ...entryImports, ...layoutImports])].map(path => `/${path}`),
-      scriptLoadingMode = oneOptions.web?.experimental_scriptLoading,
-      needsSeparatedPreloads = scriptLoadingMode === "defer-non-critical" || scriptLoadingMode === "after-lcp-aggressive",
-      criticalPreloads = needsSeparatedPreloads ? [... /* @__PURE__ */new Set([...preloadSetupFilePreloads,
-      // add the virtual entry (framework bootstrap)
-      vxrnOutput.clientManifest["virtual:one-entry"].file,
-      // add the route entry js (like ./app/index.ts) - prefer direct chunk lookup
-      ...(clientChunk ? [clientChunk.fileName] : clientManifestEntry ? [clientManifestEntry.file] : []),
-      // add layout files (but not their deep imports)
-      ...layoutEntries.map(entry => entry.file)])].map(path => `/${path}`) : void 0,
-      deferredPreloads = needsSeparatedPreloads ? [... /* @__PURE__ */new Set([...entryImports, ...layoutEntries.flatMap(entry => collectImports(entry))])].filter(path => !criticalPreloads.includes(`/${path}`)).map(path => `/${path}`) : void 0,
-      preloads2 = needsSeparatedPreloads ? [...criticalPreloads, ...deferredPreloads] : allPreloads,
-      allEntries = [clientManifestEntry, ...layoutEntries].filter(Boolean),
-      layoutCSS = [...new Set(layoutEntries.flatMap(entry => collectImports(entry, {
-        type: "css"
-      })).map(path => `/${path}`))],
-      allCSS = [... /* @__PURE__ */new Set([...layoutCSS,
-      // css from page entry
-      ...(clientManifestEntry ? collectImports(clientManifestEntry, {
-        type: "css"
-      }).map(path => `/${path}`) : []),
-      // root-level css (handles cssCodeSplit: false)
-      ...Object.entries(vxrnOutput.clientManifest).filter(([key]) => key.endsWith(".css")).map(([, entry]) => `/${entry.file}`)])],
-      hasCriticalCSS = allCSS.some(p => criticalCSSOutputPaths.has(p)),
-      needsCSSContents = oneOptions.web?.inlineLayoutCSS || hasCriticalCSS;
-    let allCSSContents;
-    needsCSSContents && (allCSSContents = await Promise.all(allCSS.map(async cssPath => {
-      if (!oneOptions.web?.inlineLayoutCSS && !criticalCSSOutputPaths.has(cssPath)) return "";
-      const cached = cssFileContentsCache.get(cssPath);
-      if (cached !== void 0) return cached;
-      const filePath = join(clientDir, cssPath);
-      try {
-        const content = await FSExtra.readFile(filePath, "utf-8");
-        return cssFileContentsCache.set(cssPath, content), content;
-      } catch {
-        return console.warn(`[one] Warning: Could not read CSS file ${filePath}`), cssFileContentsCache.set(cssPath, ""), "";
+      if (!oneOptions.setupFile) return [];
+      const clientSetupFile = typeof oneOptions.setupFile === "string" ? oneOptions.setupFile : oneOptions.setupFile.client;
+      if (!clientSetupFile) return [];
+      const needle = clientSetupFile.replace(/^\.\//, "");
+      for (const file in vxrnOutput.clientManifest) {
+        if (file === needle) {
+          const entry = vxrnOutput.clientManifest[file];
+          return [entry.file
+          // getting 404s for preloading the imports as well?
+          // ...(entry.imports as string[])
+          ];
+        }
       }
-    }))), process.env.DEBUG && console.info("[one] building routes", {
-      foundRoute,
-      layoutEntries,
-      allEntries,
-      allCSS
-    });
+      return [];
+    })();
+    const allPreloads = [... /* @__PURE__ */new Set([...preloadSetupFilePreloads,
+    // add the route entry js (like ./app/index.ts) - prefer direct chunk lookup
+    ...(clientChunk ? [clientChunk.fileName] : clientManifestEntry ? [clientManifestEntry.file] : []),
+    // add the virtual entry
+    vxrnOutput.clientManifest["virtual:one-entry"].file, ...entryImports, ...layoutImports])].map(path => `/${path}`);
+    const scriptLoadingMode = oneOptions.web?.experimental_scriptLoading;
+    const useDeferredLoading = scriptLoadingMode === "defer-non-critical";
+    const useAggressiveLCP = scriptLoadingMode === "after-lcp-aggressive";
+    const needsSeparatedPreloads = useDeferredLoading || useAggressiveLCP;
+    const criticalPreloads = needsSeparatedPreloads ? [... /* @__PURE__ */new Set([...preloadSetupFilePreloads,
+    // add the virtual entry (framework bootstrap)
+    vxrnOutput.clientManifest["virtual:one-entry"].file,
+    // add the route entry js (like ./app/index.ts) - prefer direct chunk lookup
+    ...(clientChunk ? [clientChunk.fileName] : clientManifestEntry ? [clientManifestEntry.file] : []),
+    // add layout files (but not their deep imports)
+    ...layoutEntries.map(entry => entry.file)])].map(path => `/${path}`) : void 0;
+    const deferredPreloads = needsSeparatedPreloads ? [... /* @__PURE__ */new Set([...entryImports, ...layoutEntries.flatMap(entry => collectImports(entry))])].filter(path => !criticalPreloads.includes(`/${path}`)).map(path => `/${path}`) : void 0;
+    const preloads2 = needsSeparatedPreloads ? [...criticalPreloads, ...deferredPreloads] : allPreloads;
+    const allEntries = [clientManifestEntry, ...layoutEntries].filter(Boolean);
+    const layoutCSS = [...new Set(layoutEntries.flatMap(entry => collectImports(entry, {
+      type: "css"
+    })).map(path => `/${path}`))];
+    const allCSS = [... /* @__PURE__ */new Set([...layoutCSS,
+    // css from page entry
+    ...(clientManifestEntry ? collectImports(clientManifestEntry, {
+      type: "css"
+    }).map(path => `/${path}`) : []),
+    // root-level css (handles cssCodeSplit: false)
+    ...Object.entries(vxrnOutput.clientManifest).filter(([key]) => key.endsWith(".css")).map(([, entry]) => `/${entry.file}`)])];
+    const hasCriticalCSS = allCSS.some(p => criticalCSSOutputPaths.has(p));
+    const needsCSSContents = oneOptions.web?.inlineLayoutCSS || hasCriticalCSS;
+    let allCSSContents;
+    if (needsCSSContents) {
+      allCSSContents = await Promise.all(allCSS.map(async cssPath => {
+        if (!oneOptions.web?.inlineLayoutCSS && !criticalCSSOutputPaths.has(cssPath)) {
+          return "";
+        }
+        const cached = cssFileContentsCache.get(cssPath);
+        if (cached !== void 0) return cached;
+        const filePath = join(clientDir, cssPath);
+        try {
+          const content = await FSExtra.readFile(filePath, "utf-8");
+          cssFileContentsCache.set(cssPath, content);
+          return content;
+        } catch (err) {
+          console.warn(`[one] Warning: Could not read CSS file ${filePath}`);
+          cssFileContentsCache.set(cssPath, "");
+          return "";
+        }
+      }));
+    }
+    if (process.env.DEBUG) {
+      console.info("[one] building routes", {
+        foundRoute,
+        layoutEntries,
+        allEntries,
+        allCSS
+      });
+    }
     const serverJsPath = join(`${outDir}/server`, serverFileName);
     let exported;
     try {
       exported = await import(toAbsolute(serverJsPath));
     } catch (err) {
-      throw console.error("Error importing page (original error)", err), new Error(`Error importing page: ${serverJsPath}`, {
+      console.error(`Error importing page (original error)`, err);
+      throw new Error(`Error importing page: ${serverJsPath}`, {
         cause: err
       });
     }
     const isDynamic = !!Object.keys(foundRoute.routeKeys).length;
-    if (foundRoute.type === "ssg" && isDynamic && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap") && !exported.generateStaticParams) throw new Error(`[one] Error: Missing generateStaticParams
+    if (foundRoute.type === "ssg" && isDynamic && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap") && !exported.generateStaticParams) {
+      throw new Error(`[one] Error: Missing generateStaticParams
 
   Route ${foundRoute.page} of type ${foundRoute.type} must export generateStaticParams so build can complete.
 
@@ -415,18 +513,24 @@ async function build(args) {
     https://onestack.dev/docs/routing-exports#generatestaticparams
 
 `);
+    }
     const paramsList = (await exported.generateStaticParams?.()) ?? [{}];
     console.info(`
  [build] page ${relativeId} (with ${paramsList.length} routes)
-`), process.env.DEBUG && console.info("paramsList", JSON.stringify(paramsList, null, 2));
-    const routeSitemapExport = exported.sitemap,
-      isAfterLCPMode = scriptLoadingMode === "after-lcp" || scriptLoadingMode === "after-lcp-aggressive",
-      useAfterLCP = foundRoute.type === "ssg" && isAfterLCPMode,
-      useAfterLCPAggressive = foundRoute.type === "ssg" && scriptLoadingMode === "after-lcp-aggressive",
-      shouldCollectSitemap = foundRoute.type !== "api" && foundRoute.type !== "layout" && !foundRoute.isNotFound && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap"),
-      pageBuilds = paramsList.map(params => {
-        const path = getPathnameFromFilePath(relativeId, params, foundRoute.type === "ssg");
-        return workerPool ? (console.info(`  \u21A6 route ${path}`), workerPool.buildPage({
+`);
+    if (process.env.DEBUG) {
+      console.info(`paramsList`, JSON.stringify(paramsList, null, 2));
+    }
+    const routeSitemapExport = exported.sitemap;
+    const isAfterLCPMode = scriptLoadingMode === "after-lcp" || scriptLoadingMode === "after-lcp-aggressive";
+    const useAfterLCP = foundRoute.type === "ssg" && isAfterLCPMode;
+    const useAfterLCPAggressive = foundRoute.type === "ssg" && scriptLoadingMode === "after-lcp-aggressive";
+    const shouldCollectSitemap = foundRoute.type !== "api" && foundRoute.type !== "layout" && !foundRoute.isNotFound && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap");
+    const pageBuilds = paramsList.map(params => {
+      const path = getPathnameFromFilePath(relativeId, params, foundRoute.type === "ssg");
+      if (workerPool) {
+        console.info(`  \u21A6 route ${path}`);
+        return workerPool.buildPage({
           serverEntry: vxrnOutput.serverEntry,
           path,
           relativeId,
@@ -449,64 +553,99 @@ async function build(args) {
         }).then(built => ({
           built,
           path
-        })).catch(err => (console.warn(`  \u26A0 skipping page ${path}: ${err.message}`), null))) : limit(async () => {
-          console.info(`  \u21A6 route ${path}`);
-          try {
-            return {
-              built: await runWithAsyncLocalContext(async () => await buildPage(vxrnOutput.serverEntry, path, relativeId, params, foundRoute, clientManifestEntry, staticDir, clientDir, builtMiddlewares, serverJsPath, preloads2, allCSS, layoutCSS, routePreloads, allCSSContents, criticalPreloads, deferredPreloads, useAfterLCP, useAfterLCPAggressive)),
-              path
-            };
-          } catch (err) {
-            return console.warn(`  \u26A0 skipping page ${path}: ${err.message}`), null;
-          }
+        })).catch(err => {
+          console.warn(`  \u26A0 skipping page ${path}: ${err.message}`);
+          return null;
         });
-      }),
-      results = (await Promise.all(pageBuilds)).filter(Boolean);
+      }
+      return limit(async () => {
+        console.info(`  \u21A6 route ${path}`);
+        try {
+          const built = await runWithAsyncLocalContext(async () => {
+            return await buildPage(vxrnOutput.serverEntry, path, relativeId, params, foundRoute, clientManifestEntry, staticDir, clientDir, builtMiddlewares, serverJsPath, preloads2, allCSS, layoutCSS, routePreloads, allCSSContents, criticalPreloads, deferredPreloads, useAfterLCP, useAfterLCPAggressive);
+          });
+          return {
+            built,
+            path
+          };
+        } catch (err) {
+          console.warn(`  \u26A0 skipping page ${path}: ${err.message}`);
+          return null;
+        }
+      });
+    });
+    const results = (await Promise.all(pageBuilds)).filter(Boolean);
     for (const {
       built,
       path
-    } of results) builtRoutes.push(built), shouldCollectSitemap && sitemapData.push({
-      path,
-      routeExport: routeSitemapExport
-    });
+    } of results) {
+      builtRoutes.push(built);
+      if (shouldCollectSitemap) {
+        sitemapData.push({
+          path,
+          routeExport: routeSitemapExport
+        });
+      }
+    }
+  }
+  if (workerPool) {
+    await terminateWorkerPool();
   }
-  workerPool && (await terminateWorkerPool());
   const staticTime = performance.now() - staticStartTime;
   console.info(`
  \u23F1\uFE0F static routes: ${(staticTime / 1e3).toFixed(2)}s (${builtRoutes.length} pages)
-`), printBuildTimings(), await moveAllFiles(staticDir, clientDir), await FSExtra.rm(staticDir, {
-    force: !0,
-    recursive: !0
+`);
+  printBuildTimings();
+  await moveAllFiles(staticDir, clientDir);
+  await FSExtra.rm(staticDir, {
+    force: true,
+    recursive: true
   });
-  const routeMap = {},
-    routeToBuildInfo = {},
-    pathToRoute = {},
-    preloads = {},
-    cssPreloads = {},
-    loaders = {};
+  const routeMap = {};
+  const routeToBuildInfo = {};
+  const pathToRoute = {};
+  const preloads = {};
+  const cssPreloads = {};
+  const loaders = {};
   for (const route of builtRoutes) {
-    route.cleanPath.includes("*") || (routeMap[route.cleanPath] = route.htmlPath);
+    if (!route.cleanPath.includes("*")) {
+      routeMap[route.cleanPath] = route.htmlPath;
+    }
     const {
       // dont include loaderData it can be huge
       loaderData: _loaderData,
       ...rest
     } = route;
     routeToBuildInfo[route.routeFile] = rest;
-    for (const p of getCleanPaths([route.path, route.cleanPath])) pathToRoute[p] = route.routeFile;
-    preloads[route.preloadPath] = !0, cssPreloads[route.cssPreloadPath] = !0, loaders[route.loaderPath] = !0;
+    for (const p of getCleanPaths([route.path, route.cleanPath])) {
+      pathToRoute[p] = route.routeFile;
+    }
+    preloads[route.preloadPath] = true;
+    cssPreloads[route.cssPreloadPath] = true;
+    loaders[route.loaderPath] = true;
   }
   function createBuildManifestRoute(route) {
     const {
       layouts,
       ...built
     } = route;
-    layouts?.length && (built.layouts = layouts.map(layout => ({
-      contextKey: layout.contextKey,
-      loaderServerPath: layout.loaderServerPath
-    })));
+    if (layouts?.length) {
+      ;
+      built.layouts = layouts.map(layout => ({
+        contextKey: layout.contextKey,
+        loaderServerPath: layout.loaderServerPath
+      }));
+    }
     const buildInfo = builtRoutes.find(x => x.routeFile === route.file);
-    if (built.middlewares && buildInfo?.middlewares) for (const [index, mw] of built.middlewares.entries()) mw.contextKey = buildInfo.middlewares[index];
-    return buildInfo && (built.loaderPath = buildInfo.loaderPath), built;
+    if (built.middlewares && buildInfo?.middlewares) {
+      for (const [index, mw] of built.middlewares.entries()) {
+        mw.contextKey = buildInfo.middlewares[index];
+      }
+    }
+    if (buildInfo) {
+      built.loaderPath = buildInfo.loaderPath;
+    }
+    return built;
   }
   const buildInfoForWriting = {
     outDir,
@@ -527,30 +666,44 @@ async function build(args) {
     loaders,
     useRolldown: await isRolldown()
   };
-  await writeJSON(toAbsolute(`${outDir}/buildInfo.json`), buildInfoForWriting), await FSExtra.writeFile(join(clientDir, "version.json"), JSON.stringify({
+  await writeJSON(toAbsolute(`${outDir}/buildInfo.json`), buildInfoForWriting);
+  await FSExtra.writeFile(join(clientDir, "version.json"), JSON.stringify({
     version: constants.CACHE_KEY
-  })), console.info(`
+  }));
+  console.info(`
  \u{1F6E1} skew protection: emitted version.json
 `);
   const sitemapConfig = oneOptions.web?.sitemap;
   if (sitemapConfig) {
-    const sitemapXml = generateSitemap(sitemapData, typeof sitemapConfig == "boolean" ? {} : sitemapConfig),
-      sitemapPath = join(clientDir, "sitemap.xml");
-    await FSExtra.writeFile(sitemapPath, sitemapXml), console.info(`
+    const sitemapOptions = typeof sitemapConfig === "boolean" ? {} : sitemapConfig;
+    const sitemapXml = generateSitemap(sitemapData, sitemapOptions);
+    const sitemapPath = join(clientDir, "sitemap.xml");
+    await FSExtra.writeFile(sitemapPath, sitemapXml);
+    console.info(`
  \u{1F4C4} generated sitemap.xml (${sitemapData.length} URLs)
 `);
   }
-  const postBuildLogs = [],
-    platform = deployConfig?.target;
-  switch (platform && postBuildLogs.push(`[one.build] platform ${platform}`), platform) {
+  const postBuildLogs = [];
+  const platform = deployConfig?.target;
+  if (platform) {
+    postBuildLogs.push(`[one.build] platform ${platform}`);
+  }
+  switch (platform) {
     case "vercel":
       {
         const vercelJsonPath = join(options.root, "vercel.json");
-        if (FSExtra.existsSync(vercelJsonPath)) try {
-          JSON.parse(FSExtra.readFileSync(vercelJsonPath, "utf-8")).cleanUrls || (console.warn(`
- \u26A0\uFE0F  Warning: Your vercel.json is missing "cleanUrls": true`), console.warn("    Without this, direct navigation to SSG pages will 404."), console.warn(`    Add "cleanUrls": true to your vercel.json to fix this.
-`));
-        } catch {}
+        if (FSExtra.existsSync(vercelJsonPath)) {
+          try {
+            const vercelConfig = JSON.parse(FSExtra.readFileSync(vercelJsonPath, "utf-8"));
+            if (!vercelConfig.cleanUrls) {
+              console.warn(`
+ \u26A0\uFE0F  Warning: Your vercel.json is missing "cleanUrls": true`);
+              console.warn(`    Without this, direct navigation to SSG pages will 404.`);
+              console.warn(`    Add "cleanUrls": true to your vercel.json to fix this.
+`);
+            }
+          } catch {}
+        }
         await buildVercelOutputDirectory({
           apiOutput,
           buildInfoForWriting,
@@ -562,23 +715,28 @@ async function build(args) {
       }
     case "cloudflare":
       {
-        const pageRouteMap = [],
-          apiRouteMap = [],
-          middlewareRouteMap = [];
-        for (const [routeFile, info] of Object.entries(buildInfoForWriting.routeToBuildInfo)) if (info.serverJsPath) {
-          const importPath = "./" + info.serverJsPath.replace(new RegExp(`^${outDir}/`), "");
-          pageRouteMap.push(`  '${routeFile}': () => import('${importPath}')`);
+        const pageRouteMap = [];
+        const apiRouteMap = [];
+        const middlewareRouteMap = [];
+        for (const [routeFile, info] of Object.entries(buildInfoForWriting.routeToBuildInfo)) {
+          if (info.serverJsPath) {
+            const importPath = "./" + info.serverJsPath.replace(new RegExp(`^${outDir}/`), "");
+            pageRouteMap.push(`  '${routeFile}': () => import('${importPath}')`);
+          }
         }
-        for (const route of buildInfoForWriting.manifest.apiRoutes) if (route.file) {
-          const importPath = `./api/${route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_")}.js`;
-          apiRouteMap.push(`  '${route.page}': () => import('${importPath}')`);
+        for (const route of buildInfoForWriting.manifest.apiRoutes) {
+          if (route.file) {
+            const apiFileName = route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
+            const importPath = `./api/${apiFileName}.js`;
+            apiRouteMap.push(`  '${route.page}': () => import('${importPath}')`);
+          }
         }
         for (const [, builtPath] of Object.entries(builtMiddlewares)) {
           const importPath = "./" + builtPath.replace(new RegExp(`^${outDir}/`), "");
           middlewareRouteMap.push(`  '${builtPath}': () => import('${importPath}')`);
         }
-        const workerSrcPath = join(options.root, outDir, "_worker-src.js"),
-          workerCode = `// Polyfill MessageChannel for React SSR (not available in Cloudflare Workers by default)
+        const workerSrcPath = join(options.root, outDir, "_worker-src.js");
+        const workerCode = `// Polyfill MessageChannel for React SSR (not available in Cloudflare Workers by default)
 if (typeof MessageChannel === 'undefined') {
   globalThis.MessageChannel = class MessageChannel {
     constructor() {
@@ -594,16 +752,13 @@ import { serve, setFetchStaticHtml } from 'one/serve-worker'
 const lazyRoutes = {
   serverEntry: () => import('./server/_virtual_one-entry.js'),
   pages: {
-${pageRouteMap.join(`,
-`)}
+${pageRouteMap.join(",\n")}
   },
   api: {
-${apiRouteMap.join(`,
-`)}
+${apiRouteMap.join(",\n")}
   },
   middlewares: {
-${middlewareRouteMap.join(`,
-`)}
+${middlewareRouteMap.join(",\n")}
   }
 }
 
@@ -658,14 +813,15 @@ export default {
   }
 }
 `;
-        await FSExtra.writeFile(workerSrcPath, workerCode), console.info(`
- [cloudflare] Bundling worker...`), await viteBuild({
+        await FSExtra.writeFile(workerSrcPath, workerCode);
+        console.info("\n [cloudflare] Bundling worker...");
+        await viteBuild({
           root: options.root,
           mode: "production",
           logLevel: "warn",
           build: {
             outDir,
-            emptyOutDir: !1,
+            emptyOutDir: false,
             // Use SSR mode with node target for proper Node.js module resolution
             ssr: workerSrcPath,
             rolldownOptions: {
@@ -678,10 +834,10 @@ export default {
                 entryFileNames: "worker.js",
                 format: "es",
                 // Keep dynamic imports separate for lazy loading
-                inlineDynamicImports: !1
+                inlineDynamicImports: false
               }
             },
-            minify: !0,
+            minify: true,
             target: "esnext"
           },
           define: {
@@ -708,11 +864,12 @@ export default {
           },
           ssr: {
             target: "node",
-            noExternal: !0
+            noExternal: true
           }
-        }), await FSExtra.remove(workerSrcPath);
-        const projectName = await getCloudflareProjectName(options.root),
-          wranglerConfig = `{
+        });
+        await FSExtra.remove(workerSrcPath);
+        const projectName = await getCloudflareProjectName(options.root);
+        const wranglerConfig = `{
   "name": ${JSON.stringify(projectName)},
   "main": "worker.js",
   "compatibility_date": "2024-12-05",
@@ -727,24 +884,33 @@ export default {
   "assets": { "directory": "client", "binding": "ASSETS", "run_worker_first": true }
 }
 `;
-        await FSExtra.writeFile(join(options.root, outDir, "wrangler.jsonc"), wranglerConfig), postBuildLogs.push(`Cloudflare worker bundled at ${outDir}/worker.js`), postBuildLogs.push(`To deploy: cd ${outDir} && wrangler deploy`);
+        await FSExtra.writeFile(join(options.root, outDir, "wrangler.jsonc"), wranglerConfig);
+        postBuildLogs.push(`Cloudflare worker bundled at ${outDir}/worker.js`);
+        postBuildLogs.push(`To deploy: cd ${outDir} && wrangler deploy`);
         break;
       }
   }
-  const securityScanOption = oneOptions.build?.securityScan,
-    securityScanLevel = securityScanOption === !1 ? null : securityScanOption === !0 || securityScanOption === void 0 ? "warn" : typeof securityScanOption == "string" ? securityScanOption : securityScanOption.level ?? "warn",
-    securitySafePatterns = typeof securityScanOption == "object" && securityScanOption !== null ? securityScanOption.safePatterns : void 0;
+  const securityScanOption = oneOptions.build?.securityScan;
+  const securityScanLevel = securityScanOption === false ? null : securityScanOption === true || securityScanOption === void 0 ? "warn" : typeof securityScanOption === "string" ? securityScanOption : securityScanOption.level ?? "warn";
+  const securitySafePatterns = typeof securityScanOption === "object" && securityScanOption !== null ? securityScanOption.safePatterns : void 0;
   if (securityScanLevel) {
     const {
       runSecurityScan
     } = await import("./securityScan.mjs");
-    (await runSecurityScan(clientDir, securityScanLevel, securitySafePatterns)) || process.exit(1);
+    const passed = await runSecurityScan(clientDir, securityScanLevel, securitySafePatterns);
+    if (!passed) {
+      process.exit(1);
+    }
   }
-  postBuildLogs.length && (console.info(`
+  if (postBuildLogs.length) {
+    console.info(`
 
-`), postBuildLogs.forEach(log => {
-    console.info(`  \xB7 ${log}`);
-  })), console.info(`
+`);
+    postBuildLogs.forEach(log => {
+      console.info(`  \xB7 ${log}`);
+    });
+  }
+  console.info(`
  \u{1F49B} build complete
 `);
 }
@@ -754,7 +920,8 @@ function getCleanPaths(possiblePaths) {
     const paths = [p];
     if (p.match(TRAILING_INDEX_REGEX)) {
       const pathWithTrailingIndexRemoved = p.replace(TRAILING_INDEX_REGEX, "");
-      paths.push(pathWithTrailingIndexRemoved), paths.push(pathWithTrailingIndexRemoved + "/");
+      paths.push(pathWithTrailingIndexRemoved);
+      paths.push(pathWithTrailingIndexRemoved + "/");
     }
     return paths;
   })));
@@ -762,8 +929,8 @@ function getCleanPaths(possiblePaths) {
 async function moveAllFiles(src, dest) {
   try {
     await FSExtra.copy(src, dest, {
-      overwrite: !0,
-      errorOnExist: !1
+      overwrite: true,
+      errorOnExist: false
     });
   } catch (err) {
     console.error("Error moving files:", err);