vxrn 0.1.50 → 0.1.52

package/dist/cjs/utils/swapPrebuiltReactModules.native.js

@@ -0,0 +1,272 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var swapPrebuiltReactModules_exports = {};
+__export(swapPrebuiltReactModules_exports, {
+  swapPrebuiltReactModules: () => swapPrebuiltReactModules
+});
+module.exports = __toCommonJS(swapPrebuiltReactModules_exports);
+var import_promises = require("node:fs/promises"), import_node_path = require("node:path"), import_react_native_prebuilt = require("@vxrn/react-native-prebuilt"), import_resolveFile = require("./resolveFile"), import_fs_extra = __toESM(require("fs-extra"), 1), import_isBuildingNativeBundle = require("./isBuildingNativeBundle");
+function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve2(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve2, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+function swapPrebuiltReactModules(cacheDir) {
+  return _swapPrebuiltReactModules.apply(this, arguments);
+}
+function _swapPrebuiltReactModules() {
+  return _swapPrebuiltReactModules = _async_to_generator(function(cacheDir) {
+    var prebuilds, jsxRuntime, _tmp, virtualModules, _tmp1, _, _tmp2, _tmp3;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return prebuilds = {
+            reactJSX: (0, import_node_path.join)(cacheDir, "react-jsx-runtime.js"),
+            react: (0, import_node_path.join)(cacheDir, "react.js"),
+            reactNative: (0, import_node_path.join)(cacheDir, "react-native.js")
+          }, [
+            4,
+            import_fs_extra.default.pathExists(prebuilds.reactNative)
+          ];
+        case 1:
+          return _state.sent() ? [
+            3,
+            3
+          ] : (console.info("Pre-building react, react-native react/jsx-runtime (one time cost)..."), [
+            4,
+            Promise.all([
+              (0, import_react_native_prebuilt.buildReactNative)({
+                entryPoints: [
+                  (0, import_resolveFile.resolveFile)("react-native")
+                ],
+                outfile: prebuilds.reactNative
+              }),
+              (0, import_react_native_prebuilt.buildReact)({
+                entryPoints: [
+                  (0, import_resolveFile.resolveFile)("react")
+                ],
+                outfile: prebuilds.react
+              }),
+              (0, import_react_native_prebuilt.buildReactJSX)({
+                entryPoints: [
+                  (0, import_resolveFile.resolveFile)("react/jsx-dev-runtime")
+                ],
+                outfile: prebuilds.reactJSX
+              })
+            ])
+          ]);
+        case 2:
+          _state.sent(), _state.label = 3;
+        case 3:
+          return _tmp = {
+            // alias: 'virtual:react-jsx',
+            alias: prebuilds.reactJSX
+          }, [
+            4,
+            (0, import_promises.readFile)(prebuilds.reactJSX, "utf-8")
+          ];
+        case 4:
+          return jsxRuntime = (_tmp.contents = _state.sent(), _tmp), _tmp1 = {}, _ = "react-native", _tmp2 = {
+            // alias: 'virtual:react-native',
+            alias: prebuilds.reactNative
+          }, [
+            4,
+            (0, import_promises.readFile)(prebuilds.reactNative, "utf-8")
+          ];
+        case 5:
+          return _tmp1[_] = (_tmp2.contents = _state.sent(), _tmp2), _tmp3 = {
+            // alias: 'virtual:react',
+            alias: prebuilds.react
+          }, [
+            4,
+            (0, import_promises.readFile)(prebuilds.react, "utf-8")
+          ];
+        case 6:
+          return virtualModules = (_tmp1.react = (_tmp3.contents = _state.sent(), _tmp3), _tmp1["react/jsx-runtime"] = jsxRuntime, _tmp1["react/jsx-dev-runtime"] = jsxRuntime, _tmp1), [
+            2,
+            {
+              name: "swap-react-native",
+              enforce: "pre",
+              resolveId: function(id) {
+                var importer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+                if (id.startsWith("react-native/Libraries"))
+                  return "virtual:rn-internals:".concat(id);
+                if (id === "react-native-web")
+                  return prebuilds.reactNative;
+                for (var targetId in virtualModules)
+                  if (id === targetId || id.includes("node_modules/".concat(targetId, "/"))) {
+                    var info = virtualModules[targetId];
+                    return info.alias;
+                  }
+                if (import_isBuildingNativeBundle.isBuildingNativeBundle && id[0] === ".") {
+                  var absolutePath = (0, import_node_path.resolve)((0, import_node_path.dirname)(importer), id), nativePath = absolutePath.replace(/(.m?js)/, ".native.js");
+                  if (nativePath === id)
+                    return;
+                  try {
+                    var directoryPath = absolutePath + "/index.native.js", directoryNonNativePath = absolutePath + "/index.js";
+                    if (import_fs_extra.default.pathExistsSync(directoryPath))
+                      return directoryPath;
+                    if (import_fs_extra.default.pathExistsSync(directoryNonNativePath))
+                      return directoryNonNativePath;
+                    if (import_fs_extra.default.pathExistsSync(nativePath))
+                      return nativePath;
+                  } catch (err) {
+                    console.warn("error probably fine", err);
+                  }
+                }
+              },
+              load: function(id) {
+                if (id.startsWith("virtual:rn-internals")) {
+                  var idOut = id.replace("virtual:rn-internals:", ""), out = 'const ___val = __cachedModules["'.concat(idOut, `"]
+        const ___defaultVal = ___val ? ___val.default || ___val : ___val
+        export default ___defaultVal`);
+                  return out;
+                }
+                for (var targetId in virtualModules) {
+                  var info = virtualModules[targetId];
+                  if (id === info.alias)
+                    return info.contents;
+                }
+              }
+            }
+          ];
+      }
+    });
+  }), _swapPrebuiltReactModules.apply(this, arguments);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  swapPrebuiltReactModules
+});
+//# sourceMappingURL=swapPrebuiltReactModules.js.map

package/dist/cjs/utils/swapPrebuiltReactModules.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/swapPrebuiltReactModules.ts"],
+  "mappings": "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",
+  "names": ["swapPrebuiltReactModules", "cacheDir", "prebuilds", "jsxRuntime", "virtualModules", "reactJSX", "join", "react", "reactNative", "FSExtra", "pathExists", "console", "info", "Promise", "all", "buildReactNative", "entryPoints", "resolveFile", "outfile", "buildReact", "buildReactJSX", "alias", "readFile", "contents", "name", "enforce", "resolveId", "id", "importer", "startsWith", "targetId", "includes", "isBuildingNativeBundle", "absolutePath", "resolve", "dirname", "nativePath", "replace", "directoryPath", "directoryNonNativePath", "pathExistsSync", "err", "warn", "load", "idOut", "out"]
+}

package/dist/cjs/utils/uniq.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var uniq_exports = {};
+__export(uniq_exports, {
+  uniq: () => uniq
+});
+module.exports = __toCommonJS(uniq_exports);
+function uniq(a) {
+  return [...new Set(a)];
+}
+//# sourceMappingURL=uniq.js.map

package/dist/cjs/utils/uniq.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/uniq.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,KAAK,GAAU;AAC7B,SAAO,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;AACvB;",
+  "names": []
+}

package/dist/cjs/utils/uniq.native.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var uniq_exports = {};
+__export(uniq_exports, {
+  uniq: () => uniq
+});
+module.exports = __toCommonJS(uniq_exports);
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function uniq(a) {
+  return _to_consumable_array(new Set(a));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uniq
+});
+//# sourceMappingURL=uniq.js.map

package/dist/cjs/utils/uniq.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/uniq.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,SAASA,KAAKC,GAAQ;AAC3B,SAAQ,qBAAG,IAAIC,IAAID,CAAAA,CAAAA;AACrB;",
+  "names": ["uniq", "a", "Set"]
+}

package/dist/esm/exports/bindKeypressInput.js

@@ -0,0 +1,34 @@
+import readline from "node:readline";
+function bindKeypressInput() {
+  if (!process.stdin.setRawMode) {
+    console.warn({
+      msg: "Interactive mode is not supported in this environment"
+    });
+    return;
+  }
+  readline.emitKeypressEvents(process.stdin), process.stdin.setRawMode(!0), process.stdin.on("keypress", (_key, data) => {
+    const { ctrl, name } = data;
+    if (ctrl === !0)
+      switch (name) {
+        case "c":
+          process.exit();
+        case "z":
+          process.emit("SIGTSTP", "SIGTSTP");
+          break;
+      }
+    else
+      switch (name) {
+        case "r":
+          break;
+        case "d":
+          break;
+        case "c":
+          process.stdout.write("\x1B[2J\x1B[0;0H");
+          break;
+      }
+  });
+}
+export {
+  bindKeypressInput
+};
+//# sourceMappingURL=bindKeypressInput.js.map

package/dist/esm/exports/bindKeypressInput.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exports/bindKeypressInput.ts"],
+  "mappings": "AAAA,OAAO,cAAc;AAEd,SAAS,oBAAoB;AAClC,MAAI,CAAC,QAAQ,MAAM,YAAY;AAC7B,YAAQ,KAAK;AAAA,MACX,KAAK;AAAA,IACP,CAAC;AACD;AAAA,EACF;AAEA,WAAS,mBAAmB,QAAQ,KAAK,GACzC,QAAQ,MAAM,WAAW,EAAI,GAE7B,QAAQ,MAAM,GAAG,YAAY,CAAC,MAAM,SAAS;AAC3C,UAAM,EAAE,MAAM,KAAK,IAAI;AACvB,QAAI,SAAS;AACX,cAAQ,MAAM;AAAA,QAEZ,KAAK;AACH,kBAAQ,KAAK;AAAA,QACf,KAAK;AACH,kBAAQ,KAAK,WAAW,SAAS;AACjC;AAAA,MACJ;AAAA;AAEA,cAAQ,MAAM;AAAA,QACZ,KAAK;AAKH;AAAA,QACF,KAAK;AAKH;AAAA,QACF,KAAK;AACH,kBAAQ,OAAO,MAAM,kBAAsB;AAE3C;AAAA,MACJ;AAAA,EAEJ,CAAC;AACH;",
+  "names": []
+}

package/dist/esm/exports/bindKeypressInput.mjs

@@ -0,0 +1,31 @@
+import readline from "node:readline";
+function bindKeypressInput() {
+  if (!process.stdin.setRawMode) {
+    console.warn({
+      msg: "Interactive mode is not supported in this environment"
+    });
+    return;
+  }
+  readline.emitKeypressEvents(process.stdin), process.stdin.setRawMode(!0), process.stdin.on("keypress", (_key, data) => {
+    const {
+      ctrl,
+      name
+    } = data;
+    if (ctrl === !0) switch (name) {
+      case "c":
+        process.exit();
+      case "z":
+        process.emit("SIGTSTP", "SIGTSTP");
+        break;
+    } else switch (name) {
+      case "r":
+        break;
+      case "d":
+        break;
+      case "c":
+        process.stdout.write("\x1B[2J\x1B[0;0H");
+        break;
+    }
+  });
+}
+export { bindKeypressInput };

package/dist/esm/exports/bindKeypressInput.native.js

@@ -0,0 +1,34 @@
+import readline from "node:readline";
+function bindKeypressInput() {
+  if (!process.stdin.setRawMode) {
+    console.warn({
+      msg: "Interactive mode is not supported in this environment"
+    });
+    return;
+  }
+  readline.emitKeypressEvents(process.stdin), process.stdin.setRawMode(!0), process.stdin.on("keypress", function(_key, data) {
+    var ctrl = data.ctrl, name = data.name;
+    if (ctrl === !0)
+      switch (name) {
+        case "c":
+          process.exit();
+        case "z":
+          process.emit("SIGTSTP", "SIGTSTP");
+          break;
+      }
+    else
+      switch (name) {
+        case "r":
+          break;
+        case "d":
+          break;
+        case "c":
+          process.stdout.write("\x1B[2J\x1B[0;0H");
+          break;
+      }
+  });
+}
+export {
+  bindKeypressInput
+};
+//# sourceMappingURL=bindKeypressInput.js.map

package/dist/esm/exports/bindKeypressInput.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/bindKeypressInput.ts"],
+  "mappings": "AAAA,OAAOA,cAAc;AAEd,SAASC,oBAAAA;AACd,MAAI,CAACC,QAAQC,MAAMC,YAAY;AAC7BC,YAAQC,KAAK;MACXC,KAAK;IACP,CAAA;AACA;EACF;AAEAP,WAASQ,mBAAmBN,QAAQC,KAAK,GACzCD,QAAQC,MAAMC,WAAW,EAAA,GAEzBF,QAAQC,MAAMM,GAAG,YAAY,SAACC,MAAMC,MAAAA;AAClC,QAAQC,OAAeD,KAAfC,MAAMC,OAASF,KAATE;AACd,QAAID,SAAS;AACX,cAAQC,MAAAA;QAEN,KAAK;AACHX,kBAAQY,KAAI;QACd,KAAK;AACHZ,kBAAQa,KAAK,WAAW,SAAA;AACxB;MACJ;;AAEA,cAAQF,MAAAA;QACN,KAAK;AAKH;QACF,KAAK;AAKH;QACF,KAAK;AACHX,kBAAQc,OAAOC,MAAM,kBAAA;AAErB;MACJ;EAEJ,CAAA;AACF;",
+  "names": ["readline", "bindKeypressInput", "process", "stdin", "setRawMode", "console", "warn", "msg", "emitKeypressEvents", "on", "_key", "data", "ctrl", "name", "exit", "emit", "stdout", "write"]
+}

package/dist/esm/exports/build.js

@@ -1,15 +1,11 @@
-import { build as esbuild } from "esbuild";
+import FSExtra from "fs-extra";
 import { resolve as importMetaResolve } from "import-meta-resolve";
-import fs from "node:fs";
-import { tmpdir } from "node:os";
-import Path from "node:path";
+import { rm } from "node:fs/promises";
 import { mergeConfig, build as viteBuild } from "vite";
-import FSExtra from "fs-extra";
 import { getBaseViteConfig } from "../utils/getBaseViteConfig";
-import { getHtml } from "../utils/getHtml";
 import { getOptimizeDeps } from "../utils/getOptimizeDeps";
 import { getOptionsFilled } from "../utils/getOptionsFilled";
-import { assertIsError } from "../utils/assert";
+const { existsSync } = FSExtra;
 Error.stackTraceLimit = 1 / 0;
 const resolveFile = (path) => {
   try {
@@ -17,9 +13,9 @@ const resolveFile = (path) => {
   } catch {
     return require.resolve(path);
   }
-}, { ensureDir, existsSync, readFile, pathExists } = FSExtra, build = async (optionsIn, buildOptions = {}) => {
+}, build = async (optionsIn, buildOptions = {}) => {
   const options = await getOptionsFilled(optionsIn);
-  process.env.NODE_ENV = "production";
+  existsSync("dist") && await rm("dist", { recursive: !0, force: !0 }), existsSync("node_modules/.vite") && await rm("node_modules/.vite", { recursive: !0, force: !0 }), process.env.NODE_ENV = "production";
   const { optimizeDeps } = getOptimizeDeps("build");
   let webBuildConfig = mergeConfig(
     getBaseViteConfig({
@@ -31,21 +27,33 @@ const resolveFile = (path) => {
       optimizeDeps
     }
   );
-  options.webConfig && (webBuildConfig = mergeConfig(webBuildConfig, options.webConfig)), buildOptions.step !== "generate" && (console.info("build client"), await viteBuild(
-    mergeConfig(webBuildConfig, {
+  if (options.webConfig && (webBuildConfig = mergeConfig(webBuildConfig, options.webConfig)), buildOptions.step !== "generate") {
+    let clientBuildConfig = mergeConfig(webBuildConfig, {
       build: {
         ssrManifest: !0,
         outDir: "dist/client"
       }
-    })
-  )), console.info("build server");
+    });
+    process.env.VXRN_DISABLE_PROD_OPTIMIZATION && (clientBuildConfig = mergeConfig(clientBuildConfig, {
+      optimizeDeps: {
+        esbuildOptions: {
+          minify: !1
+        }
+      },
+      build: {
+        minify: !1,
+        rollupOptions: {
+          treeshake: !1,
+          output: {
+            minifyInternalExports: !1
+          }
+        }
+      }
+    })), await viteBuild(clientBuildConfig);
+  }
+  console.info("build server");
   const { output } = await viteBuild(
     mergeConfig(webBuildConfig, {
-      // optimizeDeps: {
-      //   esbuildOptions: {
-      //     format: 'cjs',
-      //   },
-      // },
       ssr: {
         noExternal: optimizeDeps.include,
         optimizeDeps
@@ -61,87 +69,8 @@ const resolveFile = (path) => {
       }
     })
   );
-  console.info("generating static pages"), await generateStaticPages(options, output);
+  options.afterBuild && await options.afterBuild(options, output);
 };
-async function generateStaticPages(options, serverOutput) {
-  const toAbsolute = (p) => Path.resolve(options.root, p), staticDir = toAbsolute("dist/static");
-  await ensureDir(staticDir);
-  const template = fs.readFileSync(toAbsolute("index.html"), "utf-8"), render = (await import(`${options.root}/dist/server/entry-server.js`)).render, assets = [], allRoutes = [];
-  for (const output of serverOutput) {
-    let getUrl = function(_params = {}) {
-      if (name === "index")
-        return "/";
-      if (name.startsWith("[...")) {
-        const part = name.replace("[...", "").replace("]", "");
-        return `/${_params[part]}`;
-      }
-      return `/${name.split("/").map((part) => {
-        if (part[0] === "[") {
-          const found = _params[part.slice(1, part.length - 1)];
-          return found || console.warn("not found", { _params, part }), found;
-        }
-        return part;
-      }).join("/")}`;
-    };
-    if (output.type === "asset") {
-      assets.push(output);
-      continue;
-    }
-    const id = output.facadeModuleId || "", file = Path.basename(id), name = file.replace(/\.[^/.]+$/, "");
-    if (!id || file[0] === "_" || file.includes("entry-server") || id.includes("+api"))
-      continue;
-    const endpointPath = Path.join(options.root, "dist/server", output.fileName);
-    let exported;
-    try {
-      exported = await import(endpointPath);
-    } catch (err) {
-      throw console.error("Error importing page (original error)", err), new Error(`Error importing page: ${endpointPath}`, {
-        cause: err
-      });
-    }
-    const paramsList = await exported.generateStaticParams?.() ?? [{}];
-    for (const params of paramsList) {
-      const path = getUrl(params), loaderData = await exported.loader?.({ path, params }) ?? {};
-      allRoutes.push({ path, params, loaderData });
-    }
-  }
-  const cssStringRaw = assets.filter((x) => x.name?.endsWith(".css")).map((x) => x.source).join(`
-
-`), tmpCssFile = Path.join(tmpdir(), "tmp.css");
-  await FSExtra.writeFile(tmpCssFile, cssStringRaw, "utf-8"), await esbuild({
-    entryPoints: [tmpCssFile],
-    target: "safari17",
-    bundle: !0,
-    minifyWhitespace: !0,
-    sourcemap: !1,
-    outfile: tmpCssFile,
-    loader: { ".css": "css" }
-  });
-  const cssString = await FSExtra.readFile(tmpCssFile, "utf-8");
-  for (const { path, loaderData, params } of allRoutes)
-    try {
-      const loaderProps = { params };
-      globalThis.__vxrnLoaderProps__ = loaderProps, console.info("render", path);
-      const { appHtml, headHtml } = await render({ path }), slashFileName = `${path === "/" ? "/index" : path}.html`, clientHtmlPath = toAbsolute(`dist/client${slashFileName}`), clientHtml = existsSync(clientHtmlPath) ? await readFile(clientHtmlPath, "utf-8") : null, html = getHtml({
-        template: clientHtml || template,
-        appHtml,
-        headHtml,
-        loaderData,
-        loaderProps,
-        css: cssString
-      }), filePath = toAbsolute(`dist/static${slashFileName}`);
-      await ensureDir(Path.dirname(filePath)), fs.writeFileSync(toAbsolute(filePath), html);
-    } catch (err) {
-      throw assertIsError(err), console.error("og error because cause not working", err), new Error(
-        `Error building static page: ${path} with:
-  loaderData: ${JSON.stringify(loaderData || null)}
-  params: ${JSON.stringify(params || null)}`,
-        {
-          cause: err
-        }
-      );
-    }
-}
 export {
   build,
   resolveFile