one 1.12.2 → 1.12.4

package/dist/esm/cli/build.js

@@ -1,786 +0,0 @@
-import { createRequire } from "node:module";
-import { cpus } from "node:os";
-import Path, { join, relative, resolve } from "node:path";
-import { resolvePath } from "@vxrn/resolve";
-import FSExtra from "fs-extra";
-import MicroMatch from "micromatch";
-import { mergeConfig, build as viteBuild } from "vite";
-import {
-  fillOptions,
-  getOptimizeDeps,
-  rollupRemoveUnusedImportsPlugin,
-  build as vxrnBuild
-} from "vxrn";
-import * as constants from "../constants";
-import { setServerGlobals } from "../server/setServerGlobals";
-import { getPathnameFromFilePath } from "../utils/getPathnameFromFilePath";
-import { getRouterRootFromOneOptions } from "../utils/getRouterRootFromOneOptions";
-import { isRolldown } from "../utils/isRolldown";
-import { toAbsolute } from "../utils/toAbsolute";
-import { buildVercelOutputDirectory } from "../vercel/build/buildVercelOutputDirectory";
-import { getManifest } from "../vite/getManifest";
-import { loadUserOneOptions } from "../vite/loadConfig";
-import { runWithAsyncLocalContext } from "../vite/one-server-only";
-import { buildPage, printBuildTimings } from "./buildPage";
-import { checkNodeVersion } from "./checkNodeVersion";
-import { getWorkerPool, terminateWorkerPool } from "./workerPool";
-import { generateSitemap } from "./generateSitemap";
-import { labelProcess } from "./label-process";
-import { pLimit } from "../utils/pLimit";
-import { getCriticalCSSOutputPaths } from "../vite/plugins/criticalCSSPlugin";
-const { ensureDir, writeJSON } = FSExtra;
-function normalizeDeploy(deploy) {
-  if (deploy)
-    return typeof deploy == "string" ? { target: deploy } : 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(/^@[^/]+\//, "");
-  } catch {
-  }
-  return "one-app";
-}
-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;
-}
-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 ? {
-    ...config,
-    plugins: config.plugins.map((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] });
-      return cloned;
-    })
-  } : config;
-}
-async function build(args) {
-  process.env.IS_VXRN_CLI = "true", process.env.NODE_ENV ? 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();
-  const { oneOptions, config: viteLoadedConfig } = await loadUserOneOptions("build"), routerRoot = getRouterRootFromOneOptions(oneOptions);
-  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(`
- \u2601\uFE0F  ONE_SERVER_URL: ${url}
-`));
-  }
-  const outDir = viteLoadedConfig?.config?.build?.outDir ?? "dist", manifest = getManifest({ routerRoot }), 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
-        }
-      }
-    },
-    args
-  ), bundleTime = performance.now() - buildStartTime;
-  if (console.info(`
- \u23F1\uFE0F  vite bundle: ${(bundleTime / 1e3).toFixed(2)}s
-`), !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 }
-        }
-      }
-    }
-  );
-  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,
-      ssr: {
-        noExternal: !0,
-        external: ["react", "react-dom"],
-        optimizeDeps: optimizeDepsNoRolldown
-      },
-      environments: {
-        ssr: {
-          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}`);
-              }
-            }
-          }
-        }
-      }
-    }), userApiBuildConf = oneOptions.build?.api?.config, finalApiBuildConf = userApiBuildConf ? mergeConfig(mergedConfig, userApiBuildConf) : mergedConfig;
-    return await viteBuild(
-      // allow user merging api build config
-      finalApiBuildConf
-    );
-  }
-  const builtMiddlewares = {}, apiPromise = manifest.apiRoutes.length ? (console.info(`
- \u{1F528} build api routes
-`), buildCustomRoutes("api", manifest.apiRoutes)) : Promise.resolve(null), 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);
-    }
-  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;
-  if (workerPool) {
-    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}`;
-  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 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();
-  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}/`, "")}`;
-      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 [, 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 foundRoute of manifest.pageRoutes) {
-    let collectImports = function(entry, { type = "js" } = {}) {
-      const { imports = [], css } = entry, cacheKey = `${entry.file || imports.join(",")}:${type}`, 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, { 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;
-    };
-    if (!foundRoute.file)
-      continue;
-    const routeModulePath = join(
-      resolve(process.cwd(), options.root),
-      routerRoot,
-      foundRoute.file.slice(2)
-    ), serverFileName = moduleIdToServerChunk.get(routeModulePath);
-    if (!serverFileName) {
-      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;
-    }
-    const clientChunk = clientChunksBySource.get(routeModulePath), manifestKey = `${routerRoot}${foundRoute.file.slice(1)}`, 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 (clientChunk) {
-      const routeKey = `/${routerRoot}${foundRoute.file.slice(1)}`;
-      routePreloads[routeKey] = `/${clientChunk.fileName}`;
-    } else if (clientManifestEntry) {
-      const routeKey = `/${routerRoot}${foundRoute.file.slice(1)}`;
-      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, ""), "";
-        }
-      })
-    )), 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}`, {
-        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
-
-  Route ${foundRoute.page} of type ${foundRoute.type} must export generateStaticParams so build can complete.
-
-  See docs on generateStaticParams:
-    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({
-        serverEntry: vxrnOutput.serverEntry,
-        path,
-        relativeId,
-        params,
-        foundRoute,
-        clientManifestEntry,
-        staticDir,
-        clientDir,
-        builtMiddlewares,
-        serverJsPath,
-        preloads: preloads2,
-        allCSS,
-        layoutCSS,
-        routePreloads,
-        allCSSContents,
-        criticalPreloads,
-        deferredPreloads,
-        useAfterLCP,
-        useAfterLCPAggressive
-      }).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;
-        }
-      });
-    }), results = (await Promise.all(pageBuilds)).filter(Boolean);
-    for (const { built, path } of results)
-      builtRoutes.push(built), shouldCollectSitemap && sitemapData.push({
-        path,
-        routeExport: routeSitemapExport
-      });
-  }
-  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 });
-  const routeMap = {}, routeToBuildInfo = {}, pathToRoute = {}, preloads = {}, cssPreloads = {}, loaders = {};
-  for (const route of builtRoutes) {
-    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;
-  }
-  function createBuildManifestRoute(route) {
-    const { layouts, ...built } = route;
-    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;
-  }
-  const buildInfoForWriting = {
-    outDir,
-    oneOptions,
-    routeToBuildInfo,
-    pathToRoute,
-    manifest: {
-      pageRoutes: manifest.pageRoutes.map(createBuildManifestRoute),
-      apiRoutes: manifest.apiRoutes.map(createBuildManifestRoute),
-      allRoutes: manifest.allRoutes.map(createBuildManifestRoute)
-    },
-    routeMap,
-    constants: JSON.parse(JSON.stringify({ ...constants })),
-    preloads,
-    cssPreloads,
-    loaders,
-    useRolldown: await isRolldown()
-  };
-  await writeJSON(toAbsolute(`${outDir}/buildInfo.json`), buildInfoForWriting), await FSExtra.writeFile(
-    join(clientDir, "version.json"),
-    JSON.stringify({ version: constants.CACHE_KEY })
-  ), 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(`
- \u{1F4C4} generated sitemap.xml (${sitemapData.length} URLs)
-`);
-  }
-  const postBuildLogs = [], platform = deployConfig?.target;
-  switch (platform && postBuildLogs.push(`[one.build] platform ${platform}`), 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 {
-        }
-      await buildVercelOutputDirectory({
-        apiOutput,
-        buildInfoForWriting,
-        clientDir,
-        oneOptionsRoot: options.root,
-        postBuildLogs
-      });
-      break;
-    }
-    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}')`);
-        }
-      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 [, 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)
-if (typeof MessageChannel === 'undefined') {
-  globalThis.MessageChannel = class MessageChannel {
-    constructor() {
-      this.port1 = { postMessage: () => {}, onmessage: null, close: () => {} }
-      this.port2 = { postMessage: () => {}, onmessage: null, close: () => {} }
-    }
-  }
-}
-
-import { serve, setFetchStaticHtml } from 'one/serve-worker'
-
-// Lazy import map - modules load on-demand when route is matched
-const lazyRoutes = {
-  serverEntry: () => import('./server/_virtual_one-entry.js'),
-  pages: {
-${pageRouteMap.join(`,
-`)}
-  },
-  api: {
-${apiRouteMap.join(`,
-`)}
-  },
-  middlewares: {
-${middlewareRouteMap.join(`,
-`)}
-  }
-}
-
-const buildInfo = ${JSON.stringify(buildInfoForWriting)}
-
-let app
-
-export default {
-  async fetch(request, env, ctx) {
-    if (!app) {
-      app = await serve(buildInfo, lazyRoutes)
-    }
-
-    // Set up static HTML fetcher for this request (uses ASSETS binding)
-    if (env.ASSETS) {
-      setFetchStaticHtml(async (path) => {
-        try {
-          const url = new URL(request.url)
-          url.pathname = path
-          const assetResponse = await env.ASSETS.fetch(new Request(url))
-          if (assetResponse && assetResponse.ok) {
-            return await assetResponse.text()
-          }
-        } catch (e) {
-          // Asset not found
-        }
-        return null
-      })
-    }
-
-    try {
-      // Try the app first
-      const response = await app.fetch(request, env, ctx)
-
-      // If no route matched (404) or no response, try serving static assets
-      if (!response || response.status === 404) {
-        if (env.ASSETS) {
-          try {
-            const assetResponse = await env.ASSETS.fetch(request)
-            // If asset exists, return it
-            if (assetResponse && assetResponse.status !== 404) {
-              return assetResponse
-            }
-          } catch (e) {
-            // Asset not found, continue with original response
-          }
-        }
-      }
-
-      return response
-    } finally {
-      // Clean up per-request state
-      setFetchStaticHtml(null)
-    }
-  }
-}
-`;
-      await FSExtra.writeFile(workerSrcPath, workerCode), console.info(`
- [cloudflare] Bundling worker...`), await viteBuild({
-        root: options.root,
-        mode: "production",
-        logLevel: "warn",
-        build: {
-          outDir,
-          emptyOutDir: !1,
-          // Use SSR mode with node target for proper Node.js module resolution
-          ssr: workerSrcPath,
-          rolldownOptions: {
-            external: [
-              // React Native dev tools - not needed in production
-              "@react-native/dev-middleware",
-              "@react-native/debugger-shell",
-              "metro",
-              "metro-core",
-              "metro-runtime",
-              // Native modules that can't run in workers
-              /\.node$/
-            ],
-            output: {
-              entryFileNames: "worker.js",
-              format: "es",
-              // Keep dynamic imports separate for lazy loading
-              inlineDynamicImports: !1
-            }
-          },
-          minify: !0,
-          target: "esnext"
-        },
-        define: {
-          "process.env.NODE_ENV": JSON.stringify("production"),
-          "process.env.VITE_ENVIRONMENT": JSON.stringify("ssr")
-        },
-        resolve: {
-          conditions: ["workerd", "worker", "node", "module", "default"],
-          alias: [
-            // rolldown can't parse react-native's Flow syntax; alias to react-native-web for ssr
-            {
-              find: /^react-native\/Libraries\/.*/,
-              replacement: resolvePath("@vxrn/vite-plugin-metro/empty", options.root)
-            },
-            {
-              find: "react-native/package.json",
-              replacement: resolvePath("react-native-web/package.json", options.root)
-            },
-            {
-              find: "react-native",
-              replacement: resolvePath("react-native-web", options.root)
-            },
-            {
-              find: "react-native-safe-area-context",
-              replacement: resolvePath("@vxrn/safe-area", options.root)
-            }
-          ]
-        },
-        ssr: {
-          target: "node",
-          noExternal: !0
-        }
-      }), await FSExtra.remove(workerSrcPath);
-      const projectName = await getCloudflareProjectName(options.root), wranglerConfig = `{
-  "name": ${JSON.stringify(projectName)},
-  "main": "worker.js",
-  "compatibility_date": "2024-12-05",
-  "compatibility_flags": ["nodejs_compat"],
-  "find_additional_modules": true,
-  "rules": [
-    { "type": "ESModule", "globs": ["./server/**/*.js"], "fallthrough": true },
-    { "type": "ESModule", "globs": ["./api/**/*.js"], "fallthrough": true },
-    { "type": "ESModule", "globs": ["./middlewares/**/*.js"], "fallthrough": true },
-    { "type": "ESModule", "globs": ["./assets/**/*.js"], "fallthrough": true }
-  ],
-  "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`);
-      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;
-  if (securityScanLevel) {
-    const { runSecurityScan } = await import("./securityScan");
-    await runSecurityScan(
-      clientDir,
-      securityScanLevel,
-      securitySafePatterns
-    ) || process.exit(1);
-  }
-  postBuildLogs.length && (console.info(`
-
-`), postBuildLogs.forEach((log) => {
-    console.info(`  \xB7 ${log}`);
-  })), console.info(`
-
-  \u{1F49B} build complete
-
-`);
-}
-const TRAILING_INDEX_REGEX = /\/index(\.(web))?/;
-function getCleanPaths(possiblePaths) {
-  return Array.from(
-    new Set(
-      Array.from(new Set(possiblePaths)).flatMap((p) => {
-        const paths = [p];
-        if (p.match(TRAILING_INDEX_REGEX)) {
-          const pathWithTrailingIndexRemoved = p.replace(TRAILING_INDEX_REGEX, "");
-          paths.push(pathWithTrailingIndexRemoved), paths.push(pathWithTrailingIndexRemoved + "/");
-        }
-        return paths;
-      })
-    )
-  );
-}
-async function moveAllFiles(src, dest) {
-  try {
-    await FSExtra.copy(src, dest, { overwrite: !0, errorOnExist: !1 });
-  } catch (err) {
-    console.error("Error moving files:", err);
-  }
-}
-export {
-  build
-};
-//# sourceMappingURL=build.js.map