one 1.25.5 → 1.25.7

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

@@ -0,0 +1,253 @@
+"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: 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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var securityScan_exports = {};
+__export(securityScan_exports, {
+  runSecurityScan: () => runSecurityScan,
+  scanBundleForSecrets: () => scanBundleForSecrets
+});
+module.exports = __toCommonJS(securityScan_exports);
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var SECRET_PATTERNS = [
+// api tokens / keys with known prefixes
+["Anthropic API key", /sk-ant-[A-Za-z0-9_-]{20,}/g], ["OpenAI API key", /sk-proj-[A-Za-z0-9_-]{20,}/g], ["Stripe secret key", /sk_live_[A-Za-z0-9]{20,}/g], ["Stripe webhook secret", /whsec_[A-Za-z0-9]{20,}/g], ["GitHub token", /gh[ps]_[A-Za-z0-9]{36,}/g], ["GitHub PAT", /github_pat_[A-Za-z0-9_]{20,}/g], ["AWS access key", RegExp("(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])", "g")], ["Postmark server token", /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/g], ["Bearer token assignment", /["']Bearer\s+[A-Za-z0-9_.-]{20,}["']/g], ["Generic secret assignment", /(?:secret|password|api_key|apikey)\s*[:=]\s*["'][A-Za-z0-9_-]{16,}["']/gi],
+// known env var names that should never be inlined
+["BETTER_AUTH_SECRET value", /BETTER_AUTH_SECRET["']\s*[:=]\s*["'][^"']+["']/g], ["POSTMARK_SERVER_TOKEN value", /POSTMARK_SERVER_TOKEN["']\s*[:=]\s*["'][^"']+["']/g], ["ANTHROPIC_API_KEY value", /ANTHROPIC_API_KEY["']\s*[:=]\s*["'][^"']+["']/g]];
+var SAFE_UUIDS = /* @__PURE__ */new Set(["00000000-0000-0000-0000-000000000000", "09259e3b-7be8-46f6-9801-106bf1866e1c",
+// WebRTC SDP
+"4ad15a19-80e2-4105-bf43-48039fd2963e"]);
+var BUILTIN_SAFE_PATTERNS = [/sk_live_your_/, /sk_live_your_key/, /rk_\w+_\w+/,
+// tamagui theme tokens
+/sk_all_element/,
+// DOM property names
+/sk_personal_data/];
+function createSafeMatcher(userPatterns) {
+  var safeStrings = new Set(SAFE_UUIDS);
+  var safeRegexes = [...BUILTIN_SAFE_PATTERNS];
+  if (userPatterns) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = userPatterns[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var p = _step.value;
+        if (typeof p === "string") {
+          safeStrings.add(p);
+        } else {
+          safeRegexes.push(p);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  return function (match) {
+    if (safeStrings.has(match)) return true;
+    return safeRegexes.some(function (p2) {
+      return p2.test(match);
+    });
+  };
+}
+async function collectJSFiles(dir) {
+  var files = [];
+  async function walk(currentDir) {
+    var entries;
+    try {
+      entries = await (0, import_promises.readdir)(currentDir, {
+        withFileTypes: true
+      });
+    } catch (unused) {
+      return;
+    }
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var entry = _step.value;
+        var fullPath = (0, import_path.join)(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else if (entry.name.endsWith(".js")) {
+          files.push(fullPath);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function scanBundleForSecrets(distDir, userSafePatterns) {
+  var isSafe = createSafeMatcher(userSafePatterns);
+  var files = await collectJSFiles(distDir);
+  var findings = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var fullPath = _step.value;
+      var relativePath = fullPath.slice(distDir.length + 1);
+      var content = void 0;
+      try {
+        content = await (0, import_promises.readFile)(fullPath, "utf-8");
+      } catch (unused) {
+        continue;
+      }
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = SECRET_PATTERNS[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var [label, pattern] = _step1.value;
+          pattern.lastIndex = 0;
+          var match = void 0;
+          while ((match = pattern.exec(content)) !== null) {
+            var _ref;
+            var _beforeMatch_match;
+            var matched = match[0];
+            if (isSafe(matched)) continue;
+            var beforeMatch = content.slice(0, match.index);
+            var line = ((_ref = (_beforeMatch_match = beforeMatch.match(/\n/g)) === null || _beforeMatch_match === void 0 ? void 0 : _beforeMatch_match.length) !== null && _ref !== void 0 ? _ref : 0) + 1;
+            findings.push({
+              file: relativePath,
+              label,
+              match: matched.length > 40 ? `${matched.slice(0, 20)}...${matched.slice(-10)}` : matched,
+              line
+            });
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return {
+    clean: findings.length === 0,
+    findings
+  };
+}
+async function runSecurityScan(clientDir, level, safePatterns) {
+  console.info(`
+ \u{1F512} scanning client bundles for leaked secrets...
+`);
+  var {
+    clean,
+    findings
+  } = await scanBundleForSecrets(clientDir, safePatterns);
+  if (clean) {
+    console.info(`
+ \u{1F512} security scan passed \u2014 no secrets found
+`);
+    return true;
+  }
+  var icon = level === "error" ? "\u{1F6A8}" : "\u26A0\uFE0F";
+  var header = level === "error" ? `${icon} ${findings.length} secret(s) leaked into client bundle:` : `${icon} ${findings.length} potential secret(s) found in client bundle:`;
+  console.error(`
+ ${header}
+`);
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = findings[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var f = _step.value;
+      console.error(`   ${f.label}`);
+      console.error(`     file: ${f.file}:${f.line}`);
+      console.error(`     match: ${f.match}
+`);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  if (level === "error") {
+    console.error(` Set build.securityScan to 'warn' to continue building despite findings.
+`);
+    return false;
+  }
+  console.warn(` Set build.securityScan to 'error' to fail builds when secrets are detected.
+`);
+  return true;
+}
+//# sourceMappingURL=securityScan.native.js.map

package/dist/cjs/cli/securityScan.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","securityScan_exports","__export","runSecurityScan","scanBundleForSecrets","module","exports","import_promises","require","import_path","SECRET_PATTERNS","RegExp","SAFE_UUIDS","Set","BUILTIN_SAFE_PATTERNS","createSafeMatcher","userPatterns","safeStrings","safeRegexes","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","Symbol","iterator","_step","next","done","p","add","push","err","return","match","has","some","p2","test","collectJSFiles","dir","files","walk","currentDir","entries","readdir","withFileTypes","unused","entry","fullPath","join","name","isDirectory","endsWith"],"sources":["../../../src/cli/securityScan.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,oBAAA;AAAAC,QAAA,CAAAD,oBAAA;EAAAE,eAAA,EAAAA,CAAA,KAAAA,eAAA;EAAAC,oBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAV,YAAkC,CAAAK,oBAAA;AAClC,IAAAM,eAAA,GAAAC,OAAqB;AAGrB,IAAAC,WAAM,GAAAD,OAA2C;AAAA,IAAAE,eAAA;AAE/C;AACA,CACC,qBACA,4BAAyB,CACzB,EACD,CACC,kBACD,gCACE,CAEF,qBACC,2BAA2B,CAC5B,GAEE,yBACF,4BAEA,CACC,gBACA,0BAA2B,CAC9B,EAGA,CACE,cACA,kCACA,mBACDC,MAAA,yDAGD,EACE,CACA,yBACA,kEACA,4BACA,0CACF,CAEA,2BAA2B,EACzB,0EAAsC,CACtC;AAEA;AACE,CACE,0BAAiB,EACf,iDAAiB,GAEjB,CAAkB,6BACpB,EACF,qDACF,EAEA,CACE,yBAAyB,EACzB,gDAA4C,CAC9C,CACF;AAUA,IAAAC,UAAA,GAAe,eAAe,IAAgCC,GAAA,EAC5D,sCAAyB,EAEzB,sCAAwC;AACtC;AACA,sCAAI,CACF;AAA2D,IAC7DC,qBAAQ,IACN,mCACF,EACA;AACE;AACA,gBAAU;AACR;AAAmB,kBACV,CACT;AAAmB,SACrBC,kBAAAC,YAAA;EAAA,IACFC,WAAA,OAAAJ,GAAA,CAAAD,UAAA;EACF,IAAAM,WAAA,IAEA,GAAAJ,qBAAc,CACd;EACF,IAAAE,YAAA;IAEA,IAAAG,yBAAsB,GACpB;MAAAC,iBACA,QAIC;MAAAC,cAAA;IACD,IAAM;MACN,KAAM,IAAAC,SAAc,GAAAN,YAAe,CAAAO,MAAO,CAAAC,QAAA,KAAAC,KAAA,IAAAN,yBAAA,IAAAM,KAAA,GAAAH,SAAA,CAAAI,IAAA,IAAAC,IAAA,GAAAR,yBAAA;QACpC,IAAAS,CAAA,GAAAH,KAA+B,CAAAzB,KAAA;QAErC,WAAW4B,CAAA,KAAY,QAAO;UACtBX,WAAA,CAAAY,GAAe,CAAAD,CAAA;QACjB;UACAV,WAAA,CAAAY,IAAA,CAAAF,CAAA;QACF;MACF;IACE,SAAAG,GAAA;MACFX,iBAAA;MAEAC,cAAY,GAAOU,GAAA;IAEjB,UAAQ;MACR,IAAI;QAEJ,KAAAZ,yBAA6B,IAAOG,SAAO,CAAAU,MAAM;UAC/CV,SAAM,CAAAU,MAAU;QAChB;MAGA,UAAM;QACN,IAAAZ,iBAAc;UAEd,MAAAC,cAAc;QAAA;MACN;IACN;EAIM;EACN,OACD,UAAAY,KAAA;IAAA,IACHhB,WAAA,CAAAiB,GAAA,CAAAD,KAAA;IACF,OAAAf,WAAA,CAAAiB,IAAA,WAAAC,EAAA;MACF,OAAAA,EAAA,CAAAC,IAAA,CAAAJ,KAAA;IAEA;EACF;AAMA;AAKE,eAAaK,eAAAC,GAAA;EAAA,IAAAC,KAAA;EAAuD,eAAAC,KAAAC,UAAA;IAEpE,IAAMC,OAAE;IAER,IAAI;MACFA,OAAQ,SAAK,IAAApC,eAAA,CAAAqC,OAAA,EAAAF,UAAA;QAAAG,aAAA;MAAiD;IAC9D,SAAOC,MAAA;MACT;IAEA;IACA,IAAM3B,yBACM,OACH;MAAAC,iBAAiB,QAAM;MAAAC,cAAA;IAGhC;MAAoB,KAAM,IAAAC,SAAA,GAAAqB,OAAA,CAAApB,MAAA,CAAAC,QAAA,KAAAC,KAAA,IAAAN,yBAAA,IAAAM,KAAA,GAAAH,SAAA,CAAAI,IAAA,IAAAC,IAAA,GAAAR,yBAAA;QAAI,IAAA4B,KAAA,GAAAtB,KAAA,CAAAzB,KAAA;QAE9B,IAAAgD,QAAgB,OAAAvC,WAAU,CAAAwC,IAAA,EAAAP,UAAA,EAAAK,KAAA,CAAAG,IAAA;QACxB,IAAQH,KAAA,CAAMI,WAAQ,EAAK,EAAE;UAC7B,MAAQV,IAAM,CAAAO,QAAA;QACd,OAAQ,IAAMD,KAAA,CAAAG,IAAA,CAAAE,QAAiB,MAAK;UAAIZ,KAAA,CAAAV,IAAA,CAAAkB,QAAA;QAC1C;MAEI;IACF,SAAQjB,GAAA;MACNX,iBAAA;MAAAC,cAAA,GAAAU,GAAA;IACF;MACA;QACF,KAAAZ,yBAAA,IAAAG,SAAA,CAAAU,MAAA;UAEQV,SAAA,CAAAU,MAAA;QACN;MAAA;QACF,IAAAZ,iBAAA;UACO,MAAAC,cAAA;QACT","ignoreList":[]}

package/dist/cjs/cli/workerPool.cjs

@@ -0,0 +1,178 @@
+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: 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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var workerPool_exports = {};
+__export(workerPool_exports, {
+  BuildWorkerPool: () => BuildWorkerPool,
+  getWorkerPool: () => getWorkerPool,
+  terminateWorkerPool: () => terminateWorkerPool
+});
+module.exports = __toCommonJS(workerPool_exports);
+var import_node_worker_threads = require("node:worker_threads");
+var import_node_os = require("node:os");
+var import_node_url = require("node:url");
+var import_node_path = require("node:path");
+const import_meta = {};
+const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+const __dirname = (0, import_node_path.dirname)(__filename);
+class BuildWorkerPool {
+  workers = [];
+  available = [];
+  taskQueue = [];
+  pendingById = /* @__PURE__ */new Map();
+  nextId = 0;
+  readyCount = 0;
+  initCount = 0;
+  _ready;
+  _resolveReady;
+  _initialized;
+  _resolveInitialized;
+  _terminated = false;
+  constructor(size = Math.max(1, (0, import_node_os.cpus)().length - 1)) {
+    this._ready = new Promise(resolve => {
+      this._resolveReady = resolve;
+    });
+    this._initialized = new Promise(resolve => {
+      this._resolveInitialized = resolve;
+    });
+    const workerPath = (0, import_node_path.join)(__dirname, "buildPageWorker.mjs");
+    for (let i = 0; i < size; i++) {
+      const worker = new import_node_worker_threads.Worker(workerPath);
+      worker.on("message", msg => {
+        if (msg.type === "ready") {
+          this.readyCount++;
+          this.available.push(worker);
+          if (this.readyCount === size) {
+            this._resolveReady();
+          }
+        } else if (msg.type === "init-done") {
+          this.initCount++;
+          if (this.initCount === size) {
+            this._resolveInitialized();
+          }
+          this.dispatch();
+        } else if (msg.type === "done" || msg.type === "error") {
+          const pending = this.pendingById.get(msg.id);
+          if (pending) {
+            this.pendingById.delete(msg.id);
+            if (msg.type === "done") {
+              pending.resolve(msg.result);
+            } else {
+              pending.reject(new Error(msg.error));
+            }
+          }
+          this.available.push(worker);
+          this.dispatch();
+        }
+      });
+      worker.on("error", err => {
+        console.error("[BuildWorkerPool] Worker error:", err);
+      });
+      this.workers.push(worker);
+    }
+  }
+  get size() {
+    return this.workers.length;
+  }
+  // initialize all workers with pre-loaded config from main thread
+  async initialize(oneOptions) {
+    await this._ready;
+    for (const worker of this.workers) {
+      worker.postMessage({
+        type: "init",
+        id: this.nextId++,
+        oneOptions
+      });
+    }
+    await this._initialized;
+  }
+  dispatch() {
+    while (this.available.length > 0 && this.taskQueue.length > 0) {
+      const worker = this.available.shift();
+      const {
+        msg,
+        pending
+      } = this.taskQueue.shift();
+      this.pendingById.set(pending.id, pending);
+      worker.postMessage(msg);
+    }
+  }
+  async buildPage(args) {
+    if (this._terminated) {
+      throw new Error("Worker pool has been terminated");
+    }
+    const serializedRoute = {
+      type: args.foundRoute.type,
+      file: args.foundRoute.file,
+      // only keep serializable layout data
+      layouts: args.foundRoute.layouts?.map(layout => ({
+        contextKey: layout.contextKey,
+        loaderServerPath: layout.loaderServerPath,
+        layoutRenderMode: layout.layoutRenderMode
+      })),
+      // only keep contextKey from middlewares
+      middlewares: args.foundRoute.middlewares?.map(mw => ({
+        contextKey: mw.contextKey
+      }))
+    };
+    const id = this.nextId++;
+    const msg = {
+      type: "build",
+      id,
+      args: {
+        ...args,
+        foundRoute: serializedRoute
+      }
+    };
+    return new Promise((resolve, reject) => {
+      const pending = {
+        id,
+        resolve,
+        reject
+      };
+      this.taskQueue.push({
+        msg,
+        pending
+      });
+      this.dispatch();
+    });
+  }
+  async terminate() {
+    this._terminated = true;
+    await Promise.all(this.workers.map(w => w.terminate()));
+    this.workers = [];
+    this.available = [];
+  }
+}
+let pool = null;
+function getWorkerPool(size) {
+  if (!pool) {
+    pool = new BuildWorkerPool(size);
+  }
+  return pool;
+}
+async function terminateWorkerPool() {
+  if (pool) {
+    await pool.terminate();
+    pool = null;
+  }
+}

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

@@ -0,0 +1,260 @@
+"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: 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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var workerPool_exports = {};
+__export(workerPool_exports, {
+  BuildWorkerPool: () => BuildWorkerPool,
+  getWorkerPool: () => getWorkerPool,
+  terminateWorkerPool: () => terminateWorkerPool
+});
+module.exports = __toCommonJS(workerPool_exports);
+var import_worker_threads = require("worker_threads");
+var import_os = require("os");
+var import_url = require("url");
+var import_path = require("path");
+const import_meta = {};
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __filename = (0, import_url.fileURLToPath)(import_meta.url);
+var __dirname = (0, import_path.dirname)(__filename);
+var BuildWorkerPool = /* @__PURE__ */function () {
+  "use strict";
+
+  function BuildWorkerPool2() {
+    var _this,
+      _loop = function (i2) {
+        var worker = new import_worker_threads.Worker(workerPath);
+        worker.on("message", function (msg) {
+          if (msg.type === "ready") {
+            _this1.readyCount++;
+            _this1.available.push(worker);
+            if (_this1.readyCount === size) {
+              _this1._resolveReady();
+            }
+          } else if (msg.type === "init-done") {
+            _this1.initCount++;
+            if (_this1.initCount === size) {
+              _this1._resolveInitialized();
+            }
+            _this1.dispatch();
+          } else if (msg.type === "done" || msg.type === "error") {
+            var pending = _this1.pendingById.get(msg.id);
+            if (pending) {
+              _this1.pendingById.delete(msg.id);
+              if (msg.type === "done") {
+                pending.resolve(msg.result);
+              } else {
+                pending.reject(new Error(msg.error));
+              }
+            }
+            _this1.available.push(worker);
+            _this1.dispatch();
+          }
+        });
+        worker.on("error", function (err) {
+          console.error("[BuildWorkerPool] Worker error:", err);
+        });
+        _this.workers.push(worker);
+      };
+    var _this1 = this;
+    var size = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Math.max(1, (0, import_os.cpus)().length - 1);
+    _class_call_check(this, BuildWorkerPool2);
+    _define_property(this, "workers", []);
+    _define_property(this, "available", []);
+    _define_property(this, "taskQueue", []);
+    _define_property(this, "pendingById", /* @__PURE__ */new Map());
+    _define_property(this, "nextId", 0);
+    _define_property(this, "readyCount", 0);
+    _define_property(this, "initCount", 0);
+    _define_property(this, "_ready", void 0);
+    _define_property(this, "_resolveReady", void 0);
+    _define_property(this, "_initialized", void 0);
+    _define_property(this, "_resolveInitialized", void 0);
+    _define_property(this, "_terminated", false);
+    this._ready = new Promise(function (resolve) {
+      _this1._resolveReady = resolve;
+    });
+    this._initialized = new Promise(function (resolve) {
+      _this1._resolveInitialized = resolve;
+    });
+    var workerPath = (0, import_path.join)(__dirname, "buildPageWorker.mjs");
+    for (var i = 0; i < size; i++) _this = this, _loop(i);
+  }
+  _create_class(BuildWorkerPool2, [{
+    key: "size",
+    get: function get() {
+      return this.workers.length;
+    }
+  }, {
+    key: "initialize",
+    value:
+    // initialize all workers with pre-loaded config from main thread
+    async function initialize(oneOptions) {
+      await this._ready;
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.workers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var worker = _step.value;
+          worker.postMessage({
+            type: "init",
+            id: this.nextId++,
+            oneOptions
+          });
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      await this._initialized;
+    }
+  }, {
+    key: "dispatch",
+    value: function dispatch() {
+      while (this.available.length > 0 && this.taskQueue.length > 0) {
+        var worker = this.available.shift();
+        var {
+          msg,
+          pending
+        } = this.taskQueue.shift();
+        this.pendingById.set(pending.id, pending);
+        worker.postMessage(msg);
+      }
+    }
+  }, {
+    key: "buildPage",
+    value: async function buildPage(args) {
+      var _this = this;
+      var _args_foundRoute_layouts, _args_foundRoute_middlewares;
+      if (this._terminated) {
+        throw new Error("Worker pool has been terminated");
+      }
+      var serializedRoute = {
+        type: args.foundRoute.type,
+        file: args.foundRoute.file,
+        // only keep serializable layout data
+        layouts: (_args_foundRoute_layouts = args.foundRoute.layouts) === null || _args_foundRoute_layouts === void 0 ? void 0 : _args_foundRoute_layouts.map(function (layout) {
+          return {
+            contextKey: layout.contextKey,
+            loaderServerPath: layout.loaderServerPath,
+            layoutRenderMode: layout.layoutRenderMode
+          };
+        }),
+        // only keep contextKey from middlewares
+        middlewares: (_args_foundRoute_middlewares = args.foundRoute.middlewares) === null || _args_foundRoute_middlewares === void 0 ? void 0 : _args_foundRoute_middlewares.map(function (mw) {
+          return {
+            contextKey: mw.contextKey
+          };
+        })
+      };
+      var id = this.nextId++;
+      var msg = {
+        type: "build",
+        id,
+        args: {
+          ...args,
+          foundRoute: serializedRoute
+        }
+      };
+      return new Promise(function (resolve, reject) {
+        var pending = {
+          id,
+          resolve,
+          reject
+        };
+        _this.taskQueue.push({
+          msg,
+          pending
+        });
+        _this.dispatch();
+      });
+    }
+  }, {
+    key: "terminate",
+    value: async function terminate() {
+      this._terminated = true;
+      await Promise.all(this.workers.map(function (w) {
+        return w.terminate();
+      }));
+      this.workers = [];
+      this.available = [];
+    }
+  }]);
+  return BuildWorkerPool2;
+}();
+var pool = null;
+function getWorkerPool(size) {
+  if (!pool) {
+    pool = new BuildWorkerPool(size);
+  }
+  return pool;
+}
+async function terminateWorkerPool() {
+  if (pool) {
+    await pool.terminate();
+    pool = null;
+  }
+}
+//# sourceMappingURL=workerPool.native.js.map