one 1.25.5 → 1.25.7

package/dist/cjs/cli/build.native.js

@@ -0,0 +1,1702 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+module.exports = __toCommonJS(build_exports);
+var import_module = require("module");
+var import_os = require("os");
+var import_path = __toESM(require("path"), 1);
+var import_resolve = require("@vxrn/resolve");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_micromatch = __toESM(require("micromatch"), 1);
+var import_vite = require("vite");
+var import_vxrn = require("vxrn");
+var constants = __toESM(require("../constants.native.js"), 1);
+var import_setServerGlobals = require("../server/setServerGlobals.native.js");
+var import_environmentGuardPlugin = require("../vite/plugins/environmentGuardPlugin.native.js");
+var import_buildOutputPointer = require("../utils/buildOutputPointer.native.js");
+var import_getPathnameFromFilePath = require("../utils/getPathnameFromFilePath.native.js");
+var import_getRouterRootFromOneOptions = require("../utils/getRouterRootFromOneOptions.native.js");
+var import_isRolldown = require("../utils/isRolldown.native.js");
+var import_toAbsolute = require("../utils/toAbsolute.native.js");
+var import_buildVercelOutputDirectory = require("../vercel/build/buildVercelOutputDirectory.native.js");
+var import_getManifest = require("../vite/getManifest.native.js");
+var import_loadConfig = require("../vite/loadConfig.native.js");
+var import_one_server_only = require("../vite/one-server-only.native.js");
+var import_buildPage = require("./buildPage.native.js");
+var import_checkNodeVersion = require("./checkNodeVersion.native.js");
+var import_workerPool = require("./workerPool.native.js");
+var import_generateSitemap = require("./generateSitemap.native.js");
+var import_label_process = require("./label-process.native.js");
+var import_pLimit = require("../utils/pLimit.native.js");
+var import_criticalCSSPlugin = require("../vite/plugins/criticalCSSPlugin.native.js");
+var import_install_error_handlers = require("./install-error-handlers.native.js");
+const import_meta = {};
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var {
+  ensureDir,
+  writeJSON
+} = import_fs_extra.default;
+function normalizeDeploy(deploy) {
+  if (!deploy) return void 0;
+  if (typeof deploy === "string") return {
+    target: deploy
+  };
+  return deploy;
+}
+var GENERATED_CLOUDFLARE_WRANGLER_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
+}];
+var CLOUDFLARE_DEPLOY_WRANGLER_RULES = [{
+  type: "ESModule",
+  globs: ["assets/**/*.js", "assets/**/*.mjs"]
+}];
+function isPlainObject(value) {
+  return !!value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && !Array.isArray(value);
+}
+function mergeJsonObjects(base, overrides) {
+  var merged = {
+    ...base
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(overrides)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [key, value] = _step.value;
+      var baseValue = merged[key];
+      if (isPlainObject(baseValue) && isPlainObject(value)) {
+        merged[key] = mergeJsonObjects(baseValue, value);
+      } else {
+        merged[key] = value;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return merged;
+}
+function dedupeJsonValues(values) {
+  var seen = /* @__PURE__ */new Set();
+  return values.filter(function (value) {
+    var key = JSON.stringify(value);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function mergeCloudflareCompatibilityFlags(flags) {
+  var userFlags = Array.isArray(flags) ? flags.filter(function (flag) {
+    return typeof flag === "string";
+  }) : [];
+  return dedupeJsonValues(["nodejs_compat", ...userFlags]);
+}
+function mergeCloudflareRules(rules) {
+  var userRules = Array.isArray(rules) ? rules.filter(function (rule) {
+    return isPlainObject(rule);
+  }) : [];
+  return dedupeJsonValues([...GENERATED_CLOUDFLARE_WRANGLER_RULES, ...userRules]);
+}
+function parseJsonc(text) {
+  var out = "";
+  var i = 0;
+  var inString = false;
+  var quote = "";
+  while (i < text.length) {
+    var ch = text[i];
+    var next = text[i + 1];
+    if (inString) {
+      if (ch === "\\") {
+        out += ch + (next !== null && next !== void 0 ? next : "");
+        i += 2;
+        continue;
+      }
+      if (ch === quote) inString = false;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      quote = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < text.length - 1 && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+async function loadUserWranglerConfig(root) {
+  var candidateRoots = [... /* @__PURE__ */new Set([root, process.cwd()])];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = candidateRoots[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var candidateRoot = _step.value;
+      for (var _i = 0, _iter = ["wrangler.jsonc", "wrangler.json"]; _i < _iter.length; _i++) {
+        var fileName = _iter[_i];
+        var configPath = (0, import_path.join)(candidateRoot, fileName);
+        if (!(await import_fs_extra.default.pathExists(configPath))) {
+          continue;
+        }
+        var contents = await import_fs_extra.default.readFile(configPath, "utf-8");
+        var parsed = void 0;
+        try {
+          parsed = parseJsonc(contents);
+        } catch (err) {
+          throw new Error(`Failed to parse ${(0, import_path.relative)(process.cwd(), configPath)}: ${err.message}`);
+        }
+        if (!isPlainObject(parsed)) {
+          throw new Error(`Expected ${(0, import_path.relative)(process.cwd(), configPath)} to contain a top-level JSON object`);
+        }
+        return {
+          path: configPath,
+          config: parsed
+        };
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return null;
+}
+function createCloudflareWranglerConfig(projectName, userConfig) {
+  var generatedConfig = {
+    name: projectName,
+    main: "worker.js",
+    compatibility_date: "2024-12-05",
+    compatibility_flags: ["nodejs_compat"],
+    find_additional_modules: true,
+    rules: GENERATED_CLOUDFLARE_WRANGLER_RULES,
+    assets: {
+      directory: "client",
+      binding: "ASSETS",
+      run_worker_first: true
+    }
+  };
+  var mergedConfig = userConfig ? mergeJsonObjects(generatedConfig, userConfig) : generatedConfig;
+  mergedConfig.main = "worker.js";
+  mergedConfig.find_additional_modules = true;
+  mergedConfig.compatibility_flags = mergeCloudflareCompatibilityFlags(mergedConfig.compatibility_flags);
+  mergedConfig.rules = mergeCloudflareRules(mergedConfig.rules);
+  mergedConfig.assets = {
+    ...(isPlainObject(mergedConfig.assets) ? mergedConfig.assets : {}),
+    directory: "client",
+    binding: "ASSETS",
+    run_worker_first: true
+  };
+  return mergedConfig;
+}
+function omitEmptyJsonValues(value) {
+  if (Array.isArray(value)) {
+    var items = value.map(function (item) {
+      return omitEmptyJsonValues(item);
+    }).filter(function (item) {
+      return item !== void 0;
+    });
+    return items.length > 0 ? items : void 0;
+  }
+  if (isPlainObject(value)) {
+    var entries = Object.entries(value).map(function (param) {
+      var [key, item] = param;
+      return [key, omitEmptyJsonValues(item)];
+    }).filter(function (entry) {
+      return entry[1] !== void 0;
+    });
+    return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+  }
+  return value;
+}
+async function finalizeCloudflareWranglerDeployConfig(configPath) {
+  var parsed = JSON.parse(await import_fs_extra.default.readFile(configPath, "utf-8"));
+  if (!isPlainObject(parsed)) {
+    throw new Error(`Expected ${(0, import_path.relative)(process.cwd(), configPath)} to contain a JSON object`);
+  }
+  parsed.rules = CLOUDFLARE_DEPLOY_WRANGLER_RULES;
+  var config = omitEmptyJsonValues(parsed);
+  if (!isPlainObject(config)) {
+    throw new Error(`Expected ${(0, import_path.relative)(process.cwd(), configPath)} to contain deploy config`);
+  }
+  await import_fs_extra.default.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`);
+}
+async function getCloudflareProjectName(root) {
+  try {
+    var pkg = JSON.parse(await import_fs_extra.default.readFile((0, import_path.join)(root, "package.json"), "utf-8"));
+    if (pkg.name) {
+      return pkg.name.replace(/^@[^/]+\//, "");
+    }
+  } catch (unused) {}
+  return "one-app";
+}
+process.env.ONE_CACHE_KEY = constants.CACHE_KEY;
+function shouldUseWorkers(oneOptions) {
+  var _oneOptions_build;
+  if (process.env.ONE_BUILD_WORKERS === "0") return false;
+  if (process.env.ONE_BUILD_WORKERS === "1") return true;
+  return (oneOptions === null || oneOptions === void 0 ? void 0 : (_oneOptions_build = oneOptions.build) === null || _oneOptions_build === void 0 ? void 0 : _oneOptions_build.workers) !== false;
+}
+(0, import_install_error_handlers.installPrepareStackTraceGuard)();
+var buildErrorHandlersInstalled = false;
+function installBuildErrorHandlers() {
+  if (buildErrorHandlersInstalled) return;
+  buildErrorHandlersInstalled = true;
+  process.on("uncaughtException", function (err) {
+    try {
+      process.stderr.write(`[one build] uncaught exception
+${(0, import_install_error_handlers.formatErrorSafely)(err)}
+`);
+    } catch (unused) {}
+    process.exit(1);
+  });
+  process.on("unhandledRejection", function (reason) {
+    try {
+      process.stderr.write(`[one build] unhandled rejection
+${(0, import_install_error_handlers.formatErrorSafely)(reason)}
+`);
+    } catch (unused) {}
+    process.exit(1);
+  });
+}
+var HOOK_KEYS = ["resolveId", "load", "transform", "renderChunk", "generateBundle", "writeBundle", "buildStart", "buildEnd", "moduleParsed"];
+function clonePluginHooks(config) {
+  if (!config.plugins) return config;
+  return {
+    ...config,
+    plugins: config.plugins.map(function (p) {
+      if (!p || (typeof p === "undefined" ? "undefined" : _type_of(p)) !== "object") return p;
+      var cloned = {
+        ...p
+      };
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = HOOK_KEYS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var key = _step.value;
+          if (cloned[key] && _type_of(cloned[key]) === "object" && "handler" in cloned[key]) {
+            cloned[key] = {
+              ...cloned[key]
+            };
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      return cloned;
+    })
+  };
+}
+async function build(args) {
+  var _process_env_ONE_BUILD_CONCURRENCY, _ref, _ref1, _args_skipEnv, _vxrnOutput_serverBuildConfig, _securityScanOption_level;
+  var _oneOptions_build, _oneOptions_web, _oneOptions_web1, _viteLoadedConfig_config_build, _viteLoadedConfig_config, _oneOptions_router, _oneOptions_build1, _oneOptions_build_server, _oneOptions_build2, _oneOptions_build3, _oneOptions_build4, _oneOptions_web2, _oneOptions_build5;
+  installBuildErrorHandlers();
+  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")
+`);
+  }
+  (0, import_label_process.labelProcess)("build");
+  (0, import_checkNodeVersion.checkNodeVersion)();
+  (0, import_setServerGlobals.setServerGlobals)();
+  var {
+    oneOptions,
+    config: viteLoadedConfig
+  } = await (0, import_loadConfig.loadUserOneOptions)("build");
+  var routerRoot = (0, import_getRouterRootFromOneOptions.getRouterRootFromOneOptions)(oneOptions);
+  var configuredBuildConcurrency = (_process_env_ONE_BUILD_CONCURRENCY = process.env.ONE_BUILD_CONCURRENCY) !== null && _process_env_ONE_BUILD_CONCURRENCY !== void 0 ? _process_env_ONE_BUILD_CONCURRENCY : (_oneOptions_build = oneOptions.build) === null || _oneOptions_build === void 0 ? void 0 : _oneOptions_build.concurrency;
+  var buildConcurrency = configuredBuildConcurrency === void 0 ? Math.max(1, Math.min((0, import_os.cpus)().length, 8)) : Number(configuredBuildConcurrency);
+  if (!Number.isInteger(buildConcurrency) || buildConcurrency < 1) {
+    throw new Error(`build.concurrency must be a positive integer, received ${JSON.stringify(configuredBuildConcurrency)}`);
+  }
+  if ((_oneOptions_web = oneOptions.web) === null || _oneOptions_web === void 0 ? void 0 : _oneOptions_web.defaultRenderMode) {
+    process.env.ONE_DEFAULT_RENDER_MODE = oneOptions.web.defaultRenderMode;
+  }
+  var deployConfig = normalizeDeploy((_oneOptions_web1 = oneOptions.web) === null || _oneOptions_web1 === void 0 ? void 0 : _oneOptions_web1.deploy);
+  if (!process.env.ONE_SERVER_URL && deployConfig) {
+    var _deployConfig_url;
+    var url = (_deployConfig_url = deployConfig.url) !== null && _deployConfig_url !== void 0 ? _deployConfig_url : deployConfig.target === "cloudflare" ? `https://${await getCloudflareProjectName(process.cwd())}.workers.dev` : void 0;
+    if (url) {
+      process.env.ONE_SERVER_URL = url;
+      console.info(`
+ \u2601\uFE0F ONE_SERVER_URL: ${url}
+`);
+    }
+  }
+  var outDir = (_ref = viteLoadedConfig === null || viteLoadedConfig === void 0 ? void 0 : (_viteLoadedConfig_config = viteLoadedConfig.config) === null || _viteLoadedConfig_config === void 0 ? void 0 : (_viteLoadedConfig_config_build = _viteLoadedConfig_config.build) === null || _viteLoadedConfig_config_build === void 0 ? void 0 : _viteLoadedConfig_config_build.outDir) !== null && _ref !== void 0 ? _ref : "dist";
+  var manifest = (0, import_getManifest.getManifest)({
+    routerRoot,
+    ignoredRouteFiles: (_oneOptions_router = oneOptions.router) === null || _oneOptions_router === void 0 ? void 0 : _oneOptions_router.ignoredRouteFiles
+  });
+  var serverOutputFormat = ((_oneOptions_build1 = oneOptions.build) === null || _oneOptions_build1 === void 0 ? void 0 : _oneOptions_build1.server) === false ? "esm" : (_ref1 = (_oneOptions_build2 = oneOptions.build) === null || _oneOptions_build2 === void 0 ? void 0 : (_oneOptions_build_server = _oneOptions_build2.server) === null || _oneOptions_build_server === void 0 ? void 0 : _oneOptions_build_server.outputFormat) !== null && _ref1 !== void 0 ? _ref1 : "esm";
+  var buildStartTime = performance.now();
+  var vxrnOutput = await (0, import_vxrn.build)({
+    skipEnv: (_args_skipEnv = args.skipEnv) !== null && _args_skipEnv !== void 0 ? _args_skipEnv : oneOptions.skipEnv,
+    server: oneOptions.server,
+    build: {
+      analyze: true,
+      server: ((_oneOptions_build3 = oneOptions.build) === null || _oneOptions_build3 === void 0 ? void 0 : _oneOptions_build3.server) === false ? false : {
+        outputFormat: serverOutputFormat
+      }
+    }
+  }, args);
+  var bundleTime = performance.now() - buildStartTime;
+  console.info(`
+ \u23F1\uFE0F vite bundle: ${(bundleTime / 1e3).toFixed(2)}s
+`);
+  if (!vxrnOutput || args.platform !== "web") {
+    return;
+  }
+  var options = await (0, import_vxrn.fillOptions)(vxrnOutput.options, {
+    mode: "prod"
+  });
+  var {
+    optimizeDeps
+  } = (0, import_vxrn.getOptimizeDeps)("build");
+  var {
+    rolldownOptions: _rolldownOptions,
+    ...optimizeDepsNoRolldown
+  } = optimizeDeps;
+  var serverOpts = (_oneOptions_build4 = oneOptions.build) === null || _oneOptions_build4 === void 0 ? void 0 : _oneOptions_build4.server;
+  var isUnified = (typeof serverOpts === "undefined" ? "undefined" : _type_of(serverOpts)) === "object" && serverOpts !== null && serverOpts.unified === true;
+  var baseForApi = isUnified ? clonePluginHooks((_vxrnOutput_serverBuildConfig = vxrnOutput.serverBuildConfig) !== null && _vxrnOutput_serverBuildConfig !== void 0 ? _vxrnOutput_serverBuildConfig : vxrnOutput.webBuildConfig) : clonePluginHooks(vxrnOutput.webBuildConfig);
+  if (isUnified) {
+    var clone = {
+      ...baseForApi,
+      build: baseForApi.build ? {
+        ...baseForApi.build
+      } : void 0,
+      plugins: baseForApi.plugins ? baseForApi.plugins.filter(function (p) {
+        return p && (typeof p === "undefined" ? "undefined" : _type_of(p)) === "object" && p.name !== "omit-api-routes";
+      }) : void 0
+    };
+    if (clone.build && clone.build.rolldownOptions) {
+      var ro = {
+        ...clone.build.rolldownOptions
+      };
+      delete ro.input;
+      clone.build.rolldownOptions = ro;
+    }
+    if (clone.build) {
+      delete clone.build.outDir;
+    }
+    baseForApi = clone;
+  }
+  var apiBuildConfig = (0, import_vite.mergeConfig)(baseForApi, {
+    configFile: false,
+    appType: "custom",
+    optimizeDeps: optimizeDepsNoRolldown,
+    environments: {
+      client: {
+        optimizeDeps: {
+          rolldownOptions: _rolldownOptions
+        }
+      }
+    }
+  });
+  async function buildCustomRoutes(subFolder, routes) {
+    var _ref2;
+    var _oneOptions_build_api, _oneOptions_build6, _oneOptions_build_api1, _oneOptions_build12, _oneOptions_build_api2, _oneOptions_build22;
+    var input = routes.reduce(function (entries, param) {
+      var {
+        page,
+        file: file2
+      } = param;
+      entries[page.slice(1) + ".js"] = (0, import_path.join)(routerRoot, file2);
+      return entries;
+    }, {});
+    var outputFormat = (_ref2 = oneOptions === null || oneOptions === void 0 ? void 0 : (_oneOptions_build6 = oneOptions.build) === null || _oneOptions_build6 === void 0 ? void 0 : (_oneOptions_build_api = _oneOptions_build6.api) === null || _oneOptions_build_api === void 0 ? void 0 : _oneOptions_build_api.outputFormat) !== null && _ref2 !== void 0 ? _ref2 : serverOutputFormat;
+    var treeshake = oneOptions === null || oneOptions === void 0 ? void 0 : (_oneOptions_build12 = oneOptions.build) === null || _oneOptions_build12 === void 0 ? void 0 : (_oneOptions_build_api1 = _oneOptions_build12.api) === null || _oneOptions_build_api1 === void 0 ? void 0 : _oneOptions_build_api1.treeshake;
+    var mergedConfig = (0, import_vite.mergeConfig)(apiBuildConfig, {
+      appType: "custom",
+      configFile: false,
+      define: vxrnOutput.processEnvDefines,
+      ssr: isUnified ? {
+        // in unified mode let the base (serverBuildConfig) set ssr.noExternal
+        // — default is now ['react', 'react-dom'] instead of `true`, so
+        // rolldown can externalize the rest.
+        optimizeDeps: optimizeDepsNoRolldown
+      } : {
+        noExternal: true,
+        external: ["react", "react-dom"],
+        optimizeDeps: optimizeDepsNoRolldown
+      },
+      environments: {
+        ssr: {
+          optimizeDeps: {
+            rolldownOptions: _rolldownOptions
+          }
+        }
+      },
+      build: {
+        ssr: true,
+        emptyOutDir: false,
+        outDir: `${outDir}/${subFolder}`,
+        copyPublicDir: false,
+        minify: false,
+        rolldownOptions: {
+          treeshake: treeshake !== null && treeshake !== void 0 ? treeshake : {
+            moduleSideEffects: false
+          },
+          plugins: [
+          // otherwise rollup is leaving commonjs-only top level imports...
+          outputFormat === "esm" ? import_vxrn.rollupRemoveUnusedImportsPlugin : null].filter(Boolean),
+          // too many issues
+          // treeshake: {
+          //   moduleSideEffects: false,
+          // },
+          // prevents it from shaking out the exports
+          preserveEntrySignatures: "strict",
+          input,
+          // in unified mode, inherit externals from serverBuildConfig (user
+          // ssr.external / rolldownOptions.external). the legacy path resets
+          // them to [] so per-route files bundle everything.
+          ...(isUnified ? {} : {
+            external: []
+          }),
+          output: {
+            entryFileNames: "[name]",
+            exports: "auto",
+            ...(outputFormat === "esm" ? {
+              format: "esm",
+              esModule: true
+            } : {
+              format: "cjs",
+              // Preserve folder structure and use .cjs extension
+              entryFileNames: function (chunkInfo) {
+                var name = chunkInfo.name.replace(/\.js$/, ".cjs");
+                return name;
+              },
+              chunkFileNames: function (chunkInfo) {
+                var chunkName = (0, import_vite.normalizePath)(chunkInfo.name);
+                var dir = import_path.posix.dirname(chunkName);
+                var name = import_path.posix.basename(chunkName, import_path.posix.extname(chunkName));
+                return import_path.posix.join(dir, `${name}-[hash].cjs`);
+              },
+              assetFileNames: function (assetInfo) {
+                var _assetInfo_name;
+                var assetName = (0, import_vite.normalizePath)((_assetInfo_name = assetInfo.name) !== null && _assetInfo_name !== void 0 ? _assetInfo_name : "");
+                var dir = import_path.posix.dirname(assetName);
+                var baseName = import_path.posix.basename(assetName, import_path.posix.extname(assetName));
+                var ext = import_path.posix.extname(assetName);
+                return import_path.posix.join(dir, `${baseName}-[hash]${ext}`);
+              }
+            })
+          }
+        }
+      }
+    });
+    var userApiBuildConf = (_oneOptions_build22 = oneOptions.build) === null || _oneOptions_build22 === void 0 ? void 0 : (_oneOptions_build_api2 = _oneOptions_build22.api) === null || _oneOptions_build_api2 === void 0 ? void 0 : _oneOptions_build_api2.config;
+    var finalApiBuildConf = userApiBuildConf ? (0, import_vite.mergeConfig)(mergedConfig, userApiBuildConf) : mergedConfig;
+    var output3 = await (0, import_vite.build)(
+    // allow user merging api build config
+    finalApiBuildConf);
+    return output3;
+  }
+  var builtMiddlewares = {};
+  var apiPromise = manifest.apiRoutes.length ? (console.info(`
+ \u{1F528} build api routes
+`), buildCustomRoutes("api", manifest.apiRoutes)) : Promise.resolve(null);
+  var middlewarePromise = manifest.middlewareRoutes.length ? (console.info(`
+ \u{1F528} build middlewares
+`), buildCustomRoutes("middlewares", manifest.middlewareRoutes)) : Promise.resolve(null);
+  var [apiOutput, middlewareBuildInfo] = await Promise.all([apiPromise, middlewarePromise]);
+  if (middlewareBuildInfo) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      var _loop = function () {
+        var middleware = _step.value;
+        var absoluteRoot = (0, import_path.resolve)(process.cwd(), options.root);
+        var fullPath = (0, import_vite.normalizePath)((0, import_path.join)(absoluteRoot, routerRoot, middleware.file));
+        var outChunks = middlewareBuildInfo.output.filter(function (x) {
+          return x.type === "chunk";
+        });
+        var chunk2 = outChunks.find(function (x) {
+          return x.facadeModuleId === fullPath;
+        });
+        if (!chunk2) throw new Error(`internal err finding middleware`);
+        builtMiddlewares[middleware.file] = import_path.posix.join(outDir, "middlewares", chunk2.fileName);
+      };
+      for (var _iterator = manifest.middlewareRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  globalThis["require"] = (0, import_module.createRequire)(import_meta.dirname + "/");
+  var assets = [];
+  var builtRoutes = [];
+  var sitemapData = [];
+  var collectImportsCache = /* @__PURE__ */new Map();
+  var collectImportsInFlight = /* @__PURE__ */new Set();
+  var cssFileContentsCache = /* @__PURE__ */new Map();
+  var criticalCSSOutputPaths = (0, import_criticalCSSPlugin.getCriticalCSSOutputPaths)(vxrnOutput.clientManifest);
+  var limit = (0, import_pLimit.pLimit)(buildConcurrency);
+  var useWorkers = shouldUseWorkers(oneOptions);
+  var workerPool = useWorkers ? (0, import_workerPool.getWorkerPool)(buildConcurrency) : null;
+  if (workerPool) {
+    var serializableOptions = JSON.parse(JSON.stringify(oneOptions, function (_key, value) {
+      return typeof value === "function" ? void 0 : value;
+    }));
+    await workerPool.initialize(serializableOptions);
+  }
+  var staticStartTime = performance.now();
+  var modeLabel = useWorkers ? `workers: ${workerPool === null || workerPool === void 0 ? void 0 : workerPool.size}` : `concurrency: ${buildConcurrency}`;
+  console.info(`
+ \u{1F528} build static routes (${modeLabel})
+`);
+  var staticDir = (0, import_path.join)(`${outDir}/static`);
+  var clientDir = (0, import_path.join)(`${outDir}/client`);
+  await ensureDir(staticDir);
+  if (!vxrnOutput.serverOutput) {
+    throw new Error(`No server output`);
+  }
+  var clientChunksBySource = /* @__PURE__ */new Map();
+  if (vxrnOutput.clientOutput) {
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = vxrnOutput.clientOutput[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var chunk = _step1.value;
+        if (chunk.type === "chunk" && chunk.facadeModuleId) {
+          clientChunksBySource.set(chunk.facadeModuleId, {
+            fileName: chunk.fileName,
+            imports: chunk.imports || []
+          });
+        }
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+  }
+  var outputEntries = [...vxrnOutput.serverOutput.entries()];
+  var layoutServerPaths = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = outputEntries[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var [, output] = _step2.value;
+      if (output.type === "asset") continue;
+      var id = output.facadeModuleId || "";
+      var file = import_path.default.basename(id);
+      if (file.startsWith("_layout") && id.includes(`/${routerRoot}/`)) {
+        var relativePath = (0, import_vite.normalizePath)((0, import_path.relative)(process.cwd(), id)).replace(`${routerRoot}/`, "");
+        var contextKey = `./${relativePath}`;
+        layoutServerPaths.set(contextKey, output.fileName);
+      }
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var routeByPath = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion3 = true,
+    _didIteratorError3 = false,
+    _iteratorError3 = void 0;
+  try {
+    for (var _iterator3 = manifest.pageRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      var route = _step3.value;
+      if (route.file) {
+        var routePath = `${routerRoot}${route.file.slice(1)}`;
+        routeByPath.set(routePath, route);
+      }
+    }
+  } catch (err) {
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+        _iterator3.return();
+      }
+    } finally {
+      if (_didIteratorError3) {
+        throw _iteratorError3;
+      }
+    }
+  }
+  var _iteratorNormalCompletion4 = true,
+    _didIteratorError4 = false,
+    _iteratorError4 = void 0;
+  try {
+    for (var _iterator4 = outputEntries[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      var [, output1] = _step4.value;
+      if (output1.type === "asset") {
+        assets.push(output1);
+      }
+    }
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+  var moduleIdToServerChunk = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion5 = true,
+    _didIteratorError5 = false,
+    _iteratorError5 = void 0;
+  try {
+    for (var _iterator5 = outputEntries[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+      var [, output2] = _step5.value;
+      if (output2.type === "asset") continue;
+      var moduleIds = output2.moduleIds || (output2.facadeModuleId ? [output2.facadeModuleId] : []);
+      var _iteratorNormalCompletion6 = true,
+        _didIteratorError6 = false,
+        _iteratorError6 = void 0;
+      try {
+        for (var _iterator6 = moduleIds[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          var moduleId = _step6.value;
+          moduleIdToServerChunk.set(moduleId, output2.fileName);
+          if (moduleId.includes("?one-spa-build")) {
+            moduleIdToServerChunk.set(moduleId.slice(0, moduleId.indexOf("?")), output2.fileName);
+          }
+        }
+      } catch (err) {
+        _didIteratorError6 = true;
+        _iteratorError6 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+            _iterator6.return();
+          }
+        } finally {
+          if (_didIteratorError6) {
+            throw _iteratorError6;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError5 = true;
+    _iteratorError5 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+        _iterator5.return();
+      }
+    } finally {
+      if (_didIteratorError5) {
+        throw _iteratorError5;
+      }
+    }
+  }
+  var _iteratorNormalCompletion7 = true,
+    _didIteratorError7 = false,
+    _iteratorError7 = void 0;
+  try {
+    var _loop1 = async function () {
+      var foundRoute = _step7.value;
+      var _ref2, _ref12;
+      var _vxrnOutput_buildArgs, _foundRoute_layouts, _oneOptions_web3, _oneOptions_web12, _exported_generateStaticParams;
+      if (!foundRoute.file) {
+        return "continue";
+      }
+      var routeModulePath = (0, import_vite.normalizePath)((0, import_path.join)((0, import_path.resolve)(process.cwd(), options.root), routerRoot, foundRoute.file.slice(2)));
+      var serverFileName = moduleIdToServerChunk.get(routeModulePath);
+      if (!serverFileName) {
+        if (foundRoute.type === "spa") {
+          throw new Error(`[one] No build-only server chunk for SPA route: ${foundRoute.file}`);
+        }
+        console.warn(`[one] No server chunk found for route: ${foundRoute.file}`);
+        return "continue";
+      }
+      var onlyBuild = (_vxrnOutput_buildArgs = vxrnOutput.buildArgs) === null || _vxrnOutput_buildArgs === void 0 ? void 0 : _vxrnOutput_buildArgs.only;
+      if (onlyBuild) {
+        var relativeId = foundRoute.file.slice(1);
+        if (!import_micromatch.default.contains(relativeId, onlyBuild)) {
+          return "continue";
+        }
+      }
+      var clientChunk = clientChunksBySource.get(routeModulePath);
+      var manifestKey = `${routerRoot}${foundRoute.file.slice(1)}`;
+      var clientManifestEntry = vxrnOutput.clientManifest[manifestKey];
+      if (!clientChunk && foundRoute.type !== "spa" && foundRoute.type !== "ssg") {
+        console.warn(`No client chunk found for route: ${routeModulePath}`);
+        return "continue";
+      }
+      foundRoute.loaderServerPath = serverFileName;
+      var relativeId1 = foundRoute.file.replace(/^\.\//, "/");
+      if (foundRoute.layouts) {
+        var _iteratorNormalCompletion12 = true,
+          _didIteratorError12 = false,
+          _iteratorError12 = void 0;
+        try {
+          for (var _iterator12 = foundRoute.layouts[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+            var layout = _step12.value;
+            var serverPath = layoutServerPaths.get(layout.contextKey);
+            if (serverPath) {
+              layout.loaderServerPath = serverPath;
+            }
+          }
+        } catch (err) {
+          _didIteratorError12 = true;
+          _iteratorError12 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+              _iterator12.return();
+            }
+          } finally {
+            if (_didIteratorError12) {
+              throw _iteratorError12;
+            }
+          }
+        }
+      }
+      function collectImports(entry2) {
+        var {
+          type = "js"
+        } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var {
+          imports = [],
+          css
+        } = entry2;
+        var cacheKey = `${entry2.file || imports.join(",")}:${type}`;
+        var cached = collectImportsCache.get(cacheKey);
+        if (cached) return cached;
+        if (collectImportsInFlight.has(cacheKey)) return [];
+        collectImportsInFlight.add(cacheKey);
+        var result = [...new Set([...(type === "js" ? imports : css || []), ...imports.flatMap(function (name) {
+          var found = vxrnOutput.clientManifest[name];
+          if (!found) {
+            console.warn(`No found imports`, name, vxrnOutput.clientManifest);
+          }
+          return collectImports(found, {
+            type
+          });
+        })].flat().filter(function (x) {
+          return x && (type === "css" || x.endsWith(".js"));
+        }).map(function (x) {
+          return type === "css" ? x : x.startsWith("assets/") ? x : `assets/${x.slice(1)}`;
+        }))];
+        collectImportsInFlight.delete(cacheKey);
+        collectImportsCache.set(cacheKey, result);
+        return result;
+      }
+      var entryImports = collectImports(clientManifestEntry || {});
+      var layoutEntries = (_ref2 = (_foundRoute_layouts = foundRoute.layouts) === null || _foundRoute_layouts === void 0 ? void 0 : _foundRoute_layouts.flatMap(function (layout2) {
+        var clientKey2 = `${routerRoot}${layout2.contextKey.slice(1)}`;
+        var found = vxrnOutput.clientManifest[clientKey2];
+        return found ? found : [];
+      })) !== null && _ref2 !== void 0 ? _ref2 : [];
+      var layoutImports = layoutEntries.flatMap(function (entry2) {
+        return [entry2.file, ...collectImports(entry2)];
+      });
+      var routePreloads = {};
+      var rootLayoutKey = `${routerRoot}/_layout.tsx`;
+      var rootLayoutEntry = vxrnOutput.clientManifest[rootLayoutKey];
+      if (rootLayoutEntry) {
+        routePreloads[`/${rootLayoutKey}`] = `/${rootLayoutEntry.file}`;
+      }
+      if (foundRoute.layouts) {
+        var _iteratorNormalCompletion13 = true,
+          _didIteratorError13 = false,
+          _iteratorError13 = void 0;
+        try {
+          for (var _iterator13 = foundRoute.layouts[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
+            var layout1 = _step13.value;
+            var clientKey = `${routerRoot}${layout1.contextKey.slice(1)}`;
+            var entry = vxrnOutput.clientManifest[clientKey];
+            if (entry) {
+              routePreloads[`/${clientKey}`] = `/${entry.file}`;
+            }
+          }
+        } catch (err) {
+          _didIteratorError13 = true;
+          _iteratorError13 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+              _iterator13.return();
+            }
+          } finally {
+            if (_didIteratorError13) {
+              throw _iteratorError13;
+            }
+          }
+        }
+      }
+      if (clientChunk) {
+        var routeKey = `/${routerRoot}${foundRoute.file.slice(1)}`;
+        routePreloads[routeKey] = `/${clientChunk.fileName}`;
+      } else if (clientManifestEntry) {
+        var routeKey1 = `/${routerRoot}${foundRoute.file.slice(1)}`;
+        routePreloads[routeKey1] = `/${clientManifestEntry.file}`;
+      }
+      var preloadSetupFilePreloads = function () {
+        if (!oneOptions.setupFile) return [];
+        var clientSetupFile = typeof oneOptions.setupFile === "string" ? oneOptions.setupFile : oneOptions.setupFile.client;
+        if (!clientSetupFile) return [];
+        var needle = clientSetupFile.replace(/^\.\//, "");
+        for (var file2 in vxrnOutput.clientManifest) {
+          if (file2 === needle) {
+            var entry2 = vxrnOutput.clientManifest[file2];
+            return [entry2.file];
+          }
+        }
+        return [];
+      }();
+      var 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(function (path2) {
+        return `/${path2}`;
+      });
+      var scriptLoadingMode = (_oneOptions_web3 = oneOptions.web) === null || _oneOptions_web3 === void 0 ? void 0 : _oneOptions_web3.experimental_scriptLoading;
+      var useDeferredLoading = scriptLoadingMode === "defer-non-critical";
+      var useAggressiveLCP = scriptLoadingMode === "after-lcp-aggressive";
+      var needsSeparatedPreloads = useDeferredLoading || useAggressiveLCP;
+      var 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(function (entry2) {
+        return entry2.file;
+      })])].map(function (path2) {
+        return `/${path2}`;
+      }) : void 0;
+      var deferredPreloads = needsSeparatedPreloads ? [... /* @__PURE__ */new Set([...entryImports, ...layoutEntries.flatMap(function (entry2) {
+        return collectImports(entry2);
+      })])].filter(function (path2) {
+        return !criticalPreloads.includes(`/${path2}`);
+      }).map(function (path2) {
+        return `/${path2}`;
+      }) : void 0;
+      var preloads2 = needsSeparatedPreloads ? [...criticalPreloads, ...deferredPreloads] : allPreloads;
+      var allEntries = [clientManifestEntry, ...layoutEntries].filter(Boolean);
+      var layoutCSS = [...new Set(layoutEntries.flatMap(function (entry2) {
+        return collectImports(entry2, {
+          type: "css"
+        });
+      }).map(function (path2) {
+        return `/${path2}`;
+      }))];
+      var allCSS = [... /* @__PURE__ */new Set([...layoutCSS,
+      // css from page entry
+      ...(clientManifestEntry ? collectImports(clientManifestEntry, {
+        type: "css"
+      }).map(function (path2) {
+        return `/${path2}`;
+      }) : []),
+      // root-level css for cssCodeSplit: false (vite emits a single
+      // top-level `style.css` entry whose `src` equals `style.css`). when
+      // cssCodeSplit is true (default), the manifest also contains a
+      // per-component css entry for every chunk that ships any css — those
+      // are owned by their JS chunk and must NOT be injected globally, or
+      // every SSG page ends up preloading every css chunk in the project
+      // (the prod /download was loading 23 stylesheets with editor/IDE
+      // chunks despite being a marketing route).
+      ...Object.entries(vxrnOutput.clientManifest).filter(function (param) {
+        var [key, entry2] = param;
+        if (!key.endsWith(".css")) return false;
+        var src = entry2.src;
+        return src === "style.css";
+      }).map(function (param) {
+        var [, entry2] = param;
+        return `/${entry2.file}`;
+      })])];
+      var hasCriticalCSS = allCSS.some(function (p) {
+        return criticalCSSOutputPaths.has(p);
+      });
+      var needsCSSContents = ((_oneOptions_web12 = oneOptions.web) === null || _oneOptions_web12 === void 0 ? void 0 : _oneOptions_web12.inlineLayoutCSS) || hasCriticalCSS;
+      var allCSSContents = void 0;
+      if (needsCSSContents) {
+        allCSSContents = await Promise.all(allCSS.map(async function (cssPath) {
+          var _oneOptions_web4;
+          if (!((_oneOptions_web4 = oneOptions.web) === null || _oneOptions_web4 === void 0 ? void 0 : _oneOptions_web4.inlineLayoutCSS) && !criticalCSSOutputPaths.has(cssPath)) {
+            return "";
+          }
+          var cached = cssFileContentsCache.get(cssPath);
+          if (cached !== void 0) return cached;
+          var filePath = (0, import_path.join)(clientDir, cssPath);
+          try {
+            var content = await import_fs_extra.default.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
+        });
+      }
+      var serverJsPath = import_path.posix.join(outDir, "server", serverFileName);
+      var exported = void 0;
+      try {
+        exported = await import((0, import_toAbsolute.toAbsoluteUrl)(serverJsPath));
+      } catch (err) {
+        console.error(`Error importing page (original error)`, err);
+        throw new Error(`Error importing page: ${serverJsPath}`, {
+          cause: err
+        });
+      }
+      foundRoute.hasLoader = typeof exported.loader === "function";
+      var 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
+
+`);
+      }
+      var paramsList = (_ref12 = await ((_exported_generateStaticParams = exported.generateStaticParams) === null || _exported_generateStaticParams === void 0 ? void 0 : _exported_generateStaticParams.call(exported))) !== null && _ref12 !== void 0 ? _ref12 : [{}];
+      console.info(`
+ [build] page ${relativeId1} (with ${paramsList.length} routes)
+`);
+      if (process.env.DEBUG) {
+        console.info(`paramsList`, JSON.stringify(paramsList, null, 2));
+      }
+      var routeSitemapExport = exported.sitemap;
+      var isAfterLCPMode = scriptLoadingMode === "after-lcp" || scriptLoadingMode === "after-lcp-aggressive";
+      var useAfterLCP = foundRoute.type === "ssg" && isAfterLCPMode;
+      var useAfterLCPAggressive = foundRoute.type === "ssg" && scriptLoadingMode === "after-lcp-aggressive";
+      var shouldCollectSitemap = foundRoute.type !== "api" && foundRoute.type !== "layout" && !foundRoute.isNotFound && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap");
+      var pageBuilds = paramsList.map(function (params) {
+        var path2 = (0, import_getPathnameFromFilePath.getPathnameFromFilePath)(relativeId1, params, foundRoute.type === "ssg");
+        if (workerPool) {
+          console.info(`  \u21A6 route ${path2}`);
+          return workerPool.buildPage({
+            serverEntry: vxrnOutput.serverEntry,
+            path: path2,
+            relativeId: relativeId1,
+            params,
+            foundRoute,
+            clientManifestEntry,
+            staticDir,
+            clientDir,
+            builtMiddlewares,
+            serverJsPath,
+            preloads: preloads2,
+            allCSS,
+            layoutCSS,
+            routePreloads,
+            allCSSContents,
+            criticalPreloads,
+            deferredPreloads,
+            useAfterLCP,
+            useAfterLCPAggressive
+          }).then(function (built2) {
+            return {
+              built: built2,
+              path: path2
+            };
+          });
+        }
+        return limit(async function () {
+          console.info(`  \u21A6 route ${path2}`);
+          var built2 = await (0, import_one_server_only.runWithAsyncLocalContext)(async function () {
+            return await (0, import_buildPage.buildPage)(vxrnOutput.serverEntry, path2, relativeId1, params, foundRoute, clientManifestEntry, staticDir, clientDir, builtMiddlewares, serverJsPath, preloads2, allCSS, layoutCSS, routePreloads, allCSSContents, criticalPreloads, deferredPreloads, useAfterLCP, useAfterLCPAggressive);
+          });
+          return {
+            built: built2,
+            path: path2
+          };
+        });
+      });
+      var results = await Promise.all(pageBuilds);
+      var _iteratorNormalCompletion22 = true,
+        _didIteratorError22 = false,
+        _iteratorError22 = void 0;
+      try {
+        for (var _iterator22 = results[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
+          var {
+            built,
+            path
+          } = _step22.value;
+          builtRoutes.push(built);
+          if (shouldCollectSitemap) {
+            sitemapData.push({
+              path,
+              routeExport: routeSitemapExport
+            });
+          }
+        }
+      } catch (err) {
+        _didIteratorError22 = true;
+        _iteratorError22 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
+            _iterator22.return();
+          }
+        } finally {
+          if (_didIteratorError22) {
+            throw _iteratorError22;
+          }
+        }
+      }
+    };
+    for (var _iterator7 = manifest.pageRoutes[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) await _loop1();
+  } catch (err) {
+    _didIteratorError7 = true;
+    _iteratorError7 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+        _iterator7.return();
+      }
+    } finally {
+      if (_didIteratorError7) {
+        throw _iteratorError7;
+      }
+    }
+  }
+  if (workerPool) {
+    await (0, import_workerPool.terminateWorkerPool)();
+  }
+  var staticTime = performance.now() - staticStartTime;
+  console.info(`
+ \u23F1\uFE0F static routes: ${(staticTime / 1e3).toFixed(2)}s (${builtRoutes.length} pages)
+`);
+  (0, import_buildPage.printBuildTimings)();
+  await moveAllFiles(staticDir, clientDir);
+  await import_fs_extra.default.remove(staticDir);
+  var routeMap = {};
+  var routeToBuildInfo = {};
+  var pathToRoute = {};
+  var preloads = {};
+  var cssPreloads = {};
+  var loaders = {};
+  var cssContentsByPath;
+  var _iteratorNormalCompletion8 = true,
+    _didIteratorError8 = false,
+    _iteratorError8 = void 0;
+  try {
+    var _loop2 = function () {
+      var route2 = _step8.value;
+      if (!route2.cleanPath.includes("*")) {
+        routeMap[route2.cleanPath] = route2.htmlPath;
+      }
+      var {
+        // dont include loaderData it can be huge
+        loaderData: _loaderData,
+        cssContents,
+        ...rest
+      } = route2;
+      if (cssContents) {
+        var contentsByPath = cssContentsByPath || (cssContentsByPath = {});
+        route2.css.forEach(function (cssPath, index) {
+          var content = cssContents[index];
+          if (content) contentsByPath[cssPath] = content;
+        });
+      }
+      routeToBuildInfo[route2.routeFile] = rest;
+      var _iteratorNormalCompletion12 = true,
+        _didIteratorError12 = false,
+        _iteratorError12 = void 0;
+      try {
+        for (var _iterator12 = getCleanPaths([route2.path, route2.cleanPath])[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+          var p = _step12.value;
+          pathToRoute[p] = route2.routeFile;
+        }
+      } catch (err) {
+        _didIteratorError12 = true;
+        _iteratorError12 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+            _iterator12.return();
+          }
+        } finally {
+          if (_didIteratorError12) {
+            throw _iteratorError12;
+          }
+        }
+      }
+      preloads[route2.preloadPath] = true;
+      cssPreloads[route2.cssPreloadPath] = true;
+      loaders[route2.loaderPath] = true;
+    };
+    for (var _iterator8 = builtRoutes[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) _loop2();
+  } catch (err) {
+    _didIteratorError8 = true;
+    _iteratorError8 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+        _iterator8.return();
+      }
+    } finally {
+      if (_didIteratorError8) {
+        throw _iteratorError8;
+      }
+    }
+  }
+  function createBuildManifestRoute(route2) {
+    var {
+      layouts,
+      ...built
+    } = route2;
+    if (layouts === null || layouts === void 0 ? void 0 : layouts.length) {
+      ;
+      built.layouts = layouts.map(function (layout) {
+        return {
+          contextKey: layout.contextKey,
+          loaderServerPath: layout.loaderServerPath
+        };
+      });
+    }
+    var buildInfo = builtRoutes.find(function (x) {
+      return x.routeFile === route2.file;
+    });
+    if (built.middlewares) {
+      var _iteratorNormalCompletion12 = true,
+        _didIteratorError12 = false,
+        _iteratorError12 = void 0;
+      try {
+        for (var _iterator12 = built.middlewares.entries()[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+          var [index, mw] = _step12.value;
+          var _buildInfo_middlewares;
+          var viaBuildInfo = buildInfo === null || buildInfo === void 0 ? void 0 : (_buildInfo_middlewares = buildInfo.middlewares) === null || _buildInfo_middlewares === void 0 ? void 0 : _buildInfo_middlewares[index];
+          if (viaBuildInfo) {
+            mw.contextKey = viaBuildInfo;
+            continue;
+          }
+          var viaMiddlewareMap = builtMiddlewares[mw.contextKey];
+          if (viaMiddlewareMap) {
+            mw.contextKey = viaMiddlewareMap;
+          }
+        }
+      } catch (err) {
+        _didIteratorError12 = true;
+        _iteratorError12 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+            _iterator12.return();
+          }
+        } finally {
+          if (_didIteratorError12) {
+            throw _iteratorError12;
+          }
+        }
+      }
+    }
+    if (buildInfo) {
+      built.loaderPath = buildInfo.loaderPath;
+    }
+    return built;
+  }
+  var buildInfoForWriting = {
+    outDir,
+    oneOptions,
+    routeToBuildInfo,
+    cssContentsByPath,
+    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 (0, import_isRolldown.isRolldown)()
+  };
+  await writeJSON((0, import_toAbsolute.toAbsolute)(`${outDir}/buildInfo.json`), buildInfoForWriting);
+  await (0, import_buildOutputPointer.writeBuildOutputPointer)(outDir);
+  await import_fs_extra.default.writeFile((0, import_path.join)(clientDir, "version.json"), JSON.stringify({
+    version: constants.CACHE_KEY
+  }));
+  console.info(`
+ \u{1F6E1} skew protection: emitted version.json
+`);
+  var sitemapConfig = (_oneOptions_web2 = oneOptions.web) === null || _oneOptions_web2 === void 0 ? void 0 : _oneOptions_web2.sitemap;
+  if (sitemapConfig) {
+    var sitemapOptions = typeof sitemapConfig === "boolean" ? {} : sitemapConfig;
+    var sitemapXml = (0, import_generateSitemap.generateSitemap)(sitemapData, sitemapOptions);
+    var sitemapPath = (0, import_path.join)(clientDir, "sitemap.xml");
+    await import_fs_extra.default.writeFile(sitemapPath, sitemapXml);
+    console.info(`
+ \u{1F4C4} generated sitemap.xml (${sitemapData.length} URLs)
+`);
+  }
+  var postBuildLogs = [];
+  var platform = deployConfig === null || deployConfig === void 0 ? void 0 : deployConfig.target;
+  if (platform) {
+    postBuildLogs.push(`[one.build] platform ${platform}`);
+  }
+  switch (platform) {
+    case "vercel":
+      {
+        var vercelJsonPath = (0, import_path.join)(options.root, "vercel.json");
+        if (import_fs_extra.default.existsSync(vercelJsonPath)) {
+          try {
+            var vercelConfig = JSON.parse(import_fs_extra.default.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 (unused) {}
+        }
+        await (0, import_buildVercelOutputDirectory.buildVercelOutputDirectory)({
+          apiOutput,
+          buildInfoForWriting,
+          clientDir,
+          oneOptionsRoot: options.root,
+          postBuildLogs
+        });
+        break;
+      }
+    case "cloudflare":
+      {
+        var workerSrcDir = (0, import_path.join)(options.root, outDir);
+        var getWorkerSourceImportPath = function (routeFile2) {
+          var importPath3 = (0, import_vite.normalizePath)((0, import_path.relative)(workerSrcDir, (0, import_path.join)(options.root, routerRoot, routeFile2)));
+          return importPath3.startsWith(".") ? importPath3 : `./${importPath3}`;
+        };
+        var pageRouteMap = [];
+        var apiRouteMap = [];
+        var middlewareRouteMap = [];
+        var _iteratorNormalCompletion9 = true,
+          _didIteratorError9 = false,
+          _iteratorError9 = void 0;
+        try {
+          for (var _iterator9 = Object.entries(buildInfoForWriting.routeToBuildInfo)[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+            var [routeFile, info] = _step9.value;
+            if (info.serverJsPath) {
+              var importPath = "./" + info.serverJsPath.replace(new RegExp(`^${outDir}/`), "");
+              pageRouteMap.push(`  '${routeFile}': () => import('${importPath}')`);
+            }
+          }
+        } catch (err) {
+          _didIteratorError9 = true;
+          _iteratorError9 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+              _iterator9.return();
+            }
+          } finally {
+            if (_didIteratorError9) {
+              throw _iteratorError9;
+            }
+          }
+        }
+        var _iteratorNormalCompletion10 = true,
+          _didIteratorError10 = false,
+          _iteratorError10 = void 0;
+        try {
+          for (var _iterator10 = buildInfoForWriting.manifest.apiRoutes[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+            var route1 = _step10.value;
+            if (route1.file) {
+              var importPath1 = getWorkerSourceImportPath(route1.file);
+              apiRouteMap.push(`  '${route1.page}': () => import('${importPath1}')`);
+            }
+          }
+        } catch (err) {
+          _didIteratorError10 = true;
+          _iteratorError10 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+              _iterator10.return();
+            }
+          } finally {
+            if (_didIteratorError10) {
+              throw _iteratorError10;
+            }
+          }
+        }
+        var _iteratorNormalCompletion11 = true,
+          _didIteratorError11 = false,
+          _iteratorError11 = void 0;
+        try {
+          for (var _iterator11 = Object.entries(builtMiddlewares)[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
+            var [sourceFile, builtPath] = _step11.value;
+            var importPath2 = getWorkerSourceImportPath(sourceFile);
+            middlewareRouteMap.push(`  '${builtPath}': () => import('${importPath2}')`);
+          }
+        } catch (err) {
+          _didIteratorError11 = true;
+          _iteratorError11 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+              _iterator11.return();
+            }
+          } finally {
+            if (_didIteratorError11) {
+              throw _iteratorError11;
+            }
+          }
+        }
+        var workerSrcPath = (0, import_path.join)(options.root, outDir, "_worker-src.js");
+        var 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(",\n")}
+  },
+  api: {
+${apiRouteMap.join(",\n")}
+  },
+  middlewares: {
+${middlewareRouteMap.join(",\n")}
+  }
+}
+
+const buildInfo = ${JSON.stringify(buildInfoForWriting)}
+
+let server
+
+export default {
+  async fetch(request, env, ctx) {
+    if (!server) {
+      server = 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 {
+      const response = await server.fetch(request, env, ctx)
+
+      // no route matched or 404 \u2192 try static assets
+      if (!response || response.status === 404) {
+        if (env.ASSETS) {
+          try {
+            const assetResponse = await env.ASSETS.fetch(request)
+            if (assetResponse && assetResponse.status !== 404) {
+              return assetResponse
+            }
+          } catch (e) {
+            // asset not found, continue with original response
+          }
+        }
+      }
+
+      return response
+    } finally {
+      setFetchStaticHtml(null)
+    }
+  }
+}
+`;
+        await import_fs_extra.default.writeFile(workerSrcPath, workerCode);
+        var projectName = await getCloudflareProjectName(options.root);
+        var userWranglerConfig = await loadUserWranglerConfig(options.root);
+        var wranglerInputConfig = createCloudflareWranglerConfig(projectName, userWranglerConfig === null || userWranglerConfig === void 0 ? void 0 : userWranglerConfig.config);
+        wranglerInputConfig.main = (0, import_vite.normalizePath)((0, import_path.relative)((0, import_path.join)(options.root, outDir), workerSrcPath));
+        var wranglerInputPath = (0, import_path.join)(options.root, outDir, "_wrangler.input.jsonc");
+        await import_fs_extra.default.writeFile(wranglerInputPath, `${JSON.stringify(wranglerInputConfig, null, 2)}
+`);
+        console.info("\n [cloudflare] Bundling worker...");
+        var {
+          cloudflare
+        } = await import("@cloudflare/vite-plugin");
+        var builder = await (0, import_vite.createBuilder)({
+          root: options.root,
+          mode: "production",
+          logLevel: "warn",
+          configFile: false,
+          define: {
+            "process.env.NODE_ENV": JSON.stringify("production"),
+            "process.env.VITE_ENVIRONMENT": JSON.stringify("ssr"),
+            "process.env.ONE_CACHE_KEY": JSON.stringify(constants.CACHE_KEY)
+          },
+          plugins: [
+          // the cloudflare worker IS a server, but this build runs with
+          // configFile:false so the user vite.config (where the user-level
+          // `one()` plugin registers environmentGuardPlugin via vite.config)
+          // doesn't apply. register the guard plugin directly here so
+          // `import 'server-only'` resolves to an empty module in the
+          // worker bundle instead of inlining the package's throwing
+          // index.js — which would crash the deployed worker on the first
+          // /api request that loads any server-only-importing module.
+          (0, import_environmentGuardPlugin.environmentGuardPlugin)(oneOptions.environmentGuards), cloudflare({
+            configPath: wranglerInputPath,
+            viteEnvironment: {
+              name: "worker"
+            }
+          })],
+          resolve: {
+            alias: [
+            // rolldown can't parse react-native's Flow syntax; alias to react-native-web for ssr
+            {
+              find: /^react-native\/Libraries\/.*/,
+              replacement: (0, import_resolve.resolvePath)("@vxrn/vite-plugin-metro/empty", options.root)
+            }, {
+              find: "react-native/package.json",
+              replacement: (0, import_resolve.resolvePath)("react-native-web/package.json", options.root)
+            }, {
+              find: "react-native",
+              replacement: (0, import_resolve.resolvePath)("react-native-web", options.root)
+            }, {
+              find: "react-native-safe-area-context",
+              replacement: (0, import_resolve.resolvePath)("@vxrn/safe-area", options.root)
+            }]
+          },
+          build: {
+            outDir,
+            emptyOutDir: false,
+            rolldownOptions: {
+              // Match the main web build behavior so RN packages that import
+              // native-only symbols from react-native can still bundle against
+              // the react-native-web alias in the worker graph.
+              shimMissingExports: true,
+              // cloudflare's module worker can contain circular shared chunks
+              // when one package is used by both browser-facing SSR code and API
+              // routes. preserve source import order so a dependent chunk cannot
+              // evaluate against partially initialized exports.
+              output: {
+                strictExecutionOrder: true
+              }
+            }
+          }
+        });
+        var workerEnv = builder.environments.worker;
+        if (!workerEnv) {
+          throw new Error('[one] plugin did not register "worker" environment');
+        }
+        await builder.build(workerEnv);
+        await import_fs_extra.default.remove(workerSrcPath);
+        await import_fs_extra.default.remove(wranglerInputPath);
+        await finalizeCloudflareWranglerDeployConfig((0, import_path.join)(options.root, outDir, "worker", "wrangler.json"));
+        if (userWranglerConfig) {
+          console.info(` [cloudflare] Merging ${(0, import_path.relative)(options.root, userWranglerConfig.path)} into ${outDir}/worker/wrangler.json`);
+        }
+        postBuildLogs.push(`Cloudflare worker bundled at ${outDir}/worker/index.js`);
+        postBuildLogs.push(`To deploy: wrangler deploy`);
+        break;
+      }
+  }
+  var securityScanOption = (_oneOptions_build5 = oneOptions.build) === null || _oneOptions_build5 === void 0 ? void 0 : _oneOptions_build5.securityScan;
+  var securityScanLevel = securityScanOption === false ? null : securityScanOption === true || securityScanOption === void 0 ? "warn" : typeof securityScanOption === "string" ? securityScanOption : (_securityScanOption_level = securityScanOption.level) !== null && _securityScanOption_level !== void 0 ? _securityScanOption_level : "warn";
+  var securitySafePatterns = (typeof securityScanOption === "undefined" ? "undefined" : _type_of(securityScanOption)) === "object" && securityScanOption !== null ? securityScanOption.safePatterns : void 0;
+  if (securityScanLevel) {
+    var {
+      runSecurityScan
+    } = await import("./securityScan");
+    var passed = await runSecurityScan(clientDir, securityScanLevel, securitySafePatterns);
+    if (!passed) {
+      process.exit(1);
+    }
+  }
+  if (postBuildLogs.length) {
+    console.info(`
+
+`);
+    postBuildLogs.forEach(function (log) {
+      console.info(`  \xB7 ${log}`);
+    });
+  }
+  console.info(`
+ \u{1F49B} build complete
+`);
+}
+var TRAILING_INDEX_REGEX = /\/index(\.(web))?/;
+function getCleanPaths(possiblePaths) {
+  return Array.from(new Set(Array.from(new Set(possiblePaths)).flatMap(function (p) {
+    var paths = [p];
+    if (p.match(TRAILING_INDEX_REGEX)) {
+      var pathWithTrailingIndexRemoved = p.replace(TRAILING_INDEX_REGEX, "");
+      paths.push(pathWithTrailingIndexRemoved);
+      paths.push(pathWithTrailingIndexRemoved + "/");
+    }
+    return paths;
+  })));
+}
+async function moveAllFiles(src, dest) {
+  try {
+    await import_fs_extra.default.copy(src, dest, {
+      overwrite: true,
+      errorOnExist: false
+    });
+  } catch (err) {
+    console.error("Error moving files:", err);
+  }
+}
+//# sourceMappingURL=build.native.js.map