@tscircuit/cli 0.1.770 → 0.1.772

package/dist/main.js

@@ -17,6 +17,16 @@ var __toESM2 = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/commander/lib/error.js
@@ -2112,6 +2122,101 @@ var require_commander = __commonJS((exports2) => {
   exports2.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// node_modules/kleur/index.mjs
+function run(arr, str) {
+  let i = 0, tmp, beg = "", end = "";
+  for (;i < arr.length; i++) {
+    tmp = arr[i];
+    beg += tmp.open;
+    end += tmp.close;
+    if (!!~str.indexOf(tmp.close)) {
+      str = str.replace(tmp.rgx, tmp.close + tmp.open);
+    }
+  }
+  return beg + str + end;
+}
+function chain(has, keys) {
+  let ctx = { has, keys };
+  ctx.reset = $.reset.bind(ctx);
+  ctx.bold = $.bold.bind(ctx);
+  ctx.dim = $.dim.bind(ctx);
+  ctx.italic = $.italic.bind(ctx);
+  ctx.underline = $.underline.bind(ctx);
+  ctx.inverse = $.inverse.bind(ctx);
+  ctx.hidden = $.hidden.bind(ctx);
+  ctx.strikethrough = $.strikethrough.bind(ctx);
+  ctx.black = $.black.bind(ctx);
+  ctx.red = $.red.bind(ctx);
+  ctx.green = $.green.bind(ctx);
+  ctx.yellow = $.yellow.bind(ctx);
+  ctx.blue = $.blue.bind(ctx);
+  ctx.magenta = $.magenta.bind(ctx);
+  ctx.cyan = $.cyan.bind(ctx);
+  ctx.white = $.white.bind(ctx);
+  ctx.gray = $.gray.bind(ctx);
+  ctx.grey = $.grey.bind(ctx);
+  ctx.bgBlack = $.bgBlack.bind(ctx);
+  ctx.bgRed = $.bgRed.bind(ctx);
+  ctx.bgGreen = $.bgGreen.bind(ctx);
+  ctx.bgYellow = $.bgYellow.bind(ctx);
+  ctx.bgBlue = $.bgBlue.bind(ctx);
+  ctx.bgMagenta = $.bgMagenta.bind(ctx);
+  ctx.bgCyan = $.bgCyan.bind(ctx);
+  ctx.bgWhite = $.bgWhite.bind(ctx);
+  return ctx;
+}
+function init(open, close) {
+  let blk = {
+    open: `\x1B[${open}m`,
+    close: `\x1B[${close}m`,
+    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
+  };
+  return function(txt) {
+    if (this !== undefined && this.has !== undefined) {
+      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
+      return txt === undefined ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
+    }
+    return txt === undefined ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
+  };
+}
+var FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY = true, $, kleur_default;
+var init_kleur = __esm(() => {
+  if (typeof process !== "undefined") {
+    ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+    isTTY = process.stdout && process.stdout.isTTY;
+  }
+  $ = {
+    enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
+    reset: init(0, 0),
+    bold: init(1, 22),
+    dim: init(2, 22),
+    italic: init(3, 23),
+    underline: init(4, 24),
+    inverse: init(7, 27),
+    hidden: init(8, 28),
+    strikethrough: init(9, 29),
+    black: init(30, 39),
+    red: init(31, 39),
+    green: init(32, 39),
+    yellow: init(33, 39),
+    blue: init(34, 39),
+    magenta: init(35, 39),
+    cyan: init(36, 39),
+    white: init(37, 39),
+    gray: init(90, 39),
+    grey: init(90, 39),
+    bgBlack: init(40, 49),
+    bgRed: init(41, 49),
+    bgGreen: init(42, 49),
+    bgYellow: init(43, 49),
+    bgBlue: init(44, 49),
+    bgMagenta: init(45, 49),
+    bgCyan: init(46, 49),
+    bgWhite: init(47, 49)
+  };
+  kleur_default = $;
+});
+
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
@@ -16050,7 +16155,7 @@ var require_dist3 = __commonJS((exports2, module2) => {
   var __commonJS2 = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames22(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
-  var __export2 = (target, all) => {
+  var __export22 = (target, all) => {
     for (var name in all)
       __defProp22(target, name, { get: all[name], enumerable: true });
   };
@@ -32706,7 +32811,7 @@ var crypto = new Crypto();
     }
   });
   var src_exports = {};
-  __export2(src_exports, {
+  __export22(src_exports, {
     buildToFetchEvent: () => buildToFetchEvent,
     buildToHeaders: () => buildToHeaders,
     buildToNodeHandler: () => buildToNodeHandler,
@@ -32737,9 +32842,9 @@ var crypto = new Crypto();
     };
   }
   function buildToReadableStream(dependencies) {
-    const { ReadableStream, Uint8Array: Uint8Array2 } = dependencies;
+    const { ReadableStream: ReadableStream2, Uint8Array: Uint8Array2 } = dependencies;
     return function toReadableStream(stream) {
-      return new ReadableStream({
+      return new ReadableStream2({
         start(controller) {
           stream.on("data", (chunk) => {
             controller.enqueue(new Uint8Array2([...new Uint8Array2(chunk)]));
@@ -49287,7 +49392,7 @@ var require_load = __commonJS((exports2, module2) => {
   var __getProtoOf3 = Object.getPrototypeOf;
   var __hasOwnProp3 = Object.prototype.hasOwnProperty;
   var __name2 = (target, value) => __defProp3(target, "name", { value, configurable: true });
-  var __export2 = (target, all) => {
+  var __export3 = (target, all) => {
     for (var name in all)
       __defProp3(target, name, { get: all[name], enumerable: true });
   };
@@ -49302,7 +49407,7 @@ var require_load = __commonJS((exports2, module2) => {
   var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target, mod));
   var __toCommonJS2 = (mod) => __copyProps2(__defProp3({}, "__esModule", { value: true }), mod);
   var load_exports2 = {};
-  __export2(load_exports2, {
+  __export3(load_exports2, {
     load: () => load2
   });
   module2.exports = __toCommonJS2(load_exports2);
@@ -49522,7 +49627,7 @@ var require_dist5 = __commonJS((exports2, module2) => {
   var __commonJS2 = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames3(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
-  var __export2 = (target, all) => {
+  var __export3 = (target, all) => {
     for (var name in all)
       __defProp3(target, name, { get: all[name], enumerable: true });
   };
@@ -51828,7 +51933,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
     }
   });
   var src_exports = {};
-  __export2(src_exports, {
+  __export3(src_exports, {
     getMatchingFilePaths: () => getMatchingFilePaths,
     getVirtualFileSystemFromDirPath: () => getVirtualFileSystemFromDirPath,
     getVirtualFilesystemModuleFromDirPath: () => getVirtualFilesystemModuleFromDirPath,
@@ -51939,7 +52044,7 @@ var require_dist6 = __commonJS((exports2, module2) => {
   var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames3 = Object.getOwnPropertyNames;
   var __hasOwnProp3 = Object.prototype.hasOwnProperty;
-  var __export2 = (target, all) => {
+  var __export3 = (target, all) => {
     for (var name in all)
       __defProp3(target, name, { get: all[name], enumerable: true });
   };
@@ -51953,7 +52058,7 @@ var require_dist6 = __commonJS((exports2, module2) => {
   };
   var __toCommonJS2 = (mod) => __copyProps2(__defProp3({}, "__esModule", { value: true }), mod);
   var src_exports = {};
-  __export2(src_exports, {
+  __export3(src_exports, {
     default: () => src_default,
     getRouteMatcher: () => getRouteMatcher,
     getRouteMatcherUgly: () => getRouteMatcherUgly
@@ -67139,7 +67244,7 @@ var require_dist7 = __commonJS((exports2, module2) => {
       }
     return target;
   };
-  var __export2 = (target, all) => {
+  var __export3 = (target, all) => {
     for (var name in all)
       __defProp3(target, name, { get: all[name], enumerable: true });
   };
@@ -67174,7 +67279,7 @@ var require_dist7 = __commonJS((exports2, module2) => {
     });
   };
   var src_exports = {};
-  __export2(src_exports, {
+  __export3(src_exports, {
     getCommandFromPath: () => getCommandFromPath,
     getCommandPathOnly: () => getCommandPathOnly,
     perfectCli: () => perfectCli
@@ -67459,6 +67564,36 @@ var require_dist7 = __commonJS((exports2, module2) => {
   });
 });
 
+// lib/shared/importFromUserLand.ts
+import { createRequire as createRequire2 } from "node:module";
+import fs26 from "node:fs";
+import path28 from "node:path";
+async function importFromUserLand(moduleName) {
+  const userModulePath = path28.join(process.cwd(), "node_modules", moduleName);
+  if (fs26.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path28.join(process.cwd(), "noop.js"));
+    try {
+      const resolvedUserPath = userRequire.resolve(moduleName);
+      return await import(resolvedUserPath);
+    } catch (error) {
+      if (error?.code !== "MODULE_NOT_FOUND") {
+        throw error;
+      }
+    }
+  }
+  const cliRequire = createRequire2(import.meta.url);
+  try {
+    const resolvedCliPath = cliRequire.resolve(moduleName);
+    return await import(resolvedCliPath);
+  } catch (error) {
+    if (error?.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  return import(moduleName);
+}
+var init_importFromUserLand = () => {};
+
 // node_modules/make-vfs/dist/index.js
 var require_dist8 = __commonJS((exports2, module2) => {
   var __create3 = Object.create;
@@ -67470,7 +67605,7 @@ var require_dist8 = __commonJS((exports2, module2) => {
   var __commonJS2 = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames3(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
-  var __export2 = (target, all) => {
+  var __export3 = (target, all) => {
     for (var name in all)
       __defProp3(target, name, { get: all[name], enumerable: true });
   };
@@ -69776,7 +69911,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
     }
   });
   var src_exports = {};
-  __export2(src_exports, {
+  __export3(src_exports, {
     getMatchingFilePaths: () => getMatchingFilePaths2,
     getVirtualFileSystemFromDirPath: () => getVirtualFileSystemFromDirPath,
     getVirtualFilesystemModuleFromDirPath: () => getVirtualFilesystemModuleFromDirPath
@@ -69894,6 +70029,108 @@ export default {
   };
 });
 
+// lib/utils/abbreviate-stringify-object.ts
+var abbreviateStringifyObject = (obj) => {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  return JSON.stringify(Object.fromEntries(Object.entries(obj).map(([k, v]) => {
+    return [
+      k,
+      typeof v === "string" ? v.slice(0, 100) : typeof v === "object" && v !== null ? abbreviateStringifyObject(v) : v
+    ];
+  })));
+};
+
+// lib/shared/generate-circuit-json.tsx
+import path30 from "node:path";
+import fs28 from "node:fs";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import Debug11 from "debug";
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+async function generateCircuitJson({
+  filePath,
+  outputDir,
+  outputFileName,
+  saveToFile = false,
+  platformConfig
+}) {
+  debug11(`Generating circuit JSON for ${filePath}`);
+  const React = await importFromUserLand("react");
+  globalThis.React = React;
+  const userLandTscircuit = await importFromUserLand("tscircuit");
+  const runner = new userLandTscircuit.RootCircuit({
+    platform: platformConfig
+  });
+  const absoluteFilePath = path30.isAbsolute(filePath) ? filePath : path30.resolve(process.cwd(), filePath);
+  const projectDir = path30.dirname(absoluteFilePath);
+  const resolvedOutputDir = outputDir ?? projectDir;
+  const relativeComponentPath = path30.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path30.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path30.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  debug11(`Project directory: ${projectDir}`);
+  debug11(`Relative component path: ${relativeComponentPath}`);
+  debug11(`Output path: ${outputPath}`);
+  const fsMap = {
+    ...await import_make_vfs2.getVirtualFileSystemFromDirPath({
+      dirPath: projectDir,
+      fileMatchFn: (filePath2) => {
+        const normalizedFilePath = filePath2.replace(/\\/g, "/");
+        if (normalizedFilePath.endsWith(".kicad_mod")) {
+          return true;
+        }
+        if (normalizedFilePath.includes("node_modules/"))
+          return false;
+        if (normalizedFilePath.includes("dist/"))
+          return false;
+        if (normalizedFilePath.includes("build/"))
+          return false;
+        if (normalizedFilePath.match(/^\.[^/]/))
+          return false;
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path30.extname(normalizedFilePath)))
+          return false;
+        return true;
+      },
+      contentFormat: "string"
+    })
+  };
+  debug11(`fsMap: ${abbreviateStringifyObject(fsMap)}`);
+  const MainComponent = await import(pathToFileURL2(absoluteFilePath).href);
+  const Component = MainComponent.default || (Object.keys(MainComponent).find((k) => k[0] === k[0].toUpperCase()) !== undefined ? MainComponent[Object.keys(MainComponent).find((k) => k[0] === k[0].toUpperCase())] : undefined);
+  if (!Component) {
+    throw new Error(`No component found in "${absoluteFilePath}". Make sure you export a component.`);
+  }
+  runner.add(/* @__PURE__ */ jsxDEV2(Component, {}, undefined, false, undefined, this));
+  await runner.renderUntilSettled();
+  const circuitJson = await runner.getCircuitJson();
+  if (saveToFile) {
+    debug11(`Saving circuit JSON to ${outputPath}`);
+    fs28.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+  }
+  return {
+    circuitJson,
+    outputPath
+  };
+}
+var import_make_vfs2, debug11, ALLOWED_FILE_EXTENSIONS;
+var init_generate_circuit_json = __esm(() => {
+  init_importFromUserLand();
+  import_make_vfs2 = __toESM2(require_dist8(), 1);
+  debug11 = Debug11("tsci:generate-circuit-json");
+  ALLOWED_FILE_EXTENSIONS = [
+    ".tsx",
+    ".ts",
+    ".jsx",
+    ".js",
+    ".json",
+    ".txt",
+    ".md",
+    ".obj",
+    ".kicad_mod"
+  ];
+});
+
 // node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS((exports2, module2) => {
   module2.exports = {
@@ -71541,6 +71778,179 @@ var require_emoji_regex = __commonJS((exports2, module2) => {
   };
 });
 
+// lib/shared/circuit-json-diagnostics.ts
+function analyzeCircuitJson(circuitJson) {
+  const errors = [];
+  const warnings = [];
+  for (const item of circuitJson) {
+    if (!item || typeof item !== "object")
+      continue;
+    const t3 = item.type;
+    if (typeof t3 === "string") {
+      if (t3.endsWith("_error"))
+        errors.push(item);
+      else if (t3.endsWith("_warning"))
+        warnings.push(item);
+    }
+    if ("error_type" in item)
+      errors.push(item);
+    if ("warning_type" in item)
+      warnings.push(item);
+  }
+  return { errors, warnings };
+}
+
+// lib/shared/get-complete-platform-config.ts
+import { getPlatformConfig } from "@tscircuit/eval/platform-config";
+function getCompletePlatformConfig(userConfig) {
+  const basePlatformConfig = getPlatformConfig();
+  const defaultConfig = {
+    ...basePlatformConfig,
+    footprintFileParserMap: {
+      ...basePlatformConfig.footprintFileParserMap,
+      kicad_mod: {
+        loadFromUrl: async (url) => {
+          const fetchUrl = url.startsWith("/") ? `file://${url}` : url;
+          return basePlatformConfig.footprintFileParserMap.kicad_mod.loadFromUrl(fetchUrl);
+        }
+      }
+    }
+  };
+  if (!userConfig) {
+    return defaultConfig;
+  }
+  return {
+    ...defaultConfig,
+    ...userConfig,
+    footprintFileParserMap: {
+      ...defaultConfig.footprintFileParserMap,
+      ...userConfig.footprintFileParserMap
+    }
+  };
+}
+var init_get_complete_platform_config = () => {};
+
+// cli/build/build-file.ts
+var exports_build_file = {};
+__export2(exports_build_file, {
+  buildFile: () => buildFile
+});
+import path35 from "node:path";
+import fs35 from "node:fs";
+var buildFile = async (input, output, projectDir, options) => {
+  try {
+    console.log("Generating circuit JSON...");
+    const completePlatformConfig = getCompletePlatformConfig(options?.platformConfig);
+    const result = await generateCircuitJson({
+      filePath: input,
+      platformConfig: completePlatformConfig
+    });
+    fs35.mkdirSync(path35.dirname(output), { recursive: true });
+    fs35.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
+    console.log(`Circuit JSON written to ${path35.relative(projectDir, output)}`);
+    const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
+    if (!options?.ignoreWarnings) {
+      for (const warn of warnings) {
+        const msg = warn.message || JSON.stringify(warn);
+        console.log(kleur_default.yellow(msg));
+      }
+    }
+    if (!options?.ignoreErrors) {
+      for (const err of errors) {
+        const msg = err.message || JSON.stringify(err);
+        console.error(kleur_default.red(msg));
+        console.log(err.stack);
+      }
+    }
+    if (errors.length > 0 && !options?.ignoreErrors) {
+      console.error(kleur_default.red(`Build failed with ${errors.length} error(s). Use --ignore-errors to continue.`));
+      return { ok: false };
+    } else {
+      return {
+        ok: true,
+        circuitJson: result.circuitJson
+      };
+    }
+  } catch (err) {
+    console.error(err);
+    if (err instanceof Error) {
+      logTsxExtensionHint(err, input);
+      logTypeReexportHint(err, input);
+    }
+    return { ok: false };
+  }
+}, logTsxExtensionHint = (error, entryFilePath) => {
+  const lowerPath = entryFilePath.toLowerCase();
+  const isTsEntry = lowerPath.endsWith(".ts") && !lowerPath.endsWith(".d.ts");
+  const isAggregateError = error instanceof AggregateError || String(error).includes("AggregateError");
+  if (!isTsEntry || !isAggregateError)
+    return;
+  const entryFileName = path35.basename(entryFilePath);
+  console.error([
+    "",
+    `It looks like "${entryFileName}" is a ".ts" file. tscircuit component files must use the ".tsx" extension.`,
+    "Try renaming the file to .tsx and re-running the build.",
+    ""
+  ].join(`
+`));
+}, TYPE_REEXPORT_ERROR_REGEX, logTypeReexportHint = (error, entryFilePath) => {
+  const match = String(error).match(TYPE_REEXPORT_ERROR_REGEX);
+  if (!match)
+    return;
+  const [, exportName, fromSpecifier] = match;
+  const entryFileName = path35.basename(entryFilePath);
+  console.error([
+    "",
+    `It looks like "${entryFileName}" re-exports the type-only symbol "${exportName}" from "${fromSpecifier}" without the "type" modifier.`,
+    "Type-only exports must be re-exported with `export type { ... }`.",
+    "Try rewriting the statement as:",
+    `  export type { ${exportName} } from "${fromSpecifier}"`,
+    ""
+  ].join(`
+`));
+};
+var init_build_file = __esm(() => {
+  init_kleur();
+  init_generate_circuit_json();
+  init_get_complete_platform_config();
+  TYPE_REEXPORT_ERROR_REGEX = /SyntaxError: export '([^']+)' not found in '([^']+)'/;
+});
+
+// lib/shared/register-static-asset-loaders.ts
+var exports_register_static_asset_loaders = {};
+__export2(exports_register_static_asset_loaders, {
+  registerStaticAssetLoaders: () => registerStaticAssetLoaders
+});
+var TEXT_STATIC_ASSET_EXTENSIONS, staticAssetFilter, registered = false, registerStaticAssetLoaders = () => {
+  if (registered)
+    return;
+  registered = true;
+  if (typeof Bun !== "undefined" && typeof Bun.plugin === "function") {
+    Bun.plugin({
+      name: "tsci-static-assets",
+      setup(build) {
+        build.onLoad({ filter: staticAssetFilter }, (args) => {
+          return {
+            contents: `export default ${JSON.stringify(args.path)};`,
+            loader: "js"
+          };
+        });
+      }
+    });
+  }
+};
+var init_register_static_asset_loaders = __esm(() => {
+  TEXT_STATIC_ASSET_EXTENSIONS = [
+    ".gltf",
+    ".step",
+    ".kicad_mod",
+    ".kicad_pcb",
+    ".kicad_pro",
+    ".kicad_sch"
+  ];
+  staticAssetFilter = new RegExp(`(${TEXT_STATIC_ASSET_EXTENSIONS.map((ext) => ext.replace(".", "\\.")).join("|")})$`, "i");
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM2(require_commander(), 1);
 var {
@@ -71566,106 +71976,8 @@ import fs2 from "node:fs";
 import path from "node:path";
 
 // lib/shared/get-package-manager.ts
+init_kleur();
 import fs from "fs";
-
-// node_modules/kleur/index.mjs
-var FORCE_COLOR;
-var NODE_DISABLE_COLORS;
-var NO_COLOR;
-var TERM;
-var isTTY = true;
-if (typeof process !== "undefined") {
-  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
-  isTTY = process.stdout && process.stdout.isTTY;
-}
-var $ = {
-  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
-  reset: init(0, 0),
-  bold: init(1, 22),
-  dim: init(2, 22),
-  italic: init(3, 23),
-  underline: init(4, 24),
-  inverse: init(7, 27),
-  hidden: init(8, 28),
-  strikethrough: init(9, 29),
-  black: init(30, 39),
-  red: init(31, 39),
-  green: init(32, 39),
-  yellow: init(33, 39),
-  blue: init(34, 39),
-  magenta: init(35, 39),
-  cyan: init(36, 39),
-  white: init(37, 39),
-  gray: init(90, 39),
-  grey: init(90, 39),
-  bgBlack: init(40, 49),
-  bgRed: init(41, 49),
-  bgGreen: init(42, 49),
-  bgYellow: init(43, 49),
-  bgBlue: init(44, 49),
-  bgMagenta: init(45, 49),
-  bgCyan: init(46, 49),
-  bgWhite: init(47, 49)
-};
-function run(arr, str) {
-  let i = 0, tmp, beg = "", end = "";
-  for (;i < arr.length; i++) {
-    tmp = arr[i];
-    beg += tmp.open;
-    end += tmp.close;
-    if (!!~str.indexOf(tmp.close)) {
-      str = str.replace(tmp.rgx, tmp.close + tmp.open);
-    }
-  }
-  return beg + str + end;
-}
-function chain(has, keys) {
-  let ctx = { has, keys };
-  ctx.reset = $.reset.bind(ctx);
-  ctx.bold = $.bold.bind(ctx);
-  ctx.dim = $.dim.bind(ctx);
-  ctx.italic = $.italic.bind(ctx);
-  ctx.underline = $.underline.bind(ctx);
-  ctx.inverse = $.inverse.bind(ctx);
-  ctx.hidden = $.hidden.bind(ctx);
-  ctx.strikethrough = $.strikethrough.bind(ctx);
-  ctx.black = $.black.bind(ctx);
-  ctx.red = $.red.bind(ctx);
-  ctx.green = $.green.bind(ctx);
-  ctx.yellow = $.yellow.bind(ctx);
-  ctx.blue = $.blue.bind(ctx);
-  ctx.magenta = $.magenta.bind(ctx);
-  ctx.cyan = $.cyan.bind(ctx);
-  ctx.white = $.white.bind(ctx);
-  ctx.gray = $.gray.bind(ctx);
-  ctx.grey = $.grey.bind(ctx);
-  ctx.bgBlack = $.bgBlack.bind(ctx);
-  ctx.bgRed = $.bgRed.bind(ctx);
-  ctx.bgGreen = $.bgGreen.bind(ctx);
-  ctx.bgYellow = $.bgYellow.bind(ctx);
-  ctx.bgBlue = $.bgBlue.bind(ctx);
-  ctx.bgMagenta = $.bgMagenta.bind(ctx);
-  ctx.bgCyan = $.bgCyan.bind(ctx);
-  ctx.bgWhite = $.bgWhite.bind(ctx);
-  return ctx;
-}
-function init(open, close) {
-  let blk = {
-    open: `\x1B[${open}m`,
-    close: `\x1B[${close}m`,
-    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
-  };
-  return function(txt) {
-    if (this !== undefined && this.has !== undefined) {
-      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
-      return txt === undefined ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
-    }
-    return txt === undefined ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
-  };
-}
-var kleur_default = $;
-
-// lib/shared/get-package-manager.ts
 import { execSync } from "node:child_process";
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -74128,7 +74440,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.769";
+var version = "0.1.771";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -74181,6 +74493,7 @@ var package_default = {
     "looks-same": "^9.0.1",
     "make-vfs": "^1.0.15",
     md5: "^2.3.0",
+    multithreading: "^0.3.45",
     "perfect-cli": "^1.0.21",
     playwright: "^1.57.0",
     poppygl: "^0.0.12",
@@ -74189,7 +74502,7 @@ var package_default = {
     semver: "^7.6.3",
     sharp: "0.32.6",
     tempy: "^3.1.0",
-    tscircuit: "^0.0.1136-libonly",
+    tscircuit: "^0.0.1160-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
     zod: "^3.23.8"
@@ -74225,6 +74538,9 @@ var package_default = {
   type: "module"
 };
 
+// lib/shared/check-for-cli-update.ts
+init_kleur();
+
 // lib/utils/prompts.ts
 var import_prompts = __toESM2(require_prompts3(), 1);
 
@@ -77723,6 +78039,7 @@ function watch(paths, options = {}) {
 }
 
 // lib/shared/push-snippet.ts
+init_kleur();
 var import_semver3 = __toESM2(require_semver2(), 1);
 import * as fs13 from "node:fs";
 import * as path15 from "node:path";
@@ -77731,6 +78048,7 @@ import Debug from "debug";
 // lib/shared/get-entrypoint.ts
 import * as fs9 from "node:fs";
 import * as path11 from "node:path";
+init_kleur();
 var ALLOWED_ENTRYPOINT_NAMES = Object.freeze([
   "index.tsx",
   "index.ts",
@@ -78758,6 +79076,7 @@ Publish completed with ${uploadResults.succeeded.length} files uploaded and ${up
 };
 
 // lib/shared/add-package.ts
+init_kleur();
 import * as fs16 from "node:fs";
 import * as path18 from "node:path";
 
@@ -78790,6 +79109,7 @@ async function resolveTarballUrlFromRegistry(packageName) {
 // lib/shared/detect-and-setup-kicad-library.ts
 import * as fs14 from "node:fs";
 import * as path16 from "node:path";
+init_kleur();
 var import_strip_json_comments = __toESM2(require_strip_json_comments(), 1);
 function extractPackageName(packageSpec) {
   if (packageSpec.startsWith("http")) {
@@ -78880,6 +79200,7 @@ async function setupTsConfig(projectDir) {
 }
 
 // lib/shared/handle-registry-auth-error.ts
+init_kleur();
 import fs15 from "node:fs";
 import os2 from "node:os";
 import path17 from "node:path";
@@ -78993,6 +79314,7 @@ async function addPackage(packageSpec, projectDir = process.cwd()) {
 }
 
 // cli/dev/DevServer.ts
+init_kleur();
 import Debug2 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
@@ -79803,6 +80125,9 @@ var resolveDevTarget = async (file) => {
   return { absolutePath: availableFiles[0], projectDir };
 };
 
+// cli/dev/register.ts
+init_kleur();
+
 // lib/getVersion.ts
 var import_semver4 = __toESM2(require_semver2(), 1);
 var getVersion = () => {
@@ -79911,7 +80236,11 @@ function createDelay({ clearTimeout: defaultClear, setTimeout: defaultSet } = {}
 var delay2 = createDelay();
 var delay_default = delay2;
 
+// cli/auth/login/register.ts
+init_kleur();
+
 // cli/auth/setup-npmrc/setup-npmrc.ts
+init_kleur();
 import * as fs22 from "node:fs";
 import * as path24 from "node:path";
 import * as os3 from "node:os";
@@ -80089,9 +80418,11 @@ var registerConfigPrint = (program3) => {
 // cli/clone/register.ts
 import * as fs25 from "node:fs";
 import * as path27 from "node:path";
+init_kleur();
 
 // cli/clone/clone-bug-report.ts
 var import_jszip = __toESM2(require_lib4(), 1);
+init_kleur();
 var import_prompts7 = __toESM2(require_prompts3(), 1);
 import * as fs24 from "node:fs";
 import * as path26 from "node:path";
@@ -84478,37 +84809,7 @@ function createKicadLibraryConverterContext(params2) {
 import fs27 from "node:fs";
 import path29 from "node:path";
 import { pathToFileURL } from "node:url";
-
-// lib/shared/importFromUserLand.ts
-import { createRequire as createRequire2 } from "node:module";
-import fs26 from "node:fs";
-import path28 from "node:path";
-async function importFromUserLand(moduleName) {
-  const userModulePath = path28.join(process.cwd(), "node_modules", moduleName);
-  if (fs26.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path28.join(process.cwd(), "noop.js"));
-    try {
-      const resolvedUserPath = userRequire.resolve(moduleName);
-      return await import(resolvedUserPath);
-    } catch (error) {
-      if (error?.code !== "MODULE_NOT_FOUND") {
-        throw error;
-      }
-    }
-  }
-  const cliRequire = createRequire2(import.meta.url);
-  try {
-    const resolvedCliPath = cliRequire.resolve(moduleName);
-    return await import(resolvedCliPath);
-  } catch (error) {
-    if (error?.code !== "MODULE_NOT_FOUND") {
-      throw error;
-    }
-  }
-  return import(moduleName);
-}
-
-// lib/shared/convert-to-kicad-library.tsx
+init_importFromUserLand();
 import { jsxDEV } from "react/jsx-dev-runtime";
 async function convertToKicadLibrary({
   filePath,
@@ -84576,109 +84877,8 @@ async function convertToKicadLibrary({
 }
 
 // lib/shared/export-snippet.ts
+init_generate_circuit_json();
 var import_jszip2 = __toESM2(require_lib4(), 1);
-
-// lib/shared/generate-circuit-json.tsx
-var import_make_vfs2 = __toESM2(require_dist8(), 1);
-import path30 from "node:path";
-import fs28 from "node:fs";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-import Debug11 from "debug";
-
-// lib/utils/abbreviate-stringify-object.ts
-var abbreviateStringifyObject = (obj) => {
-  if (obj === null || obj === undefined)
-    return obj;
-  if (typeof obj !== "object")
-    return obj;
-  return JSON.stringify(Object.fromEntries(Object.entries(obj).map(([k, v]) => {
-    return [
-      k,
-      typeof v === "string" ? v.slice(0, 100) : typeof v === "object" && v !== null ? abbreviateStringifyObject(v) : v
-    ];
-  })));
-};
-
-// lib/shared/generate-circuit-json.tsx
-import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
-var debug11 = Debug11("tsci:generate-circuit-json");
-var ALLOWED_FILE_EXTENSIONS = [
-  ".tsx",
-  ".ts",
-  ".jsx",
-  ".js",
-  ".json",
-  ".txt",
-  ".md",
-  ".obj",
-  ".kicad_mod"
-];
-async function generateCircuitJson({
-  filePath,
-  outputDir,
-  outputFileName,
-  saveToFile = false,
-  platformConfig
-}) {
-  debug11(`Generating circuit JSON for ${filePath}`);
-  const React = await importFromUserLand("react");
-  globalThis.React = React;
-  const userLandTscircuit = await importFromUserLand("tscircuit");
-  const runner = new userLandTscircuit.RootCircuit({
-    platform: platformConfig
-  });
-  const absoluteFilePath = path30.isAbsolute(filePath) ? filePath : path30.resolve(process.cwd(), filePath);
-  const projectDir = path30.dirname(absoluteFilePath);
-  const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path30.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path30.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path30.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
-  debug11(`Project directory: ${projectDir}`);
-  debug11(`Relative component path: ${relativeComponentPath}`);
-  debug11(`Output path: ${outputPath}`);
-  const fsMap = {
-    ...await import_make_vfs2.getVirtualFileSystemFromDirPath({
-      dirPath: projectDir,
-      fileMatchFn: (filePath2) => {
-        const normalizedFilePath = filePath2.replace(/\\/g, "/");
-        if (normalizedFilePath.endsWith(".kicad_mod")) {
-          return true;
-        }
-        if (normalizedFilePath.includes("node_modules/"))
-          return false;
-        if (normalizedFilePath.includes("dist/"))
-          return false;
-        if (normalizedFilePath.includes("build/"))
-          return false;
-        if (normalizedFilePath.match(/^\.[^/]/))
-          return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path30.extname(normalizedFilePath)))
-          return false;
-        return true;
-      },
-      contentFormat: "string"
-    })
-  };
-  debug11(`fsMap: ${abbreviateStringifyObject(fsMap)}`);
-  const MainComponent = await import(pathToFileURL2(absoluteFilePath).href);
-  const Component = MainComponent.default || (Object.keys(MainComponent).find((k) => k[0] === k[0].toUpperCase()) !== undefined ? MainComponent[Object.keys(MainComponent).find((k) => k[0] === k[0].toUpperCase())] : undefined);
-  if (!Component) {
-    throw new Error(`No component found in "${absoluteFilePath}". Make sure you export a component.`);
-  }
-  runner.add(/* @__PURE__ */ jsxDEV2(Component, {}, undefined, false, undefined, this));
-  await runner.renderUntilSettled();
-  const circuitJson = await runner.getCircuitJson();
-  if (saveToFile) {
-    debug11(`Saving circuit JSON to ${outputPath}`);
-    fs28.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-  }
-  return {
-    circuitJson,
-    outputPath
-  };
-}
-
-// lib/shared/export-snippet.ts
 var writeFileAsync = promisify3(fs29.writeFile);
 var ALLOWED_EXPORT_FORMATS = [
   "json",
@@ -84817,6 +85017,9 @@ var exportSnippet = async ({
   onExit(0);
 };
 
+// cli/export/register.ts
+init_generate_circuit_json();
+
 // lib/shared/get-spice-with-sim.ts
 import { circuitJsonToSpice } from "circuit-json-to-spice";
 var formatSimTime = (seconds) => {
@@ -85096,6 +85299,7 @@ var registerAuthSetToken = (program3) => {
 };
 
 // cli/auth/whoami/register.ts
+init_kleur();
 var formatDate = (date) => {
   if (!date)
     return null;
@@ -85155,6 +85359,7 @@ var registerAdd = (program3) => {
 };
 
 // cli/upgrade/register.ts
+init_kleur();
 function registerUpgradeCommand(program3) {
   program3.command("upgrade").description("Upgrade CLI to the latest version").action(async () => {
     const isUpdated = await updateTsciIfNewVersionIsAvailable();
@@ -85165,6 +85370,7 @@ function registerUpgradeCommand(program3) {
 }
 
 // cli/config/set/register.ts
+init_kleur();
 var availableGlobalConfigKeys = [
   "alwaysCloneWithAuthorName"
 ];
@@ -86500,6 +86706,7 @@ Fuse.config = Config;
 }
 
 // cli/search/register.ts
+init_kleur();
 var registerSearch = (program3) => {
   program3.command("search").description("Search for footprints, CAD models or packages in the tscircuit ecosystem").argument("<query>", "Search query (e.g. keyword, author, or package name)").option("--kicad", "Only search KiCad footprints").action(async (query, opts) => {
     const onlyKicad = opts.kicad;
@@ -86553,6 +86760,9 @@ var registerSearch = (program3) => {
   });
 };
 
+// cli/import/register.ts
+init_kleur();
+
 // node_modules/easyeda/dist/browser/chunk-ZVLWDN7A.js
 var __create3 = Object.create;
 var __defProp3 = Object.defineProperty;
@@ -86568,7 +86778,7 @@ var __require2 = /* @__PURE__ */ ((x) => __require)(function(x) {
 var __commonJS2 = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames3(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export2 = (target, all) => {
+var __export3 = (target, all) => {
   for (var name in all)
     __defProp3(target, name, { get: all[name], enumerable: true });
 };
@@ -87362,7 +87572,7 @@ var require_svgson_umd = __commonJS2({
   }
 });
 var dist_exports = {};
-__export2(dist_exports, {
+__export3(dist_exports, {
   all_layers: () => all_layers,
   any_circuit_element: () => any_circuit_element,
   any_soup_element: () => any_soup_element,
@@ -87540,7 +87750,7 @@ __export2(dist_exports, {
   wave_shape: () => wave_shape
 });
 var external_exports = {};
-__export2(external_exports, {
+__export3(external_exports, {
   BRAND: () => BRAND,
   DIRTY: () => DIRTY,
   EMPTY_PATH: () => EMPTY_PATH,
@@ -121346,7 +121556,7 @@ var import_constants14 = __toESM3(require_constants6(), 1);
 var import_debug62 = __toESM3(require_browser(), 1);
 var import_debug72 = __toESM3(require_browser(), 1);
 var esm_exports2 = {};
-__export2(esm_exports2, {
+__export3(esm_exports2, {
   DocumentPosition: () => DocumentPosition,
   append: () => append,
   appendChild: () => appendChild,
@@ -154561,12 +154771,12 @@ var import_jsx_runtime5 = __toESM3(require_jsx_runtime(), 1);
 var import_jsx_runtime6 = __toESM3(require_jsx_runtime(), 1);
 var import_react7 = __toESM3(require_react(), 1);
 var __defProp32 = Object.defineProperty;
-var __export3 = (target, all) => {
+var __export32 = (target, all) => {
   for (var name in all)
     __defProp32(target, name, { get: all[name], enumerable: true });
 };
 var components_exports = {};
-__export3(components_exports, {
+__export32(components_exports, {
   AnalogSimulation: () => AnalogSimulation,
   Battery: () => Battery,
   Board: () => Board,
@@ -172425,145 +172635,16 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
+init_build_file();
 import path47 from "node:path";
 import fs47 from "node:fs";
 
-// cli/build/build-file.ts
-import path35 from "node:path";
-import fs35 from "node:fs";
-
-// lib/shared/circuit-json-diagnostics.ts
-function analyzeCircuitJson(circuitJson) {
-  const errors = [];
-  const warnings = [];
-  for (const item of circuitJson) {
-    if (!item || typeof item !== "object")
-      continue;
-    const t3 = item.type;
-    if (typeof t3 === "string") {
-      if (t3.endsWith("_error"))
-        errors.push(item);
-      else if (t3.endsWith("_warning"))
-        warnings.push(item);
-    }
-    if ("error_type" in item)
-      errors.push(item);
-    if ("warning_type" in item)
-      warnings.push(item);
-  }
-  return { errors, warnings };
-}
-
-// lib/shared/get-complete-platform-config.ts
-import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function getCompletePlatformConfig(userConfig) {
-  const basePlatformConfig = getPlatformConfig();
-  const defaultConfig = {
-    ...basePlatformConfig,
-    footprintFileParserMap: {
-      ...basePlatformConfig.footprintFileParserMap,
-      kicad_mod: {
-        loadFromUrl: async (url) => {
-          const fetchUrl = url.startsWith("/") ? `file://${url}` : url;
-          return basePlatformConfig.footprintFileParserMap.kicad_mod.loadFromUrl(fetchUrl);
-        }
-      }
-    }
-  };
-  if (!userConfig) {
-    return defaultConfig;
-  }
-  return {
-    ...defaultConfig,
-    ...userConfig,
-    footprintFileParserMap: {
-      ...defaultConfig.footprintFileParserMap,
-      ...userConfig.footprintFileParserMap
-    }
-  };
-}
-
-// cli/build/build-file.ts
-var buildFile = async (input, output, projectDir, options) => {
-  try {
-    console.log("Generating circuit JSON...");
-    const completePlatformConfig = getCompletePlatformConfig(options?.platformConfig);
-    const result = await generateCircuitJson({
-      filePath: input,
-      platformConfig: completePlatformConfig
-    });
-    fs35.mkdirSync(path35.dirname(output), { recursive: true });
-    fs35.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
-    console.log(`Circuit JSON written to ${path35.relative(projectDir, output)}`);
-    const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
-    if (!options?.ignoreWarnings) {
-      for (const warn of warnings) {
-        const msg = warn.message || JSON.stringify(warn);
-        console.log(kleur_default.yellow(msg));
-      }
-    }
-    if (!options?.ignoreErrors) {
-      for (const err of errors) {
-        const msg = err.message || JSON.stringify(err);
-        console.error(kleur_default.red(msg));
-        console.log(err.stack);
-      }
-    }
-    if (errors.length > 0 && !options?.ignoreErrors) {
-      console.error(kleur_default.red(`Build failed with ${errors.length} error(s). Use --ignore-errors to continue.`));
-      return { ok: false };
-    } else {
-      return {
-        ok: true,
-        circuitJson: result.circuitJson
-      };
-    }
-  } catch (err) {
-    console.error(err);
-    if (err instanceof Error) {
-      logTsxExtensionHint(err, input);
-      logTypeReexportHint(err, input);
-    }
-    return { ok: false };
-  }
-};
-var logTsxExtensionHint = (error, entryFilePath) => {
-  const lowerPath = entryFilePath.toLowerCase();
-  const isTsEntry = lowerPath.endsWith(".ts") && !lowerPath.endsWith(".d.ts");
-  const isAggregateError = error instanceof AggregateError || String(error).includes("AggregateError");
-  if (!isTsEntry || !isAggregateError)
-    return;
-  const entryFileName = path35.basename(entryFilePath);
-  console.error([
-    "",
-    `It looks like "${entryFileName}" is a ".ts" file. tscircuit component files must use the ".tsx" extension.`,
-    "Try renaming the file to .tsx and re-running the build.",
-    ""
-  ].join(`
-`));
-};
-var TYPE_REEXPORT_ERROR_REGEX = /SyntaxError: export '([^']+)' not found in '([^']+)'/;
-var logTypeReexportHint = (error, entryFilePath) => {
-  const match = String(error).match(TYPE_REEXPORT_ERROR_REGEX);
-  if (!match)
-    return;
-  const [, exportName, fromSpecifier] = match;
-  const entryFileName = path35.basename(entryFilePath);
-  console.error([
-    "",
-    `It looks like "${entryFileName}" re-exports the type-only symbol "${exportName}" from "${fromSpecifier}" without the "type" modifier.`,
-    "Type-only exports must be re-exported with `export type { ... }`.",
-    "Try rewriting the statement as:",
-    `  export type { ${exportName} } from "${fromSpecifier}"`,
-    ""
-  ].join(`
-`));
-};
-
 // cli/build/build-ci.ts
+init_kleur();
 import { execSync as execSync3 } from "node:child_process";
 
 // lib/shared/install-project-dependencies.ts
+init_kleur();
 import fs37 from "node:fs";
 import path37 from "node:path";
 
@@ -173148,6 +173229,7 @@ var generateKicadProject = async ({
 };
 
 // cli/build/build-kicad-pcm.ts
+init_kleur();
 import path43 from "node:path";
 import fs43 from "node:fs";
 
@@ -173343,6 +173425,7 @@ async function buildKicadPcm({
 }
 
 // cli/build/transpile/index.ts
+init_kleur();
 import path45 from "node:path";
 import fs45 from "node:fs";
 import { rollup } from "rollup";
@@ -173679,10 +173762,2657 @@ async function getLatestTscircuitCdnUrl() {
   return `https://cdn.jsdelivr.net/npm/tscircuit@${version2}/dist/browser.min.js`;
 }
 
+// cli/build/register.ts
+init_kleur();
+
+// node_modules/multithreading/src/node/polyfill.js
+import { isMainThread, parentPort, Worker as NodeWorker } from "node:worker_threads";
+globalThis.self = globalThis;
+globalThis.ErrorEvent = class ErrorEvent2 extends Event {
+  constructor(type, init2) {
+    super(type, init2);
+    this.message = init2?.message || "";
+    this.filename = init2?.filename || "";
+    this.lineno = init2?.lineno || 0;
+    this.colno = init2?.colno || 0;
+    this.error = init2?.error || null;
+  }
+};
+if (isMainThread) {
+  globalThis.Worker = class Worker2 extends EventTarget {
+    constructor(scriptURL, options) {
+      super();
+      this.onmessage = null;
+      this.onerror = null;
+      const urlStr = scriptURL.toString();
+      const finalPath = urlStr.startsWith("file://") ? new URL(urlStr) : urlStr;
+      this._worker = new NodeWorker(finalPath, { ...options });
+      this._worker.on("message", (data) => {
+        const event = new MessageEvent("message", { data });
+        this.dispatchEvent(event);
+        if (this.onmessage)
+          this.onmessage(event);
+      });
+      this._worker.on("error", (error) => {
+        const event = new ErrorEvent("error", {
+          error,
+          message: error.message
+        });
+        this.dispatchEvent(event);
+        if (this.onerror)
+          this.onerror(event);
+      });
+      this._worker.on("exit", (code) => {
+        if (code !== 0) {
+          const err = new Error(`Worker stopped with exit code ${code}`);
+          const event = new ErrorEvent("error", {
+            error: err,
+            message: err.message
+          });
+          this.dispatchEvent(event);
+          if (this.onerror)
+            this.onerror(event);
+        }
+      });
+    }
+    postMessage(message, transfer) {
+      this._worker.postMessage(message, transfer);
+    }
+    terminate() {
+      this._worker.terminate();
+    }
+  };
+}
+if (!isMainThread && parentPort) {
+
+  class WorkerGlobalScope extends EventTarget {
+    static [Symbol.hasInstance](instance) {
+      return instance === globalThis;
+    }
+  }
+  globalThis.WorkerGlobalScope = WorkerGlobalScope;
+  globalThis.postMessage = (message, transfer) => {
+    parentPort.postMessage(message, transfer);
+  };
+  let currentHandler = globalThis.onmessage;
+  parentPort.on("message", (data) => {
+    const event = new MessageEvent("message", { data });
+    if (typeof globalThis.onmessage === "function") {
+      globalThis.onmessage(event);
+    }
+  });
+  Object.defineProperty(globalThis, "onmessage", {
+    get: () => currentHandler,
+    set: (fn3) => {
+      currentHandler = fn3;
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+
+// node_modules/multithreading/src/lib/shared.js
+var toSerialized = Symbol("Thread.Serialize");
+var toDeserialized = Symbol("Thread.Deserialize");
+
+class Serializable {
+  static [toDeserialized](obj) {
+    throw new Error(`[toDeserialized] not implemented for ${this.name}`);
+  }
+}
+var classRegistry = new Map;
+var reverseClassRegistry = new Map;
+function register2(typeId, cls) {
+  classRegistry.set(typeId, cls);
+  reverseClassRegistry.set(cls, typeId);
+}
+var TRANSFERABLE_CLASSES = [
+  MessagePort,
+  ReadableStream,
+  WritableStream,
+  TransformStream,
+  ArrayBuffer
+];
+function serialize(arg) {
+  if (arg === null || arg === undefined) {
+    return { value: { t: 0, v: arg }, transfer: [] };
+  }
+  if (typeof arg === "object" && arg !== null && typeof arg[toSerialized] === "function") {
+    const { value, transfer: transfer2, typeId } = arg[toSerialized]();
+    const Ctor = arg.constructor;
+    return {
+      value: {
+        t: 1,
+        c: typeId ?? reverseClassRegistry.get(Ctor),
+        v: value
+      },
+      transfer: transfer2
+    };
+  }
+  const transfer = [];
+  if (arg instanceof SharedArrayBuffer) {} else if (ArrayBuffer.isView(arg)) {
+    if (!(arg.buffer instanceof SharedArrayBuffer)) {
+      transfer.push(arg.buffer);
+    }
+  } else if (TRANSFERABLE_CLASSES.some((t3) => arg instanceof t3)) {
+    transfer.push(arg);
+  }
+  return {
+    value: { t: 0, v: arg },
+    transfer
+  };
+}
+function deserialize(envelope) {
+  if (!envelope || typeof envelope !== "object")
+    return envelope;
+  if (envelope.t === 0) {
+    return envelope.v;
+  }
+  if (envelope.t === 1) {
+    const Cls = classRegistry.get(envelope.c);
+    if (Cls) {
+      return Cls[toDeserialized](envelope.v);
+    }
+    throw new Error(`Unknown TypeID ${envelope.c}. Did you forget to import the class?`);
+  }
+  return envelope;
+}
+
+// node_modules/multithreading/src/lib/pool.js
+var newWorker;
+function workerOverride(fn3) {
+  newWorker = fn3;
+}
+
+class WorkerPool {
+  constructor(maxThreads) {
+    this.workers = [];
+    this.taskIdCounter = 0;
+    this.maxThreads = maxThreads || navigator.hardwareConcurrency || 4;
+  }
+  createWorker() {
+    const worker = newWorker();
+    worker._loadedFnIds = new Set;
+    worker._pending = new Map;
+    worker.onmessage = (e4) => {
+      const { taskId, type } = e4.data;
+      const p4 = worker._pending.get(taskId);
+      if (p4) {
+        if (type === "ERROR") {
+          const err = new Error(e4.data.error);
+          if (e4.data.stack)
+            err.stack = e4.data.stack;
+          p4.reject(err);
+        } else {
+          p4.resolve(deserialize(e4.data.result));
+        }
+        worker._pending.delete(taskId);
+      }
+    };
+    worker.onerror = (e4) => {
+      e4.preventDefault();
+      const err = new Error(`Worker Crashed: ${e4.message}`);
+      for (const p4 of worker._pending.values())
+        p4.reject(err);
+      worker._pending.clear();
+      this.removeWorker(worker);
+    };
+    this.workers.push(worker);
+    return worker;
+  }
+  removeWorker(worker) {
+    this.workers = this.workers.filter((w4) => w4 !== worker);
+    worker.terminate();
+  }
+  async executeTask(worker, task) {
+    const { fnId, code, args } = task;
+    const taskId = this.taskIdCounter++;
+    const { promise, resolve: resolve12, reject } = Promise.withResolvers();
+    worker._pending.set(taskId, { resolve: resolve12, reject });
+    const serializedArgs = args.map(serialize);
+    const values = serializedArgs.map((r4) => r4.value);
+    const transferList = [
+      ...new Set(serializedArgs.flatMap((r4) => r4.transfer))
+    ];
+    const hasCode = worker._loadedFnIds.has(fnId);
+    if (!hasCode) {
+      worker._loadedFnIds.add(fnId);
+    }
+    worker.postMessage({
+      type: "RUN",
+      taskId,
+      fnId,
+      code: hasCode ? undefined : code,
+      args: values
+    }, { transfer: transferList });
+    return await promise;
+  }
+  async submit(task) {
+    let bestCandidate;
+    let bestCandidateLoad = Infinity;
+    let bestCandidateScore = 4;
+    for (let i3 = 0;i3 < this.workers.length; i3++) {
+      const w4 = this.workers[i3];
+      const load3 = w4._pending.size;
+      const hasAffinity = w4._loadedFnIds.has(task.fnId);
+      if (load3 === 0 && hasAffinity) {
+        return await this.executeTask(w4, task);
+      }
+      let score = 4;
+      if (load3 === 0)
+        score = 1;
+      else if (hasAffinity)
+        score = 2;
+      else
+        score = 3;
+      if (score < bestCandidateScore || score === bestCandidateScore && load3 < bestCandidateLoad) {
+        bestCandidate = w4;
+        bestCandidateScore = score;
+        bestCandidateLoad = load3;
+      }
+    }
+    if (bestCandidateScore >= 2 && this.workers.length < this.maxThreads) {
+      return await this.executeTask(this.createWorker(), task);
+    }
+    if (bestCandidate) {
+      return await this.executeTask(bestCandidate, task);
+    }
+    return await this.executeTask(this.createWorker(), task);
+  }
+  terminate() {
+    for (const w4 of this.workers)
+      w4.terminate();
+    this.workers = [];
+  }
+}
+
+// node_modules/multithreading/src/lib/caller_location.js
+function getCallerLocation() {
+  const internalFiles = [
+    "caller_location.ts",
+    "caller_location.js",
+    "lib.ts",
+    "lib.js",
+    "internal",
+    "node_modules",
+    "native"
+  ];
+  const stack = new Error().stack;
+  const lines = stack.split(`
+`);
+  let callerLine;
+  for (let i3 = 0;i3 < lines.length; i3++) {
+    const line2 = lines[i3];
+    if (line2.trim() === "Error")
+      continue;
+    const isInternal = internalFiles.some((file) => line2.includes(file));
+    if (!isInternal) {
+      callerLine = line2;
+      break;
+    }
+  }
+  if (!callerLine) {
+    throw new Error("Could not find caller line in stack trace");
+  }
+  const matchParen = callerLine.match(/\((.*)\)/);
+  let pathWithCoords = matchParen ? matchParen[1] : callerLine.replace(/^\s*at\s+/, "").trim();
+  pathWithCoords = pathWithCoords.replace(/^async\s+/, "");
+  const coordMatch = pathWithCoords.match(/:(\d+):(\d+)$/);
+  if (!coordMatch) {
+    throw new Error(`Could not parse coordinates from: ${callerLine}`);
+  }
+  const filePath = pathWithCoords.replace(/:\d+:\d+$/, "");
+  return {
+    filePath,
+    line: Number(coordMatch[1]) - 1,
+    column: Number(coordMatch[2]) - 1
+  };
+}
+
+// node_modules/multithreading/src/lib/patch_import.js
+function patchDynamicImports(code, callerLocation) {
+  let normalizedCaller = callerLocation;
+  if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(normalizedCaller)) {
+    normalizedCaller = normalizedCaller.replace(/\\/g, "/");
+    if (!normalizedCaller.startsWith("/")) {
+      normalizedCaller = "/" + normalizedCaller;
+    }
+    normalizedCaller = "file://" + normalizedCaller;
+  }
+  const importStartPattern = /\bimport\s*\(/g;
+  const replacements = [];
+  let match;
+  while ((match = importStartPattern.exec(code)) !== null) {
+    const importStartIndex = match.index;
+    const openParenIndex = importStartIndex + match[0].length - 1;
+    const argBounds = findArgumentBounds(code, openParenIndex + 1);
+    if (argBounds) {
+      const { start, end } = argBounds;
+      const originalArgument = code.slice(start, end);
+      const isStringLiteral2 = /^["'`]/.test(originalArgument);
+      let shouldApplyFallback = true;
+      if (isStringLiteral2) {
+        const content = originalArgument.slice(1, -1);
+        const isExplicitPath = /^\.{0,2}[/\\]|^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(content);
+        if (!isExplicitPath) {
+          shouldApplyFallback = false;
+          try {
+            const resolvedUrl = import.meta.resolve(content);
+            replacements.push({
+              start,
+              end,
+              text: JSON.stringify(resolvedUrl)
+            });
+          } catch (e4) {}
+        }
+      }
+      if (shouldApplyFallback) {
+        let base = `new URL(${JSON.stringify(normalizedCaller)}, import.meta.url).href`;
+        if (isStringLiteral2) {
+          const content = originalArgument.slice(1, -1);
+          if (content.startsWith("/") || content.startsWith("\\")) {
+            base = `(typeof location !== "undefined" ? location.origin : import.meta.url)`;
+          }
+        }
+        const newArgument = `new URL(${originalArgument}, ${base}).href`;
+        replacements.push({
+          start,
+          end,
+          text: newArgument
+        });
+      }
+    }
+  }
+  replacements.sort((a3, b3) => b3.start - a3.start);
+  let modifiedCode = code;
+  for (let i3 = 0;i3 < replacements.length; i3++) {
+    const rep = replacements[i3];
+    const before = modifiedCode.slice(0, rep.start);
+    const after = modifiedCode.slice(rep.end);
+    modifiedCode = before + rep.text + after;
+  }
+  return modifiedCode;
+}
+function findArgumentBounds(code, startIndex) {
+  let index = startIndex;
+  const len = code.length;
+  let inString = null;
+  let inComment = null;
+  let parenDepth = 0;
+  let argStart = -1;
+  let argEnd = -1;
+  for (;index < len; index++) {
+    const char = code[index];
+    const nextChar = code[index + 1];
+    if (inString) {
+      if (char === "\\" && index + 1 < len) {
+        index++;
+        argEnd = index + 1;
+        continue;
+      }
+      if (char === inString)
+        inString = null;
+      if (argStart === -1)
+        argStart = index;
+      argEnd = index + 1;
+      continue;
+    }
+    if (inComment) {
+      if (inComment === "//" && char === `
+`)
+        inComment = null;
+      else if (inComment === "/*" && char === "*" && nextChar === "/") {
+        inComment = null;
+        index++;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      if (argStart === -1)
+        argStart = index;
+      argEnd = index + 1;
+      continue;
+    }
+    if (char === "/" && nextChar === "/") {
+      inComment = "//";
+      index++;
+      continue;
+    }
+    if (char === "/" && nextChar === "*") {
+      inComment = "/*";
+      index++;
+      continue;
+    }
+    if (char === "(") {
+      parenDepth++;
+      if (argStart === -1)
+        argStart = index;
+      argEnd = index + 1;
+    } else if (char === ")") {
+      if (parenDepth === 0) {
+        if (argStart === -1)
+          return null;
+        return { start: argStart, end: argEnd };
+      }
+      parenDepth--;
+      if (argStart === -1)
+        argStart = index;
+      argEnd = index + 1;
+    } else if (char === ",") {
+      if (parenDepth === 0) {
+        if (argStart === -1)
+          return null;
+        return { start: argStart, end: argEnd };
+      }
+      if (argStart === -1)
+        argStart = index;
+      argEnd = index + 1;
+    } else {
+      if (!/\s/.test(char)) {
+        if (argStart === -1)
+          argStart = index;
+        argEnd = index + 1;
+      }
+    }
+  }
+  return null;
+}
+
+// node_modules/multithreading/src/lib/check_move_args.js
+function checkMoveArgs(args) {
+  for (const arg of args) {
+    const isRawSAB = arg instanceof SharedArrayBuffer;
+    const isViewSAB = ArrayBuffer.isView(arg) && arg.buffer instanceof SharedArrayBuffer;
+    const isThreadSafe = arg instanceof Mutex || arg instanceof Condvar || arg instanceof RwLock || arg instanceof Sender || arg instanceof Receiver || arg instanceof Semaphore || arg instanceof Barrier;
+    const isLibrarySAB = !isThreadSafe && typeof arg[toSerialized] !== "undefined";
+    if (isRawSAB || isViewSAB || isLibrarySAB) {
+      console.warn("Warning: You are passing a SharedArrayBuffer to a worker without locking. Please wrap this data in a Mutex() or RwLock() to prevent race conditions.");
+    }
+  }
+}
+
+// node_modules/multithreading/src/lib/sync/mutex.js
+var __classPrivateFieldSet = function(receiver, state, value, kind, f2) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f2) {
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f2 : kind === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
+};
+var _MutexGuard_data;
+var _MutexGuard_mutex;
+var _MutexGuard_released;
+var _Mutex_instances;
+var _a3;
+var _Mutex_data;
+var _Mutex_lockState;
+var _Mutex_controller;
+var _Mutex_tryLock;
+var _Mutex_unlock;
+var _Mutex_performBlockingLock;
+var _Mutex_performAsyncLock;
+var INTERNAL_MUTEX_CONTROLLER = Symbol("Thread.InternalMutexController");
+var IDX_LOCK_STATE = 0;
+var LOCKED = 1;
+var UNLOCKED = 0;
+
+class MutexGuard {
+  constructor(data, mutex) {
+    _MutexGuard_data.set(this, undefined);
+    _MutexGuard_mutex.set(this, undefined);
+    _MutexGuard_released.set(this, false);
+    __classPrivateFieldSet(this, _MutexGuard_data, data, "f");
+    __classPrivateFieldSet(this, _MutexGuard_mutex, mutex, "f");
+  }
+  get [(_MutexGuard_data = new WeakMap, _MutexGuard_mutex = new WeakMap, _MutexGuard_released = new WeakMap, INTERNAL_MUTEX_CONTROLLER)]() {
+    return __classPrivateFieldGet(this, _MutexGuard_mutex, "f");
+  }
+  get value() {
+    if (__classPrivateFieldGet(this, _MutexGuard_released, "f"))
+      throw new Error("Cannot access released mutex data");
+    return __classPrivateFieldGet(this, _MutexGuard_data, "f");
+  }
+  [Symbol.dispose]() {
+    if (!__classPrivateFieldGet(this, _MutexGuard_released, "f")) {
+      __classPrivateFieldSet(this, _MutexGuard_released, true, "f");
+      __classPrivateFieldGet(this, _MutexGuard_mutex, "f").unlock();
+    }
+  }
+  dispose() {
+    this[Symbol.dispose]();
+  }
+}
+
+class Mutex extends Serializable {
+  constructor(data, _lockBuffer) {
+    super();
+    _Mutex_instances.add(this);
+    _Mutex_data.set(this, undefined);
+    _Mutex_lockState.set(this, undefined);
+    _Mutex_controller.set(this, undefined);
+    __classPrivateFieldSet(this, _Mutex_data, data, "f");
+    __classPrivateFieldSet(this, _Mutex_lockState, _lockBuffer ? new Int32Array(_lockBuffer) : new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), "f");
+    __classPrivateFieldSet(this, _Mutex_controller, {
+      unlock: () => __classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_unlock).call(this),
+      blockingLock: () => __classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_performBlockingLock).call(this),
+      lock: () => __classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_performAsyncLock).call(this)
+    }, "f");
+  }
+  blockingLock() {
+    __classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_performBlockingLock).call(this);
+    return new MutexGuard(__classPrivateFieldGet(this, _Mutex_data, "f"), __classPrivateFieldGet(this, _Mutex_controller, "f"));
+  }
+  async lock() {
+    await __classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_performAsyncLock).call(this);
+    return new MutexGuard(__classPrivateFieldGet(this, _Mutex_data, "f"), __classPrivateFieldGet(this, _Mutex_controller, "f"));
+  }
+  [(_Mutex_data = new WeakMap, _Mutex_lockState = new WeakMap, _Mutex_controller = new WeakMap, _Mutex_instances = new WeakSet, _Mutex_tryLock = function _Mutex_tryLock() {
+    return Atomics.compareExchange(__classPrivateFieldGet(this, _Mutex_lockState, "f"), IDX_LOCK_STATE, UNLOCKED, LOCKED) === UNLOCKED;
+  }, _Mutex_unlock = function _Mutex_unlock() {
+    if (Atomics.compareExchange(__classPrivateFieldGet(this, _Mutex_lockState, "f"), IDX_LOCK_STATE, LOCKED, UNLOCKED) !== LOCKED) {
+      throw new Error("Mutex was not locked or locked by another thread");
+    }
+    Atomics.notify(__classPrivateFieldGet(this, _Mutex_lockState, "f"), IDX_LOCK_STATE, 1);
+  }, _Mutex_performBlockingLock = function _Mutex_performBlockingLock() {
+    while (true) {
+      if (__classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_tryLock).call(this))
+        return;
+      Atomics.wait(__classPrivateFieldGet(this, _Mutex_lockState, "f"), IDX_LOCK_STATE, LOCKED);
+    }
+  }, _Mutex_performAsyncLock = async function _Mutex_performAsyncLock() {
+    while (true) {
+      if (__classPrivateFieldGet(this, _Mutex_instances, "m", _Mutex_tryLock).call(this))
+        return;
+      const result = Atomics.waitAsync(__classPrivateFieldGet(this, _Mutex_lockState, "f"), IDX_LOCK_STATE, LOCKED);
+      if (result.async) {
+        await result.value;
+      }
+    }
+  }, toSerialized)]() {
+    let serializedData;
+    let transfer = [];
+    if (__classPrivateFieldGet(this, _Mutex_data, "f") !== undefined) {
+      const result = serialize(__classPrivateFieldGet(this, _Mutex_data, "f"));
+      serializedData = result.value;
+      transfer = result.transfer;
+    }
+    return {
+      value: {
+        lockBuffer: __classPrivateFieldGet(this, _Mutex_lockState, "f").buffer,
+        data: serializedData
+      },
+      transfer
+    };
+  }
+  static [toDeserialized](obj) {
+    const data = obj.data !== undefined ? deserialize(obj.data) : undefined;
+    return new _a3(data, obj.lockBuffer);
+  }
+}
+_a3 = Mutex;
+(() => {
+  register2(0, _a3);
+})();
+
+// node_modules/multithreading/src/lib/sync/condvar.js
+var __classPrivateFieldSet2 = function(receiver, state, value, kind, f2) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet2 = function(receiver, state, kind, f2) {
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f2 : kind === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
+};
+var _a4;
+var _Condvar_atomic;
+var IDX_NOTIFY_SEQ = 0;
+var SEQ_INCREMENT = 1;
+var NOTIFY_ONE = 1;
+var NOTIFY_ALL = Infinity;
+
+class Condvar extends Serializable {
+  constructor(_buffer) {
+    super();
+    _Condvar_atomic.set(this, undefined);
+    __classPrivateFieldSet2(this, _Condvar_atomic, new Int32Array(_buffer ?? new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), "f");
+  }
+  blockingWait(guard) {
+    const controller = guard[INTERNAL_MUTEX_CONTROLLER];
+    const seq = Atomics.load(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ);
+    controller.unlock();
+    Atomics.wait(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ, seq);
+    controller.blockingLock();
+  }
+  async wait(guard) {
+    const controller = guard[INTERNAL_MUTEX_CONTROLLER];
+    const seq = Atomics.load(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ);
+    controller.unlock();
+    const result = Atomics.waitAsync(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ, seq);
+    if (result.async) {
+      await result.value;
+    }
+    await controller.lock();
+  }
+  notifyOne() {
+    Atomics.add(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ, SEQ_INCREMENT);
+    Atomics.notify(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ, NOTIFY_ONE);
+  }
+  notifyAll() {
+    Atomics.add(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ, SEQ_INCREMENT);
+    Atomics.notify(__classPrivateFieldGet2(this, _Condvar_atomic, "f"), IDX_NOTIFY_SEQ, NOTIFY_ALL);
+  }
+  [(_Condvar_atomic = new WeakMap, toSerialized)]() {
+    return {
+      value: __classPrivateFieldGet2(this, _Condvar_atomic, "f").buffer,
+      transfer: []
+    };
+  }
+  static [toDeserialized](obj) {
+    return new _a4(obj);
+  }
+}
+_a4 = Condvar;
+(() => {
+  register2(1, _a4);
+})();
+// node_modules/multithreading/src/lib/sync/rwlock.js
+var __classPrivateFieldSet3 = function(receiver, state, value, kind, f2) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet3 = function(receiver, state, kind, f2) {
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f2 : kind === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
+};
+var _RwLockReadGuard_data;
+var _RwLockReadGuard_controller;
+var _RwLockReadGuard_released;
+var _RwLockWriteGuard_data;
+var _RwLockWriteGuard_controller;
+var _RwLockWriteGuard_released;
+var _RwLock_instances;
+var _a5;
+var _RwLock_data;
+var _RwLock_lockState;
+var _RwLock_readController;
+var _RwLock_writeController;
+var _RwLock_unlockRead;
+var _RwLock_unlockWrite;
+var INTERNAL_RWLOCK_CONTROLLER = Symbol("Thread.InternalRwLockController");
+var IDX_LOCK_STATE2 = 0;
+var UNLOCKED2 = 0;
+var WRITE_LOCKED = -1;
+var READ_ONE = 1;
+
+class RwLockReadGuard {
+  constructor(data, controller) {
+    _RwLockReadGuard_data.set(this, undefined);
+    _RwLockReadGuard_controller.set(this, undefined);
+    _RwLockReadGuard_released.set(this, false);
+    __classPrivateFieldSet3(this, _RwLockReadGuard_data, data, "f");
+    __classPrivateFieldSet3(this, _RwLockReadGuard_controller, controller, "f");
+  }
+  get [(_RwLockReadGuard_data = new WeakMap, _RwLockReadGuard_controller = new WeakMap, _RwLockReadGuard_released = new WeakMap, INTERNAL_RWLOCK_CONTROLLER)]() {
+    return __classPrivateFieldGet3(this, _RwLockReadGuard_controller, "f");
+  }
+  get value() {
+    if (__classPrivateFieldGet3(this, _RwLockReadGuard_released, "f"))
+      throw new Error("Cannot access released lock data");
+    return __classPrivateFieldGet3(this, _RwLockReadGuard_data, "f");
+  }
+  [Symbol.dispose]() {
+    if (!__classPrivateFieldGet3(this, _RwLockReadGuard_released, "f")) {
+      __classPrivateFieldSet3(this, _RwLockReadGuard_released, true, "f");
+      __classPrivateFieldGet3(this, _RwLockReadGuard_controller, "f").unlock();
+    }
+  }
+  dispose() {
+    this[Symbol.dispose]();
+  }
+}
+
+class RwLockWriteGuard {
+  constructor(data, controller) {
+    _RwLockWriteGuard_data.set(this, undefined);
+    _RwLockWriteGuard_controller.set(this, undefined);
+    _RwLockWriteGuard_released.set(this, false);
+    __classPrivateFieldSet3(this, _RwLockWriteGuard_data, data, "f");
+    __classPrivateFieldSet3(this, _RwLockWriteGuard_controller, controller, "f");
+  }
+  get [(_RwLockWriteGuard_data = new WeakMap, _RwLockWriteGuard_controller = new WeakMap, _RwLockWriteGuard_released = new WeakMap, INTERNAL_RWLOCK_CONTROLLER)]() {
+    return __classPrivateFieldGet3(this, _RwLockWriteGuard_controller, "f");
+  }
+  get value() {
+    if (__classPrivateFieldGet3(this, _RwLockWriteGuard_released, "f"))
+      throw new Error("Cannot access released lock data");
+    return __classPrivateFieldGet3(this, _RwLockWriteGuard_data, "f");
+  }
+  [Symbol.dispose]() {
+    if (!__classPrivateFieldGet3(this, _RwLockWriteGuard_released, "f")) {
+      __classPrivateFieldSet3(this, _RwLockWriteGuard_released, true, "f");
+      __classPrivateFieldGet3(this, _RwLockWriteGuard_controller, "f").unlock();
+    }
+  }
+  dispose() {
+    this[Symbol.dispose]();
+  }
+}
+
+class RwLock extends Serializable {
+  constructor(data, _stateBuffer) {
+    super();
+    _RwLock_instances.add(this);
+    _RwLock_data.set(this, undefined);
+    _RwLock_lockState.set(this, undefined);
+    _RwLock_readController.set(this, undefined);
+    _RwLock_writeController.set(this, undefined);
+    __classPrivateFieldSet3(this, _RwLock_data, data, "f");
+    __classPrivateFieldSet3(this, _RwLock_lockState, _stateBuffer ? new Int32Array(_stateBuffer) : new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), "f");
+    __classPrivateFieldSet3(this, _RwLock_readController, { unlock: () => __classPrivateFieldGet3(this, _RwLock_instances, "m", _RwLock_unlockRead).call(this) }, "f");
+    __classPrivateFieldSet3(this, _RwLock_writeController, { unlock: () => __classPrivateFieldGet3(this, _RwLock_instances, "m", _RwLock_unlockWrite).call(this) }, "f");
+  }
+  blockingRead() {
+    while (true) {
+      const current2 = Atomics.load(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2);
+      if (current2 === WRITE_LOCKED) {
+        Atomics.wait(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, WRITE_LOCKED);
+        continue;
+      }
+      if (Atomics.compareExchange(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, current2, current2 + READ_ONE) === current2) {
+        return new RwLockReadGuard(__classPrivateFieldGet3(this, _RwLock_data, "f"), __classPrivateFieldGet3(this, _RwLock_readController, "f"));
+      }
+    }
+  }
+  async read() {
+    while (true) {
+      const current2 = Atomics.load(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2);
+      if (current2 === WRITE_LOCKED) {
+        const res2 = Atomics.waitAsync(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, WRITE_LOCKED);
+        if (res2.async) {
+          await res2.value;
+        }
+        continue;
+      }
+      if (Atomics.compareExchange(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, current2, current2 + READ_ONE) === current2) {
+        return new RwLockReadGuard(__classPrivateFieldGet3(this, _RwLock_data, "f"), __classPrivateFieldGet3(this, _RwLock_readController, "f"));
+      }
+    }
+  }
+  blockingWrite() {
+    while (true) {
+      const current2 = Atomics.load(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2);
+      if (current2 !== UNLOCKED2) {
+        Atomics.wait(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, current2);
+        continue;
+      }
+      if (Atomics.compareExchange(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, UNLOCKED2, WRITE_LOCKED) === UNLOCKED2) {
+        return new RwLockWriteGuard(__classPrivateFieldGet3(this, _RwLock_data, "f"), __classPrivateFieldGet3(this, _RwLock_writeController, "f"));
+      }
+    }
+  }
+  async write() {
+    while (true) {
+      const current2 = Atomics.load(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2);
+      if (current2 !== UNLOCKED2) {
+        const res2 = Atomics.waitAsync(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, current2);
+        if (res2.async) {
+          await res2.value;
+        }
+        continue;
+      }
+      if (Atomics.compareExchange(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, UNLOCKED2, WRITE_LOCKED) === UNLOCKED2) {
+        return new RwLockWriteGuard(__classPrivateFieldGet3(this, _RwLock_data, "f"), __classPrivateFieldGet3(this, _RwLock_writeController, "f"));
+      }
+    }
+  }
+  [(_RwLock_data = new WeakMap, _RwLock_lockState = new WeakMap, _RwLock_readController = new WeakMap, _RwLock_writeController = new WeakMap, _RwLock_instances = new WeakSet, _RwLock_unlockRead = function _RwLock_unlockRead() {
+    const prevState = Atomics.sub(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, READ_ONE);
+    if (prevState === READ_ONE) {
+      Atomics.notify(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, 1);
+    }
+  }, _RwLock_unlockWrite = function _RwLock_unlockWrite() {
+    if (Atomics.compareExchange(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, WRITE_LOCKED, UNLOCKED2) !== WRITE_LOCKED) {
+      throw new Error("RwLock was not write-locked or locked by another thread");
+    }
+    Atomics.notify(__classPrivateFieldGet3(this, _RwLock_lockState, "f"), IDX_LOCK_STATE2, Infinity);
+  }, toSerialized)]() {
+    let serializedData;
+    let transfer = [];
+    if (__classPrivateFieldGet3(this, _RwLock_data, "f") !== undefined) {
+      const result = serialize(__classPrivateFieldGet3(this, _RwLock_data, "f"));
+      serializedData = result.value;
+      transfer = result.transfer;
+    }
+    return {
+      value: {
+        stateBuffer: __classPrivateFieldGet3(this, _RwLock_lockState, "f").buffer,
+        data: serializedData
+      },
+      transfer
+    };
+  }
+  static [toDeserialized](obj) {
+    const data = obj.data !== undefined ? deserialize(obj.data) : undefined;
+    return new _a5(data, obj.stateBuffer);
+  }
+}
+_a5 = RwLock;
+(() => {
+  register2(2, _a5);
+})();
+// node_modules/multithreading/src/lib/sync/semaphore.js
+var __classPrivateFieldSet4 = function(receiver, state, value, kind, f2) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet4 = function(receiver, state, kind, f2) {
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f2 : kind === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
+};
+var _SemaphoreGuard_amount;
+var _SemaphoreGuard_controller;
+var _SemaphoreGuard_released;
+var _Semaphore_instances;
+var _a6;
+var _Semaphore_state;
+var _Semaphore_controller;
+var _Semaphore_release;
+var INTERNAL_SEMAPHORE_CONTROLLER = Symbol("Thread.InternalSemaphoreController");
+var IDX_PERMITS = 0;
+var IDX_WAITERS = 1;
+var META_SIZE = 2;
+
+class SemaphoreGuard {
+  constructor(amount, controller) {
+    _SemaphoreGuard_amount.set(this, undefined);
+    _SemaphoreGuard_controller.set(this, undefined);
+    _SemaphoreGuard_released.set(this, false);
+    __classPrivateFieldSet4(this, _SemaphoreGuard_amount, amount, "f");
+    __classPrivateFieldSet4(this, _SemaphoreGuard_controller, controller, "f");
+  }
+  get [(_SemaphoreGuard_amount = new WeakMap, _SemaphoreGuard_controller = new WeakMap, _SemaphoreGuard_released = new WeakMap, INTERNAL_SEMAPHORE_CONTROLLER)]() {
+    return __classPrivateFieldGet4(this, _SemaphoreGuard_controller, "f");
+  }
+  get amount() {
+    return __classPrivateFieldGet4(this, _SemaphoreGuard_amount, "f");
+  }
+  [Symbol.dispose]() {
+    if (!__classPrivateFieldGet4(this, _SemaphoreGuard_released, "f")) {
+      __classPrivateFieldSet4(this, _SemaphoreGuard_released, true, "f");
+      __classPrivateFieldGet4(this, _SemaphoreGuard_controller, "f").release(__classPrivateFieldGet4(this, _SemaphoreGuard_amount, "f"));
+    }
+  }
+  dispose() {
+    this[Symbol.dispose]();
+  }
+}
+
+class Semaphore extends Serializable {
+  constructor(initialCount, _buffer) {
+    super();
+    _Semaphore_instances.add(this);
+    _Semaphore_state.set(this, undefined);
+    _Semaphore_controller.set(this, undefined);
+    if (_buffer) {
+      __classPrivateFieldSet4(this, _Semaphore_state, new Int32Array(_buffer), "f");
+    } else {
+      __classPrivateFieldSet4(this, _Semaphore_state, new Int32Array(new SharedArrayBuffer(META_SIZE * Int32Array.BYTES_PER_ELEMENT)), "f");
+      __classPrivateFieldGet4(this, _Semaphore_state, "f")[IDX_PERMITS] = initialCount;
+      __classPrivateFieldGet4(this, _Semaphore_state, "f")[IDX_WAITERS] = 0;
+    }
+    __classPrivateFieldSet4(this, _Semaphore_controller, {
+      release: (amount) => __classPrivateFieldGet4(this, _Semaphore_instances, "m", _Semaphore_release).call(this, amount)
+    }, "f");
+  }
+  get [(_Semaphore_state = new WeakMap, _Semaphore_controller = new WeakMap, _Semaphore_instances = new WeakSet, INTERNAL_SEMAPHORE_CONTROLLER)]() {
+    return __classPrivateFieldGet4(this, _Semaphore_controller, "f");
+  }
+  tryAcquire(amount = 1) {
+    const current2 = Atomics.load(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS);
+    if (current2 >= amount) {
+      const result = Atomics.compareExchange(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, current2, current2 - amount);
+      if (result === current2) {
+        return new SemaphoreGuard(amount, __classPrivateFieldGet4(this, _Semaphore_controller, "f"));
+      }
+    }
+    return null;
+  }
+  blockingAcquire(amount = 1) {
+    while (true) {
+      const current2 = Atomics.load(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS);
+      if (current2 >= amount) {
+        const result = Atomics.compareExchange(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, current2, current2 - amount);
+        if (result === current2) {
+          return new SemaphoreGuard(amount, __classPrivateFieldGet4(this, _Semaphore_controller, "f"));
+        }
+      } else {
+        Atomics.add(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_WAITERS, 1);
+        Atomics.wait(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, current2);
+        Atomics.sub(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_WAITERS, 1);
+      }
+    }
+  }
+  async acquire(amount = 1) {
+    while (true) {
+      const current2 = Atomics.load(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS);
+      if (current2 >= amount) {
+        const result = Atomics.compareExchange(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, current2, current2 - amount);
+        if (result === current2) {
+          return new SemaphoreGuard(amount, __classPrivateFieldGet4(this, _Semaphore_controller, "f"));
+        }
+      } else {
+        Atomics.add(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_WAITERS, 1);
+        const res2 = Atomics.waitAsync(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, current2);
+        if (res2.async) {
+          await res2.value;
+        }
+        Atomics.sub(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_WAITERS, 1);
+      }
+    }
+  }
+  [(_Semaphore_release = function _Semaphore_release(amount) {
+    Atomics.add(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, amount);
+    if (Atomics.load(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_WAITERS) > 0) {
+      Atomics.notify(__classPrivateFieldGet4(this, _Semaphore_state, "f"), IDX_PERMITS, amount);
+    }
+  }, toSerialized)]() {
+    return {
+      value: __classPrivateFieldGet4(this, _Semaphore_state, "f").buffer,
+      transfer: []
+    };
+  }
+  static [toDeserialized](buffer) {
+    return new _a6(0, buffer);
+  }
+}
+_a6 = Semaphore;
+(() => {
+  register2(3, _a6);
+})();
+// node_modules/multithreading/src/lib/json_buffer.js
+var _a7;
+var CONSOLE_VIEW = Symbol("SharedJsonBuffer.consoleView");
+var OFFSET_FREE_PTR = 0;
+var OFFSET_ROOT = 8;
+var HEADER_SIZE = 16;
+var TYPE_NULL = 0;
+var TYPE_TRUE = 1;
+var TYPE_FALSE = 2;
+var TYPE_NUMBER = 3;
+var TYPE_STRING = 4;
+var TYPE_OBJECT = 5;
+var TYPE_ARRAY = 6;
+var TYPE_MOVED = 4294967295;
+function initConsoleHooks() {
+  if (typeof console === "undefined")
+    return;
+  const methods = [
+    "log",
+    "info",
+    "warn",
+    "error",
+    "dir",
+    "table",
+    "debug",
+    "trace"
+  ];
+  for (const method of methods) {
+    const original = console[method];
+    console[method] = function(...args) {
+      for (let i3 = 0;i3 < args.length; i3++) {
+        const arg = args[i3];
+        if (typeof arg === "object" && typeof arg[CONSOLE_VIEW] === "function") {
+          try {
+            args[i3] = arg[CONSOLE_VIEW]();
+          } catch (e4) {
+            args[i3] = arg;
+          }
+        }
+      }
+      return original.apply(this, args);
+    };
+  }
+}
+
+class SharedJsonBufferImpl extends Serializable {
+  constructor(obj, optionsOrBuffer) {
+    super();
+    this.textDecoder = new TextDecoder;
+    this.textEncoder = new TextEncoder;
+    this.stringCache = new Map;
+    this.proxyCache = new Map;
+    this.propertyHints = new Map;
+    this.activeTargets = new Set;
+    this.tempRoots = [];
+    this.scratchPtr = 0;
+    this.scratchCap = 0;
+    this.scratchLen = 0;
+    this.scratchStart = 0;
+    this.objectHandler = {
+      get: (target, prop, receiver) => {
+        if (typeof prop === "symbol") {
+          if (prop === CONSOLE_VIEW) {
+            return () => this.toConsoleView(target.__ptr);
+          }
+          if (prop === toSerialized)
+            return () => this[toSerialized]();
+          if (prop === Symbol.iterator)
+            return;
+          return Reflect.get(target, prop, receiver);
+        }
+        if (prop === "__ptr")
+          return target.__ptr;
+        if (prop === "toJSON")
+          return () => this.toJSON(target.__ptr);
+        const ptr = target.__ptr;
+        if (ptr === 0)
+          return;
+        const curr = ptr;
+        const type = this.u32[curr >> 2];
+        if (type !== TYPE_MOVED) {
+          this.scratchLen = this.u32[curr + 8 >> 2];
+          this.scratchStart = curr + 12;
+        } else {
+          this.resolvePtr(ptr);
+        }
+        const count = this.scratchLen;
+        const start = this.scratchStart;
+        const hint = this.propertyHints.get(String(prop));
+        if (hint !== undefined && hint < count) {
+          const entryOffset = start + hint * 12;
+          const keyPtr = this.u32[entryOffset >> 2];
+          const keyStr = this.readString(keyPtr);
+          if (keyStr === prop)
+            return this.readSlot(entryOffset + 4);
+        }
+        for (let i3 = 0;i3 < count; i3++) {
+          const entryOffset = start + i3 * 12;
+          const keyPtr = this.u32[entryOffset >> 2];
+          const key = this.readString(keyPtr);
+          if (key === prop) {
+            this.propertyHints.set(String(prop), i3);
+            return this.readSlot(entryOffset + 4);
+          }
+        }
+        return;
+      },
+      has: (target, prop) => {
+        if (typeof prop === "symbol") {
+          if (prop === CONSOLE_VIEW || prop === toSerialized)
+            return true;
+          return Reflect.has(target, prop);
+        }
+        if (prop === "__ptr" || prop === "toJSON")
+          return true;
+        this.resolvePtr(target.__ptr);
+        if (target.__ptr === 0)
+          return false;
+        const propStr = String(prop);
+        const count = this.scratchLen;
+        const start = this.scratchStart;
+        const hint = this.propertyHints.get(propStr);
+        if (hint !== undefined && hint < count) {
+          const entryOffset = start + hint * 12;
+          const keyPtr = this.u32[entryOffset >> 2];
+          const keyStr = this.readString(keyPtr);
+          if (keyStr === propStr)
+            return true;
+        }
+        for (let i3 = 0;i3 < count; i3++) {
+          const entryOffset = start + i3 * 12;
+          const keyPtr = this.u32[entryOffset >> 2];
+          const key = this.readString(keyPtr);
+          if (key === propStr) {
+            this.propertyHints.set(propStr, i3);
+            return true;
+          }
+        }
+        return false;
+      },
+      set: (target, prop, value) => {
+        if (typeof prop === "symbol")
+          return false;
+        this.objectSet(target, String(prop), value);
+        return true;
+      },
+      defineProperty: (target, prop, descriptor) => {
+        if (typeof prop === "symbol")
+          return false;
+        if (descriptor.get || descriptor.set) {
+          throw new Error("SharedJsonBuffer cannot store accessors (get/set)");
+        }
+        if ("value" in descriptor) {
+          this.objectSet(target, String(prop), descriptor.value);
+        }
+        return true;
+      },
+      deleteProperty: (target, prop) => {
+        if (typeof prop === "symbol")
+          return false;
+        return this.objectDelete(target, String(prop));
+      },
+      ownKeys: (target) => {
+        this.resolvePtr(target.__ptr);
+        if (target.__ptr === 0)
+          return [];
+        const keys = [];
+        const start = this.scratchStart;
+        for (let i3 = 0;i3 < this.scratchLen; i3++) {
+          const keyPtr = this.u32[start + i3 * 12 >> 2];
+          const key = this.readString(keyPtr);
+          this.propertyHints.set(key, i3);
+          keys.push(key);
+        }
+        return keys;
+      },
+      getOwnPropertyDescriptor: (target, prop) => {
+        this.resolvePtr(target.__ptr);
+        if (target.__ptr === 0)
+          return;
+        const count = this.scratchLen;
+        const start = this.scratchStart;
+        const propStr = String(prop);
+        const hint = this.propertyHints.get(propStr);
+        if (hint !== undefined && hint < count) {
+          const entryOffset = start + hint * 12;
+          const keyPtr = this.u32[entryOffset >> 2];
+          const keyStr = this.readString(keyPtr);
+          if (keyStr === propStr) {
+            const val = this.readSlot(entryOffset + 4);
+            return {
+              enumerable: true,
+              configurable: true,
+              writable: true,
+              value: val
+            };
+          }
+        }
+        for (let i3 = 0;i3 < count; i3++) {
+          const entryOffset = start + i3 * 12;
+          const keyPtr = this.u32[entryOffset >> 2];
+          const key = this.readString(keyPtr);
+          if (key === propStr) {
+            this.propertyHints.set(propStr, i3);
+            const val = this.readSlot(entryOffset + 4);
+            return {
+              enumerable: true,
+              configurable: true,
+              writable: true,
+              value: val
+            };
+          }
+        }
+        return;
+      }
+    };
+    this.arrayHandler = {
+      get: (target, prop, receiver) => {
+        if (prop === CONSOLE_VIEW)
+          return () => this.toConsoleView(target.__ptr);
+        if (prop === toSerialized)
+          return () => this[toSerialized]();
+        if (prop === "__ptr")
+          return target.__ptr;
+        if (prop === "toJSON")
+          return () => this.toJSON(target.__ptr);
+        if (prop === Symbol.iterator) {
+          return () => new ArrayCursor(this, target.__ptr);
+        }
+        this.resolvePtr(target.__ptr);
+        if (target.__ptr === 0)
+          return;
+        if (prop === "length")
+          return this.scratchLen;
+        if (prop === "push") {
+          return (...args) => {
+            this.arraySpliceImpl(target, this.scratchLen, 0, args);
+            return this.scratchLen;
+          };
+        }
+        if (prop === "pop") {
+          return () => {
+            if (this.scratchLen === 0)
+              return;
+            return this.arraySpliceImpl(target, this.scratchLen - 1, 1)[0];
+          };
+        }
+        if (prop === "shift") {
+          return () => {
+            if (this.scratchLen === 0)
+              return;
+            return this.arraySpliceImpl(target, 0, 1)[0];
+          };
+        }
+        if (prop === "unshift") {
+          return (...args) => {
+            this.arraySpliceImpl(target, 0, 0, args);
+            return this.scratchLen;
+          };
+        }
+        if (prop === "splice") {
+          return (start, deleteCount, ...items) => {
+            const len = this.scratchLen;
+            const actualStart = start < 0 ? len + start : start;
+            const maxDel = len - (actualStart < 0 ? 0 : actualStart);
+            const actualDel = deleteCount === undefined ? maxDel : Math.min(Math.max(deleteCount, 0), maxDel);
+            return this.arraySpliceImpl(target, actualStart, actualDel, items);
+          };
+        }
+        if (prop === "flat") {
+          return (depth = 1) => {
+            const result = [];
+            const flatten = (ptr, currentDepth) => {
+              this.resolvePtr(ptr);
+              const len = this.scratchLen;
+              const start = this.scratchStart;
+              const captureStart = start;
+              for (let i3 = 0;i3 < len; i3++) {
+                const offset = captureStart + i3 * 8;
+                const type = this.u32[offset >> 2];
+                const payload = this.u32[offset + 4 >> 2];
+                if (type === TYPE_ARRAY && currentDepth > 0) {
+                  flatten(payload, currentDepth - 1);
+                } else {
+                  result.push(this.readSlot(offset));
+                }
+              }
+            };
+            flatten(target.__ptr, Math.floor(depth));
+            return result;
+          };
+        }
+        if (prop === "flatMap") {
+          return (callback, thisArg) => {
+            const len = this.scratchLen;
+            const start = this.scratchStart;
+            const result = [];
+            for (let i3 = 0;i3 < len; i3++) {
+              const val = this.readSlot(start + i3 * 8);
+              const mapped = callback.call(thisArg, val, i3, receiver);
+              if (Array.isArray(mapped)) {
+                result.push(...mapped);
+              } else {
+                result.push(mapped);
+              }
+            }
+            return result;
+          };
+        }
+        if (typeof prop === "string" && ["sort", "reverse", "fill", "copyWithin"].includes(prop)) {
+          return (...args) => {
+            const arr = this.toArrayShallow(target.__ptr);
+            arr[prop](...args);
+            arr.forEach((v4, i3) => this.arraySet(target, i3, v4));
+            return receiver;
+          };
+        }
+        if (typeof prop === "string" && prop in Array.prototype) {
+          const nativeMethod = Array.prototype[prop];
+          if (typeof nativeMethod === "function") {
+            return (...args) => {
+              const arr = this.toArrayShallow(target.__ptr);
+              return nativeMethod.apply(arr, args);
+            };
+          }
+        }
+        if (typeof prop === "string") {
+          const idx = Number(prop);
+          if (!isNaN(idx)) {
+            if (idx >= this.scratchLen)
+              return;
+            return this.readSlot(this.scratchStart + idx * 8);
+          }
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set: (target, prop, value) => {
+        if (prop === "length") {
+          const newLen = Number(value);
+          if (!isNaN(newLen) && newLen >= 0) {
+            this.resolvePtr(target.__ptr);
+            const currentLen = this.scratchLen;
+            if (newLen < currentLen) {
+              this.arraySpliceImpl(target, newLen, currentLen - newLen);
+            } else if (newLen > currentLen) {
+              this.arrayEnsureCapacity(target, newLen);
+              this.u32[this.scratchPtr + 8 >> 2] = newLen;
+            }
+            return true;
+          }
+          return false;
+        }
+        const idx = Number(prop);
+        if (!isNaN(idx)) {
+          this.arraySet(target, idx, value);
+          return true;
+        }
+        return false;
+      },
+      ownKeys: (target) => {
+        this.resolvePtr(target.__ptr);
+        const keys = [];
+        for (let i3 = 0;i3 < this.scratchLen; i3++)
+          keys.push(String(i3));
+        keys.push("length");
+        return keys;
+      },
+      getOwnPropertyDescriptor: (target, prop) => {
+        if (prop === "length") {
+          this.resolvePtr(target.__ptr);
+          return {
+            value: this.scratchLen,
+            writable: true,
+            enumerable: false,
+            configurable: false
+          };
+        }
+        const idx = Number(prop);
+        if (!isNaN(idx)) {
+          this.resolvePtr(target.__ptr);
+          if (idx >= 0 && idx < this.scratchLen) {
+            const val = this.readSlot(this.scratchStart + idx * 8);
+            return {
+              value: val,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            };
+          }
+        }
+        return;
+      }
+    };
+    if (optionsOrBuffer instanceof SharedArrayBuffer) {
+      this.buffer = optionsOrBuffer;
+      this.initViews();
+      if (Atomics.load(this.u32, OFFSET_FREE_PTR >> 2) === 0) {
+        this.initializeBuffer(obj);
+      }
+    } else {
+      const size2 = optionsOrBuffer?.size || 1024 * 64;
+      this.buffer = new SharedArrayBuffer(size2);
+      this.initViews();
+      this.initializeBuffer(obj);
+    }
+    return this.getRootProxy();
+  }
+  initViews() {
+    this.u32 = new Uint32Array(this.buffer);
+    this.f64 = new Float64Array(this.buffer);
+    this.u8 = new Uint8Array(this.buffer);
+  }
+  initializeBuffer(obj) {
+    Atomics.store(this.u32, OFFSET_FREE_PTR >> 2, HEADER_SIZE);
+    const isArr = Array.isArray(obj);
+    const initialKeys = isArr ? obj.length : obj ? Object.keys(obj).length : 0;
+    const rootPtr = isArr ? this.allocArray(initialKeys) : this.allocObject(initialKeys);
+    Atomics.store(this.u32, OFFSET_ROOT >> 2, rootPtr);
+    if (obj) {
+      const rootTarget = { __ptr: rootPtr };
+      this.tempRoots.push({
+        handle: rootTarget,
+        type: isArr ? TYPE_ARRAY : TYPE_OBJECT
+      });
+      try {
+        this.writeInitial(rootTarget, obj);
+      } finally {
+        this.tempRoots.pop();
+        Atomics.store(this.u32, OFFSET_ROOT >> 2, rootTarget.__ptr);
+      }
+    }
+  }
+  getRootProxy() {
+    const rootPtr = Atomics.load(this.u32, OFFSET_ROOT >> 2);
+    return this.getProxyForPtr(rootPtr);
+  }
+  alloc(byteSize, retry2 = true) {
+    const idx = OFFSET_FREE_PTR >> 2;
+    const currentPtr = Atomics.load(this.u32, idx);
+    const nextPtr = currentPtr + byteSize;
+    const alignedNext = nextPtr + 7 & ~7;
+    if (alignedNext > this.buffer.byteLength) {
+      if (retry2) {
+        this.collectGarbage();
+        this.propertyHints.clear();
+        return this.alloc(byteSize, false);
+      }
+      throw new Error(`SharedJsonBuffer OOM: Used ${alignedNext} of ${this.buffer.byteLength}`);
+    }
+    Atomics.store(this.u32, idx, alignedNext);
+    return currentPtr;
+  }
+  collectGarbage() {
+    const tempBuffer = new ArrayBuffer(this.buffer.byteLength);
+    const tempU32 = new Uint32Array(tempBuffer);
+    const tempF64 = new Float64Array(tempBuffer);
+    const tempU8 = new Uint8Array(tempBuffer);
+    let freePtr = HEADER_SIZE;
+    const visited = new Map;
+    const allocTemp = (size2) => {
+      const ptr = freePtr;
+      freePtr = freePtr + size2 + 7 & ~7;
+      if (freePtr > tempBuffer.byteLength) {
+        throw new Error("GC Fatal: Fragmentation too high");
+      }
+      return ptr;
+    };
+    const relocate = (oldPtr, type) => {
+      if (oldPtr === 0)
+        return 0;
+      if (type === TYPE_STRING) {
+        if (visited.has(oldPtr))
+          return visited.get(oldPtr);
+        const len = this.u32[oldPtr >> 2];
+        const newPtr2 = allocTemp(4 + len);
+        tempU32[newPtr2 >> 2] = len;
+        tempU8.set(this.u8.subarray(oldPtr + 4, oldPtr + 4 + len), newPtr2 + 4);
+        visited.set(oldPtr, newPtr2);
+        return newPtr2;
+      }
+      if (type === TYPE_NUMBER) {
+        if (visited.has(oldPtr))
+          return visited.get(oldPtr);
+        const newPtr2 = allocTemp(8);
+        tempF64[newPtr2 >> 3] = this.f64[oldPtr >> 3];
+        visited.set(oldPtr, newPtr2);
+        return newPtr2;
+      }
+      this.resolvePtr(oldPtr);
+      const actualOldPtr = this.scratchPtr;
+      if (visited.has(actualOldPtr))
+        return visited.get(actualOldPtr);
+      const actualType = this.u32[actualOldPtr >> 2];
+      let newPtr = 0;
+      if (actualType === TYPE_OBJECT) {
+        const count = this.u32[actualOldPtr + 8 >> 2];
+        const newCap = Math.max(4, count);
+        newPtr = allocTemp(12 + newCap * 12);
+        tempU32[newPtr >> 2] = TYPE_OBJECT;
+        tempU32[newPtr + 4 >> 2] = newCap;
+        tempU32[newPtr + 8 >> 2] = count;
+        const startOffset = actualOldPtr + 12;
+        const newStartOffset = newPtr + 12;
+        for (let i3 = 0;i3 < count; i3++) {
+          const entryOff = startOffset + i3 * 12;
+          const kPtr = this.u32[entryOff >> 2];
+          const vType = this.u32[entryOff + 4 >> 2];
+          const vPayload = this.u32[entryOff + 8 >> 2];
+          const newKeyPtr = relocate(kPtr, TYPE_STRING);
+          let newPayload = vPayload;
+          if (vType === TYPE_OBJECT || vType === TYPE_ARRAY || vType === TYPE_STRING || vType === TYPE_NUMBER) {
+            newPayload = relocate(vPayload, vType);
+          }
+          const destOff = newStartOffset + i3 * 12;
+          tempU32[destOff >> 2] = newKeyPtr;
+          tempU32[destOff + 4 >> 2] = vType;
+          tempU32[destOff + 8 >> 2] = newPayload;
+        }
+      } else if (actualType === TYPE_ARRAY) {
+        const len = this.u32[actualOldPtr + 8 >> 2];
+        const newCap = Math.max(4, len);
+        newPtr = allocTemp(12 + newCap * 8);
+        tempU32[newPtr >> 2] = TYPE_ARRAY;
+        tempU32[newPtr + 4 >> 2] = newCap;
+        tempU32[newPtr + 8 >> 2] = len;
+        const startOffset = actualOldPtr + 12;
+        const newStartOffset = newPtr + 12;
+        for (let i3 = 0;i3 < len; i3++) {
+          const entryOff = startOffset + i3 * 8;
+          const vType = this.u32[entryOff >> 2];
+          const vPayload = this.u32[entryOff + 4 >> 2];
+          let newPayload = vPayload;
+          if (vType === TYPE_OBJECT || vType === TYPE_ARRAY || vType === TYPE_STRING || vType === TYPE_NUMBER) {
+            newPayload = relocate(vPayload, vType);
+          }
+          const destOff = newStartOffset + i3 * 8;
+          tempU32[destOff >> 2] = vType;
+          tempU32[destOff + 4 >> 2] = newPayload;
+        }
+      }
+      visited.set(actualOldPtr, newPtr);
+      return newPtr;
+    };
+    const oldRoot = Atomics.load(this.u32, OFFSET_ROOT >> 2);
+    const newRoot = relocate(oldRoot, TYPE_OBJECT);
+    for (let i3 = 0;i3 < this.tempRoots.length; i3++) {
+      const root = this.tempRoots[i3];
+      relocate(root.handle.__ptr, root.type);
+    }
+    this.u8.set(new Uint8Array(tempBuffer).subarray(0, freePtr), 0);
+    Atomics.store(this.u32, OFFSET_FREE_PTR >> 2, freePtr);
+    Atomics.store(this.u32, OFFSET_ROOT >> 2, newRoot);
+    this.stringCache.clear();
+    this.proxyCache.clear();
+    this.propertyHints.clear();
+    const fixupPointer = (target) => {
+      this.resolvePtr(target.__ptr);
+      const oldP = this.scratchPtr;
+      if (visited.has(oldP)) {
+        target.__ptr = visited.get(oldP);
+      } else {
+        target.__ptr = 0;
+      }
+    };
+    for (const target of this.activeTargets) {
+      fixupPointer(target);
+    }
+    for (const root of this.tempRoots) {
+      fixupPointer(root.handle);
+    }
+  }
+  resolvePtr(ptr) {
+    if (ptr === 0) {
+      this.scratchPtr = 0;
+      this.scratchLen = 0;
+      return;
+    }
+    let curr = ptr;
+    let type = this.u32[curr >> 2];
+    while (type === TYPE_MOVED) {
+      curr = this.u32[curr + 4 >> 2];
+      type = this.u32[curr >> 2];
+    }
+    this.scratchPtr = curr;
+    this.scratchCap = this.u32[curr + 4 >> 2];
+    this.scratchLen = this.u32[curr + 8 >> 2];
+    this.scratchStart = curr + 12;
+  }
+  readString(ptr) {
+    if (this.stringCache.has(ptr)) {
+      return this.stringCache.get(ptr);
+    }
+    const len = this.u32[ptr >> 2];
+    const offset = ptr + 4;
+    if (len < 64) {
+      let res2 = "";
+      for (let i3 = 0;i3 < len; i3++) {
+        res2 += String.fromCharCode(this.u8[offset + i3]);
+      }
+      this.stringCache.set(ptr, res2);
+      return res2;
+    }
+    const str = this.textDecoder.decode(this.u8.subarray(offset, offset + len));
+    this.stringCache.set(ptr, str);
+    return str;
+  }
+  readSlot(offset) {
+    const type = this.u32[offset >> 2];
+    const payload = this.u32[offset + 4 >> 2];
+    if (type === TYPE_NUMBER) {
+      return this.f64[payload >> 3];
+    }
+    switch (type) {
+      case TYPE_STRING:
+        return this.readString(payload);
+      case TYPE_OBJECT:
+      case TYPE_ARRAY:
+        return this.getProxyForPtr(payload);
+      case TYPE_TRUE:
+        return true;
+      case TYPE_FALSE:
+        return false;
+      case TYPE_NULL:
+        return null;
+      default:
+        return;
+    }
+  }
+  writeValue(value) {
+    if (typeof value === "number") {
+      const ptr = this.alloc(8);
+      this.f64[ptr >> 3] = value;
+      return { type: TYPE_NUMBER, payload: ptr };
+    }
+    if (value === null || value === undefined) {
+      return { type: TYPE_NULL, payload: 0 };
+    }
+    if (value === true)
+      return { type: TYPE_TRUE, payload: 0 };
+    if (value === false)
+      return { type: TYPE_FALSE, payload: 0 };
+    if (typeof value === "string") {
+      const encoded = this.textEncoder.encode(value);
+      const len = encoded.byteLength;
+      const ptr = this.alloc(4 + len);
+      this.u32[ptr >> 2] = len;
+      this.u8.set(encoded, ptr + 4);
+      return { type: TYPE_STRING, payload: ptr };
+    }
+    if (Array.isArray(value)) {
+      const ptr = this.allocArray(value.length);
+      const target = { __ptr: ptr };
+      this.tempRoots.push({ handle: target, type: TYPE_ARRAY });
+      try {
+        value.forEach((v4, i3) => this.arraySet(target, i3, v4));
+      } finally {
+        this.tempRoots.pop();
+      }
+      return { type: TYPE_ARRAY, payload: target.__ptr };
+    }
+    if (typeof value === "object") {
+      const keys = Object.keys(value);
+      const ptr = this.allocObject(keys.length);
+      const target = { __ptr: ptr };
+      this.tempRoots.push({ handle: target, type: TYPE_OBJECT });
+      try {
+        Object.entries(value).forEach(([k4, v4]) => this.objectSet(target, k4, v4));
+      } finally {
+        this.tempRoots.pop();
+      }
+      return { type: TYPE_OBJECT, payload: target.__ptr };
+    }
+    throw new Error(`Unsupported type: ${typeof value}`);
+  }
+  allocObject(initialCap) {
+    const capacity2 = Math.max(4, initialCap);
+    const byteSize = 12 + capacity2 * 12;
+    const ptr = this.alloc(byteSize);
+    const idx = ptr >> 2;
+    this.u32[idx] = TYPE_OBJECT;
+    this.u32[idx + 1] = capacity2;
+    this.u32[idx + 2] = 0;
+    return ptr;
+  }
+  allocArray(initialCap) {
+    const capacity2 = Math.max(4, initialCap);
+    const byteSize = 12 + capacity2 * 8;
+    const ptr = this.alloc(byteSize);
+    const idx = ptr >> 2;
+    this.u32[idx] = TYPE_ARRAY;
+    this.u32[idx + 1] = capacity2;
+    this.u32[idx + 2] = 0;
+    return ptr;
+  }
+  writeInitial(target, data) {
+    if (Array.isArray(data)) {
+      data.forEach((v4, i3) => this.arraySet(target, i3, v4));
+    } else {
+      Object.entries(data).forEach(([k4, v4]) => this.objectSet(target, k4, v4));
+    }
+  }
+  getProxyForPtr(ptr) {
+    this.resolvePtr(ptr);
+    const resolvedPtr = this.scratchPtr;
+    if (this.proxyCache.has(resolvedPtr)) {
+      const ref = this.proxyCache.get(resolvedPtr);
+      const cached = ref?.deref();
+      if (cached)
+        return cached;
+    }
+    const type = this.u32[resolvedPtr >> 2];
+    const target = type === TYPE_ARRAY ? [] : {};
+    Object.defineProperty(target, "__ptr", {
+      value: resolvedPtr,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    this.activeTargets.add(target);
+    const proxy = new Proxy(target, type === TYPE_ARRAY ? this.arrayHandler : this.objectHandler);
+    this.proxyCache.set(resolvedPtr, new WeakRef(proxy));
+    return proxy;
+  }
+  toConsoleView(ptr, depth = 0) {
+    this.resolvePtr(ptr);
+    const len = this.scratchLen;
+    const start = this.scratchStart;
+    const type = this.u32[this.scratchPtr >> 2];
+    const result = type === TYPE_ARRAY ? new Array(len) : {};
+    const EAGER_DEPTH = 5;
+    const EAGER_BREADTH = 100;
+    for (let i3 = 0;i3 < len; i3++) {
+      let key;
+      let offset;
+      if (type === TYPE_ARRAY) {
+        key = i3;
+        offset = start + i3 * 8;
+      } else {
+        const entryOffset = start + i3 * 12;
+        const keyPtr = this.u32[entryOffset >> 2];
+        key = this.readString(keyPtr);
+        offset = entryOffset + 4;
+      }
+      const itemType = this.u32[offset >> 2];
+      const itemPayload = this.u32[offset + 4 >> 2];
+      if (itemType === TYPE_OBJECT || itemType === TYPE_ARRAY) {
+        const isEager = depth < EAGER_DEPTH && i3 < EAGER_BREADTH;
+        if (isEager) {
+          result[key] = this.toConsoleView(itemPayload, depth + 1);
+        } else {
+          Object.defineProperty(result, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => {
+              return this.toConsoleView(itemPayload, 0);
+            }
+          });
+        }
+      } else {
+        result[key] = this.readSlot(offset);
+      }
+    }
+    return result;
+  }
+  toJSON(ptr) {
+    this.resolvePtr(ptr);
+    const len = this.scratchLen;
+    const start = this.scratchStart;
+    const type = this.u32[this.scratchPtr >> 2];
+    if (type === TYPE_ARRAY) {
+      const arr = new Array(len);
+      for (let i3 = 0;i3 < len; i3++) {
+        const offset = start + i3 * 8;
+        const itemType = this.u32[offset >> 2];
+        const itemPayload = this.u32[offset + 4 >> 2];
+        if (itemType === TYPE_OBJECT || itemType === TYPE_ARRAY) {
+          arr[i3] = this.toJSON(itemPayload);
+        } else {
+          arr[i3] = this.readSlot(offset);
+        }
+      }
+      return arr;
+    } else {
+      const obj = {};
+      for (let i3 = 0;i3 < len; i3++) {
+        const entryOffset = start + i3 * 12;
+        const keyPtr = this.u32[entryOffset >> 2];
+        const key = this.readString(keyPtr);
+        const itemType = this.u32[entryOffset + 4 >> 2];
+        const itemPayload = this.u32[entryOffset + 8 >> 2];
+        if (itemType === TYPE_OBJECT || itemType === TYPE_ARRAY) {
+          obj[key] = this.toJSON(itemPayload);
+        } else {
+          obj[key] = this.readSlot(entryOffset + 4);
+        }
+      }
+      return obj;
+    }
+  }
+  objectDelete(target, key) {
+    this.resolvePtr(target.__ptr);
+    const ptr = this.scratchPtr;
+    const count = this.scratchLen;
+    const entriesStart = this.scratchStart;
+    let foundIdx = -1;
+    for (let i3 = 0;i3 < count; i3++) {
+      const entryOffset = entriesStart + i3 * 12;
+      const keyPtr = this.u32[entryOffset >> 2];
+      if (this.readString(keyPtr) === key) {
+        foundIdx = i3;
+        break;
+      }
+    }
+    if (foundIdx === -1)
+      return true;
+    const lastIdx = count - 1;
+    if (foundIdx !== lastIdx) {
+      const lastOffset = entriesStart + lastIdx * 12;
+      const foundOffset = entriesStart + foundIdx * 12;
+      this.u32[foundOffset >> 2] = this.u32[lastOffset >> 2];
+      this.u32[foundOffset + 4 >> 2] = this.u32[lastOffset + 4 >> 2];
+      this.u32[foundOffset + 8 >> 2] = this.u32[lastOffset + 8 >> 2];
+    }
+    this.u32[ptr + 8 >> 2] = count - 1;
+    return true;
+  }
+  objectSet(target, key, value) {
+    this.resolvePtr(target.__ptr);
+    const preScanLen = this.scratchLen;
+    const preScanStart = this.scratchStart;
+    for (let i3 = 0;i3 < preScanLen; i3++) {
+      const entryOffset = preScanStart + i3 * 12;
+      const keyPtr = this.u32[entryOffset >> 2];
+      if (this.readString(keyPtr) === key) {
+        this.u32[entryOffset + 4 >> 2] = TYPE_NULL;
+        this.u32[entryOffset + 8 >> 2] = 0;
+        break;
+      }
+    }
+    const valResult = this.writeValue(value);
+    const valHandle = { __ptr: valResult.payload };
+    const isValPtr = valResult.type >= TYPE_NUMBER;
+    if (isValPtr) {
+      this.tempRoots.push({ handle: valHandle, type: valResult.type });
+    }
+    try {
+      this.resolvePtr(target.__ptr);
+      let ptr = this.scratchPtr;
+      const entriesStart = this.scratchStart;
+      const count = this.scratchLen;
+      const cap2 = this.scratchCap;
+      for (let i3 = 0;i3 < count; i3++) {
+        const entryOffset = entriesStart + i3 * 12;
+        const keyPtr = this.u32[entryOffset >> 2];
+        if (this.readString(keyPtr) === key) {
+          this.u32[entryOffset + 4 >> 2] = valResult.type;
+          this.u32[entryOffset + 8 >> 2] = valHandle.__ptr;
+          return;
+        }
+      }
+      const keyResult = this.writeValue(key);
+      const keyHandle = { __ptr: keyResult.payload };
+      this.tempRoots.push({ handle: keyHandle, type: TYPE_STRING });
+      try {
+        this.resolvePtr(target.__ptr);
+        ptr = this.scratchPtr;
+        const currentCap = this.scratchCap;
+        const currentCount = this.scratchLen;
+        if (currentCount >= currentCap) {
+          const newCap = Math.max(currentCap * 2, 4);
+          const newByteSize = 12 + newCap * 12;
+          const newPtr = this.alloc(newByteSize);
+          this.resolvePtr(target.__ptr);
+          const oldDataStart = this.scratchStart;
+          const idx = newPtr >> 2;
+          this.u32[idx] = TYPE_OBJECT;
+          this.u32[idx + 1] = newCap;
+          this.u32[idx + 2] = currentCount + 1;
+          this.u8.set(this.u8.subarray(oldDataStart, oldDataStart + currentCount * 12), newPtr + 12);
+          const entryOffset = newPtr + 12 + currentCount * 12;
+          const eIdx = entryOffset >> 2;
+          this.u32[eIdx] = keyHandle.__ptr;
+          this.u32[eIdx + 1] = valResult.type;
+          this.u32[eIdx + 2] = valHandle.__ptr;
+          const pIdx = this.scratchPtr >> 2;
+          this.u32[pIdx] = TYPE_MOVED;
+          this.u32[pIdx + 1] = newPtr;
+        } else {
+          const entryOffset = this.scratchStart + currentCount * 12;
+          const eIdx = entryOffset >> 2;
+          this.u32[eIdx] = keyHandle.__ptr;
+          this.u32[eIdx + 1] = valResult.type;
+          this.u32[eIdx + 2] = valHandle.__ptr;
+          this.u32[ptr + 8 >> 2] = currentCount + 1;
+        }
+      } finally {
+        this.tempRoots.pop();
+      }
+    } finally {
+      if (isValPtr)
+        this.tempRoots.pop();
+    }
+  }
+  arrayEnsureCapacity(target, minCap) {
+    this.resolvePtr(target.__ptr);
+    if (this.scratchCap >= minCap)
+      return;
+    const oldCap = this.scratchCap;
+    const oldLen = this.scratchLen;
+    const oldDataStart = this.scratchStart;
+    const newCap = Math.max(oldCap * 2, minCap);
+    const newByteSize = 12 + newCap * 8;
+    const newPtr = this.alloc(newByteSize);
+    this.resolvePtr(target.__ptr);
+    const idx = newPtr >> 2;
+    this.u32[idx] = TYPE_ARRAY;
+    this.u32[idx + 1] = newCap;
+    this.u32[idx + 2] = oldLen;
+    this.u8.set(this.u8.subarray(oldDataStart, oldDataStart + oldLen * 8), newPtr + 12);
+    const pIdx = this.scratchPtr >> 2;
+    this.u32[pIdx] = TYPE_MOVED;
+    this.u32[pIdx + 1] = newPtr;
+    this.resolvePtr(target.__ptr);
+  }
+  arraySpliceImpl(target, start, deleteCount, items = []) {
+    this.resolvePtr(target.__ptr);
+    const len = this.scratchLen;
+    const actualStart = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+    const actualDeleteCount = Math.min(Math.max(deleteCount, 0), len - actualStart);
+    const deletedItems = [];
+    for (let i3 = 0;i3 < actualDeleteCount; i3++) {
+      const offset = this.scratchStart + (actualStart + i3) * 8;
+      deletedItems.push(this.readSlot(offset));
+    }
+    const insertCount = items.length;
+    const delta = insertCount - actualDeleteCount;
+    const newLen = len + delta;
+    this.arrayEnsureCapacity(target, newLen);
+    if (delta !== 0) {
+      const tailCount = len - (actualStart + actualDeleteCount);
+      const srcIdx = actualStart + actualDeleteCount;
+      const destIdx = actualStart + insertCount;
+      const srcOffset = this.scratchStart + srcIdx * 8;
+      const destOffset = this.scratchStart + destIdx * 8;
+      const byteLen = tailCount * 8;
+      this.u8.copyWithin(destOffset, srcOffset, srcOffset + byteLen);
+    }
+    for (let i3 = 0;i3 < insertCount; i3++) {
+      const val = items[i3];
+      const valResult = this.writeValue(val);
+      const valHandle = { __ptr: valResult.payload };
+      const isValPtr = valResult.type >= TYPE_NUMBER;
+      if (isValPtr) {
+        this.tempRoots.push({ handle: valHandle, type: valResult.type });
+      }
+      this.resolvePtr(target.__ptr);
+      const offset = this.scratchStart + (actualStart + i3) * 8;
+      const oIdx = offset >> 2;
+      this.u32[oIdx] = valResult.type;
+      this.u32[oIdx + 1] = valHandle.__ptr;
+      if (isValPtr)
+        this.tempRoots.pop();
+    }
+    this.u32[this.scratchPtr + 8 >> 2] = newLen;
+    this.scratchLen = newLen;
+    return deletedItems;
+  }
+  toArrayShallow(ptr) {
+    this.resolvePtr(ptr);
+    const len = this.scratchLen;
+    const start = this.scratchStart;
+    const result = new Array(len);
+    for (let i3 = 0;i3 < len; i3++) {
+      result[i3] = this.readSlot(start + i3 * 8);
+    }
+    return result;
+  }
+  arraySet(target, index, value) {
+    this.resolvePtr(target.__ptr);
+    if (index < this.scratchLen) {
+      const offset = this.scratchStart + index * 8;
+      this.u32[offset >> 2] = TYPE_NULL;
+      this.u32[offset + 4 >> 2] = 0;
+    }
+    const valResult = this.writeValue(value);
+    const valHandle = { __ptr: valResult.payload };
+    const isValPtr = valResult.type >= TYPE_NUMBER;
+    if (isValPtr) {
+      this.tempRoots.push({ handle: valHandle, type: valResult.type });
+    }
+    try {
+      this.resolvePtr(target.__ptr);
+      const ptr = this.scratchPtr;
+      const cap2 = this.scratchCap;
+      const len = this.scratchLen;
+      if (index >= cap2) {
+        const newCap = Math.max(cap2 * 2, index + 1);
+        const newByteSize = 12 + newCap * 8;
+        const newPtr = this.alloc(newByteSize);
+        this.resolvePtr(target.__ptr);
+        const oldDataStart = this.scratchStart;
+        const idx = newPtr >> 2;
+        this.u32[idx] = TYPE_ARRAY;
+        this.u32[idx + 1] = newCap;
+        const newLen = Math.max(len, index + 1);
+        this.u32[idx + 2] = newLen;
+        const oldByteLen = len * 8;
+        this.u8.set(this.u8.subarray(oldDataStart, oldDataStart + oldByteLen), newPtr + 12);
+        const pIdx = this.scratchPtr >> 2;
+        this.u32[pIdx] = TYPE_MOVED;
+        this.u32[pIdx + 1] = newPtr;
+        const offset2 = newPtr + 12 + index * 8;
+        const oIdx2 = offset2 >> 2;
+        this.u32[oIdx2] = valResult.type;
+        this.u32[oIdx2 + 1] = valHandle.__ptr;
+        return;
+      }
+      const offset = ptr + 12 + index * 8;
+      const oIdx = offset >> 2;
+      this.u32[oIdx] = valResult.type;
+      this.u32[oIdx + 1] = valHandle.__ptr;
+      if (index >= len) {
+        this.u32[ptr + 8 >> 2] = index + 1;
+      }
+    } finally {
+      if (isValPtr)
+        this.tempRoots.pop();
+    }
+  }
+  [toSerialized]() {
+    return {
+      value: this.buffer,
+      transfer: [],
+      typeId: 7
+    };
+  }
+  static [toDeserialized](data) {
+    return new _a7(null, data);
+  }
+}
+_a7 = SharedJsonBufferImpl;
+(() => {
+  initConsoleHooks();
+  register2(7, _a7);
+})();
+
+class ArrayCursor {
+  constructor(buffer, ptr) {
+    this.buffer = buffer;
+    this.index = 0;
+    this.target = { __ptr: 0 };
+    buffer.resolvePtr(ptr);
+    this.len = buffer.scratchLen;
+    this.start = buffer.scratchStart;
+    const type = buffer.u32[buffer.scratchPtr >> 2];
+    if (type !== TYPE_ARRAY) {
+      throw new Error("Iterator must be used on an Array");
+    }
+    this.flyweightProxy = new Proxy(this.target, buffer.objectHandler);
+    this.result = { done: false, value: this.flyweightProxy };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    if (this.index >= this.len) {
+      this.result.done = true;
+      this.result.value = undefined;
+      return this.result;
+    }
+    const offset = this.start + this.index * 8;
+    const itemType = this.buffer.u32[offset >> 2];
+    const itemPayload = this.buffer.u32[offset + 4 >> 2];
+    this.index++;
+    if (itemType === TYPE_OBJECT || itemType === TYPE_ARRAY) {
+      this.target.__ptr = itemPayload;
+      return this.result;
+    }
+    this.result.value = this.buffer.readSlot(offset);
+    return this.result;
+  }
+}
+
+// node_modules/multithreading/src/lib/sync/mpmc.js
+var __addDisposableResource = function(env3, value, async) {
+  if (value !== null && value !== undefined) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose)
+        throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === undefined) {
+      if (!Symbol.dispose)
+        throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async)
+        inner = dispose;
+    }
+    if (typeof dispose !== "function")
+      throw new TypeError("Object not disposable.");
+    if (inner)
+      dispose = function() {
+        try {
+          inner.call(this);
+        } catch (e4) {
+          return Promise.reject(e4);
+        }
+      };
+    env3.stack.push({ value, dispose, async });
+  } else if (async) {
+    env3.stack.push({ async: true });
+  }
+  return value;
+};
+var __disposeResources = function(SuppressedError2) {
+  return function(env3) {
+    function fail(e4) {
+      env3.error = env3.hasError ? new SuppressedError2(e4, env3.error, "An error was suppressed during disposal.") : e4;
+      env3.hasError = true;
+    }
+    var r4, s4 = 0;
+    function next() {
+      while (r4 = env3.stack.pop()) {
+        try {
+          if (!r4.async && s4 === 1)
+            return s4 = 0, env3.stack.push(r4), Promise.resolve().then(next);
+          if (r4.dispose) {
+            var result = r4.dispose.call(r4.value);
+            if (r4.async)
+              return s4 |= 2, Promise.resolve(result).then(next, function(e4) {
+                fail(e4);
+                return next();
+              });
+          } else
+            s4 |= 1;
+        } catch (e4) {
+          fail(e4);
+        }
+      }
+      if (s4 === 1)
+        return env3.hasError ? Promise.reject(env3.error) : Promise.resolve();
+      if (env3.hasError)
+        throw env3.error;
+    }
+    return next();
+  };
+}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e4 = new Error(message);
+  return e4.name = "SuppressedError", e4.error = error, e4.suppressed = suppressed, e4;
+});
+var _a8;
+var _b2;
+var _c2;
+var IDX_HEAD = 0;
+var IDX_TAIL = 1;
+var IDX_CLOSED = 2;
+var IDX_CAP = 3;
+var IDX_TX_COUNT = 4;
+var IDX_RX_COUNT = 5;
+var CLOSED = 1;
+var ERR_DISPOSED_SENDER = new Error("Sender is disposed");
+var ERR_DISPOSED_RECEIVER = new Error("Receiver disposed");
+var ERR_CLOSED = new Error("Channel closed");
+var ERR_CLOSED_NO_RX = new Error("Channel closed (No Receivers)");
+var ERR_SPURIOUS = new Error("Spurious wakeup or illegal null value");
+
+class ChannelInternals extends Serializable {
+  constructor(state, items, sendLock, recvLock, itemsAvailable, slotsAvailable) {
+    super();
+    this.state = state;
+    this.items = items;
+    this.sendLock = sendLock;
+    this.recvLock = recvLock;
+    this.itemsAvailable = itemsAvailable;
+    this.slotsAvailable = slotsAvailable;
+  }
+  write(value) {
+    const tail = this.state[IDX_TAIL];
+    this.items[tail] = value;
+    this.state[IDX_TAIL] = (tail + 1) % this.state[IDX_CAP];
+  }
+  read() {
+    const head = this.state[IDX_HEAD];
+    const val = this.items[head];
+    if (val === null)
+      return null;
+    this.items[head] = null;
+    this.state[IDX_HEAD] = (head + 1) % this.state[IDX_CAP];
+    return val;
+  }
+  isClosed() {
+    return Atomics.load(this.state, IDX_CLOSED) === CLOSED;
+  }
+  hasReceivers() {
+    return Atomics.load(this.state, IDX_RX_COUNT) > 0;
+  }
+  [toSerialized]() {
+    const itemsSer = serialize(this.items);
+    const sendLockSer = serialize(this.sendLock);
+    const recvLockSer = serialize(this.recvLock);
+    const itemsAvailSer = serialize(this.itemsAvailable);
+    const slotsAvailSer = serialize(this.slotsAvailable);
+    return {
+      value: {
+        state: this.state.buffer,
+        items: itemsSer.value,
+        sendLock: sendLockSer.value,
+        recvLock: recvLockSer.value,
+        itemsAvailable: itemsAvailSer.value,
+        slotsAvailable: slotsAvailSer.value
+      },
+      transfer: [
+        ...itemsSer.transfer,
+        ...sendLockSer.transfer,
+        ...recvLockSer.transfer,
+        ...itemsAvailSer.transfer,
+        ...slotsAvailSer.transfer
+      ]
+    };
+  }
+  static [toDeserialized](data) {
+    return new _a8(new Int32Array(data.state), deserialize(data.items), deserialize(data.sendLock), deserialize(data.recvLock), deserialize(data.itemsAvailable), deserialize(data.slotsAvailable));
+  }
+}
+_a8 = ChannelInternals;
+(() => {
+  register2(4, _a8);
+})();
+
+class ChannelHandle extends Serializable {
+  constructor(internals) {
+    super();
+    this.internals = internals;
+    this.disposed = false;
+  }
+  checkDisposed() {
+    return this.disposed ? { ok: false, error: this.disposeError } : null;
+  }
+  [toSerialized]() {
+    if (this.disposed)
+      throw new Error("Cannot move a disposed Handle");
+    this.disposed = true;
+    return serialize(this.internals);
+  }
+}
+
+class Sender extends ChannelHandle {
+  get disposeError() {
+    return ERR_DISPOSED_SENDER;
+  }
+  clone() {
+    if (this.disposed)
+      throw new Error("Cannot clone disposed Sender");
+    Atomics.add(this.internals.state, IDX_TX_COUNT, 1);
+    return new _b2(this.internals);
+  }
+  async send(value) {
+    const disposedCheck = this.checkDisposed();
+    if (disposedCheck)
+      return disposedCheck;
+    if (!this.internals.hasReceivers()) {
+      return { ok: false, error: ERR_CLOSED_NO_RX };
+    }
+    const slotToken = await this.internals.slotsAvailable.acquire();
+    if (this.internals.isClosed()) {
+      slotToken[Symbol.dispose]();
+      return { ok: false, error: ERR_CLOSED };
+    }
+    try {
+      const env_1 = { stack: [], error: undefined, hasError: false };
+      try {
+        const _lockGuard = __addDisposableResource(env_1, await this.internals.sendLock.acquire(), false);
+        if (this.internals.isClosed()) {
+          slotToken[Symbol.dispose]();
+          return { ok: false, error: ERR_CLOSED };
+        }
+        this.internals.write(value);
+      } catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+      } finally {
+        __disposeResources(env_1);
+      }
+    } catch (err) {
+      slotToken[Symbol.dispose]();
+      throw err;
+    }
+    this.internals.itemsAvailable[INTERNAL_SEMAPHORE_CONTROLLER].release(1);
+    return { ok: true, value: undefined };
+  }
+  blockingSend(value) {
+    const disposedCheck = this.checkDisposed();
+    if (disposedCheck)
+      return disposedCheck;
+    if (!this.internals.hasReceivers()) {
+      return { ok: false, error: ERR_CLOSED_NO_RX };
+    }
+    const slotToken = this.internals.slotsAvailable.blockingAcquire();
+    if (this.internals.isClosed()) {
+      slotToken[Symbol.dispose]();
+      return { ok: false, error: ERR_CLOSED };
+    }
+    try {
+      const lockToken = this.internals.sendLock.blockingAcquire();
+      try {
+        if (this.internals.isClosed()) {
+          slotToken[Symbol.dispose]();
+          return { ok: false, error: ERR_CLOSED };
+        }
+        this.internals.write(value);
+      } finally {
+        lockToken[Symbol.dispose]();
+      }
+      this.internals.itemsAvailable[INTERNAL_SEMAPHORE_CONTROLLER].release(1);
+      return { ok: true, value: undefined };
+    } catch (err) {
+      slotToken[Symbol.dispose]();
+      throw err;
+    }
+  }
+  close() {
+    if (this.disposed || this.internals.isClosed())
+      return;
+    const { state, slotsAvailable, itemsAvailable, sendLock, recvLock } = this.internals;
+    const g12 = sendLock.blockingAcquire();
+    const g22 = recvLock.blockingAcquire();
+    try {
+      if (this.internals.isClosed())
+        return;
+      Atomics.store(state, IDX_CLOSED, CLOSED);
+      slotsAvailable[INTERNAL_SEMAPHORE_CONTROLLER].release(1073741823);
+      itemsAvailable[INTERNAL_SEMAPHORE_CONTROLLER].release(1073741823);
+    } finally {
+      g12[Symbol.dispose]();
+      g22[Symbol.dispose]();
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.disposed)
+      return;
+    const prevCount = Atomics.sub(this.internals.state, IDX_TX_COUNT, 1);
+    if (prevCount === 1)
+      this.close();
+    this.disposed = true;
+  }
+  static [toDeserialized](obj) {
+    return new _b2(deserialize(obj));
+  }
+}
+_b2 = Sender;
+(() => {
+  register2(5, _b2);
+})();
+
+class Receiver extends ChannelHandle {
+  get disposeError() {
+    return ERR_DISPOSED_RECEIVER;
+  }
+  clone() {
+    if (this.disposed)
+      throw new Error("Cannot clone disposed Receiver");
+    Atomics.add(this.internals.state, IDX_RX_COUNT, 1);
+    return new _c2(this.internals);
+  }
+  async recv() {
+    const disposedCheck = this.checkDisposed();
+    if (disposedCheck)
+      return disposedCheck;
+    const itemToken = await this.internals.itemsAvailable.acquire();
+    let val;
+    try {
+      const env_2 = { stack: [], error: undefined, hasError: false };
+      try {
+        const _lockGuard = __addDisposableResource(env_2, await this.internals.recvLock.acquire(), false);
+        val = this.internals.read();
+      } catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+      } finally {
+        __disposeResources(env_2);
+      }
+    } catch (err) {
+      itemToken[Symbol.dispose]();
+      throw err;
+    }
+    if (val === null) {
+      itemToken[Symbol.dispose]();
+      return this.internals.isClosed() ? { ok: false, error: ERR_CLOSED } : { ok: false, error: ERR_SPURIOUS };
+    }
+    this.internals.slotsAvailable[INTERNAL_SEMAPHORE_CONTROLLER].release(1);
+    return { ok: true, value: val };
+  }
+  blockingRecv() {
+    const disposedCheck = this.checkDisposed();
+    if (disposedCheck)
+      return disposedCheck;
+    const itemToken = this.internals.itemsAvailable.blockingAcquire();
+    let val;
+    try {
+      const lockToken = this.internals.recvLock.blockingAcquire();
+      try {
+        val = this.internals.read();
+      } finally {
+        lockToken[Symbol.dispose]();
+      }
+    } catch (err) {
+      itemToken[Symbol.dispose]();
+      throw err;
+    }
+    if (val === null) {
+      itemToken[Symbol.dispose]();
+      return this.internals.isClosed() ? { ok: false, error: ERR_CLOSED } : { ok: false, error: ERR_SPURIOUS };
+    }
+    this.internals.slotsAvailable[INTERNAL_SEMAPHORE_CONTROLLER].release(1);
+    return { ok: true, value: val };
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const result = await this.recv();
+      if (result.ok) {
+        yield result.value;
+      } else {
+        const msg = result.error.message;
+        if (msg === ERR_CLOSED.message || msg === ERR_DISPOSED_RECEIVER.message) {
+          return;
+        }
+        throw result.error;
+      }
+    }
+  }
+  close() {
+    const sender = new Sender(this.internals);
+    sender.close();
+  }
+  [Symbol.dispose]() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    const prevCount = Atomics.sub(this.internals.state, IDX_RX_COUNT, 1);
+    if (prevCount === 1)
+      this.close();
+  }
+  static [toDeserialized](obj) {
+    return new _c2(deserialize(obj));
+  }
+}
+_c2 = Receiver;
+(() => {
+  register2(6, _c2);
+})();
+// node_modules/multithreading/src/lib/sync/barrier.js
+var __classPrivateFieldSet5 = function(receiver, state, value, kind, f2) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet5 = function(receiver, state, kind, f2) {
+  if (kind === "a" && !f2)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f2 : kind === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
+};
+var _Barrier_instances;
+var _a9;
+var _Barrier_state;
+var _Barrier_lock;
+var _Barrier_unlock;
+var _Barrier_lockAsync;
+var IDX_LOCK = 0;
+var IDX_CAP2 = 1;
+var IDX_COUNT = 2;
+var IDX_GEN = 3;
+var META_SIZE2 = 4;
+var LOCK_UNLOCKED = 0;
+var LOCK_LOCKED = 1;
+
+class Barrier extends Serializable {
+  constructor(n3, _buffer) {
+    super();
+    _Barrier_instances.add(this);
+    _Barrier_state.set(this, undefined);
+    if (_buffer) {
+      __classPrivateFieldSet5(this, _Barrier_state, new Int32Array(_buffer), "f");
+    } else {
+      if (n3 === undefined) {
+        throw new Error("Barrier capacity must be provided");
+      }
+      __classPrivateFieldSet5(this, _Barrier_state, new Int32Array(new SharedArrayBuffer(META_SIZE2 * Int32Array.BYTES_PER_ELEMENT)), "f");
+      __classPrivateFieldGet5(this, _Barrier_state, "f")[IDX_LOCK] = LOCK_UNLOCKED;
+      __classPrivateFieldGet5(this, _Barrier_state, "f")[IDX_CAP2] = n3;
+      __classPrivateFieldGet5(this, _Barrier_state, "f")[IDX_COUNT] = n3;
+      __classPrivateFieldGet5(this, _Barrier_state, "f")[IDX_GEN] = 0;
+    }
+  }
+  blockingWait() {
+    __classPrivateFieldGet5(this, _Barrier_instances, "m", _Barrier_lock).call(this);
+    const localGen = Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN);
+    const count = Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_COUNT) - 1;
+    if (count === 0) {
+      Atomics.store(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_COUNT, Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_CAP2));
+      Atomics.add(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN, 1);
+      __classPrivateFieldGet5(this, _Barrier_instances, "m", _Barrier_unlock).call(this);
+      Atomics.notify(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN, Infinity);
+      return { isLeader: true };
+    } else {
+      Atomics.store(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_COUNT, count);
+      __classPrivateFieldGet5(this, _Barrier_instances, "m", _Barrier_unlock).call(this);
+      while (Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN) === localGen) {
+        Atomics.wait(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN, localGen);
+      }
+      return { isLeader: false };
+    }
+  }
+  async wait() {
+    await __classPrivateFieldGet5(this, _Barrier_instances, "m", _Barrier_lockAsync).call(this);
+    const localGen = Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN);
+    const count = Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_COUNT) - 1;
+    if (count === 0) {
+      Atomics.store(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_COUNT, Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_CAP2));
+      Atomics.add(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN, 1);
+      __classPrivateFieldGet5(this, _Barrier_instances, "m", _Barrier_unlock).call(this);
+      Atomics.notify(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN, Infinity);
+      return { isLeader: true };
+    } else {
+      Atomics.store(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_COUNT, count);
+      __classPrivateFieldGet5(this, _Barrier_instances, "m", _Barrier_unlock).call(this);
+      while (Atomics.load(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN) === localGen) {
+        const res2 = Atomics.waitAsync(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_GEN, localGen);
+        if (res2.async) {
+          await res2.value;
+        }
+      }
+      return { isLeader: false };
+    }
+  }
+  [(_Barrier_state = new WeakMap, _Barrier_instances = new WeakSet, _Barrier_lock = function _Barrier_lock() {
+    while (Atomics.compareExchange(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_LOCK, LOCK_UNLOCKED, LOCK_LOCKED) !== LOCK_UNLOCKED) {
+      Atomics.wait(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_LOCK, LOCK_LOCKED);
+    }
+  }, _Barrier_unlock = function _Barrier_unlock() {
+    if (Atomics.compareExchange(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_LOCK, LOCK_LOCKED, LOCK_UNLOCKED) !== LOCK_LOCKED) {
+      throw new Error("Barrier lock state corrupted");
+    }
+    Atomics.notify(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_LOCK, 1);
+  }, _Barrier_lockAsync = async function _Barrier_lockAsync() {
+    while (Atomics.compareExchange(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_LOCK, LOCK_UNLOCKED, LOCK_LOCKED) !== LOCK_UNLOCKED) {
+      const res2 = Atomics.waitAsync(__classPrivateFieldGet5(this, _Barrier_state, "f"), IDX_LOCK, LOCK_LOCKED);
+      if (res2.async) {
+        await res2.value;
+      }
+    }
+  }, toSerialized)]() {
+    return {
+      value: __classPrivateFieldGet5(this, _Barrier_state, "f").buffer,
+      transfer: []
+    };
+  }
+  static [toDeserialized](buffer) {
+    return new _a9(undefined, buffer);
+  }
+}
+_a9 = Barrier;
+(() => {
+  register2(8, _a9);
+})();
+// node_modules/multithreading/src/lib/lib.js
+var globalPool = null;
+var globalConfig = { maxWorkers: navigator.hardwareConcurrency || 4 };
+var globalFunctionRegistry = new WeakMap;
+function getPool() {
+  if (!globalPool) {
+    globalPool = new WorkerPool(globalConfig.maxWorkers);
+  }
+  return globalPool;
+}
+var moveTag = Symbol("Thread.move");
+function move(...args) {
+  checkMoveArgs(args);
+  return Object.defineProperty(args, moveTag, {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: true
+  });
+}
+function spawn(arg1, arg2) {
+  const pool = getPool();
+  const { resolve: resolve12, reject, promise } = Promise.withResolvers();
+  let args = [];
+  let fn3;
+  if (arg1 && Object.prototype.hasOwnProperty.call(arg1, moveTag)) {
+    args = arg1;
+    fn3 = arg2;
+  } else {
+    fn3 = arg1;
+  }
+  let meta = globalFunctionRegistry.get(fn3);
+  if (!meta) {
+    const id = Math.random().toString(36).slice(2);
+    const callerLocation = getCallerLocation();
+    try {
+      const code = patchDynamicImports("export default " + fn3.toString(), callerLocation.filePath);
+      meta = { id, code };
+      globalFunctionRegistry.set(fn3, meta);
+    } catch (err) {
+      console.error(err);
+      return {
+        join: () => Promise.resolve({
+          ok: false,
+          error: err instanceof Error ? err : new Error("Failed to compile function")
+        }),
+        abort: () => {}
+      };
+    }
+  }
+  (async () => {
+    try {
+      const task = {
+        fnId: meta.id,
+        code: meta.code,
+        args
+      };
+      const val = await pool.submit(task);
+      resolve12({ ok: true, value: val });
+    } catch (err) {
+      resolve12({ ok: false, error: err });
+    }
+  })();
+  return {
+    join: () => promise,
+    abort: () => reject(new Error("Task aborted"))
+  };
+}
+var isWorker = typeof globalThis.WorkerGlobalScope !== "undefined" && self instanceof globalThis.WorkerGlobalScope;
+
+// node_modules/multithreading/src/node/lib.js
+workerOverride(() => new Worker(new URL("./worker.js", import.meta.url), { type: "module" }));
+
 // cli/build/register.ts
 var normalizeRelativePath = (projectDir, targetPath) => path47.relative(projectDir, targetPath).split(path47.sep).join("/");
 var registerBuild = (program3) => {
-  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ci", "Run install and optional prebuild/build commands (or default CI build)").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").option("--kicad", "Generate KiCad project directories for each successful build output").option("--preview-gltf", "Generate a GLTF file from the preview entrypoint").option("--kicad-pcm", "Generate KiCad PCM (Plugin and Content Manager) assets in dist/pcm").option("--use-cdn-javascript", "Use CDN-hosted JavaScript instead of bundled standalone file for --site").action(async (file, options) => {
+  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ci", "Run install and optional prebuild/build commands (or default CI build)").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").option("--kicad", "Generate KiCad project directories for each successful build output").option("--preview-gltf", "Generate a GLTF file from the preview entrypoint").option("--kicad-pcm", "Generate KiCad PCM (Plugin and Content Manager) assets in dist/pcm").option("--use-cdn-javascript", "Use CDN-hosted JavaScript instead of bundled standalone file for --site").option("--concurrency <number>", "Number of files to build in parallel (default: 1)", "1").action(async (file, options) => {
     try {
       const {
         projectDir,
@@ -173715,22 +176445,25 @@ var registerBuild = (program3) => {
       })();
       const distDir = path47.join(projectDir, "dist");
       fs47.mkdirSync(distDir, { recursive: true });
-      console.log(`Building ${circuitFiles.length} file(s)...`);
+      const concurrencyValue = Math.max(1, Number.parseInt(resolvedOptions?.concurrency || "1", 10));
+      if (concurrencyValue > 1) {
+        console.log(`Building ${circuitFiles.length} file(s) with concurrency ${concurrencyValue}...`);
+      } else {
+        console.log(`Building ${circuitFiles.length} file(s)...`);
+      }
       let hasErrors = false;
       const staticFileReferences = [];
       const builtFiles = [];
       const kicadProjects = [];
       const shouldGenerateKicad = resolvedOptions?.kicad || resolvedOptions?.kicadFootprintLibrary;
-      for (const filePath of circuitFiles) {
+      const buildOptions = {
+        ignoreErrors: resolvedOptions?.ignoreErrors,
+        ignoreWarnings: resolvedOptions?.ignoreWarnings,
+        platformConfig: platformConfig2
+      };
+      const processBuildResult = async (filePath, outputPath, buildOutcome) => {
         const relative10 = path47.relative(projectDir, filePath);
-        console.log(`Building ${relative10}...`);
         const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-        const outputPath = path47.join(distDir, outputDirName, "circuit.json");
-        const buildOutcome = await buildFile(filePath, outputPath, projectDir, {
-          ignoreErrors: resolvedOptions?.ignoreErrors,
-          ignoreWarnings: resolvedOptions?.ignoreWarnings,
-          platformConfig: platformConfig2
-        });
         builtFiles.push({
           sourcePath: filePath,
           outputPath,
@@ -173761,6 +176494,77 @@ var registerBuild = (program3) => {
             sourcePath: filePath
           });
         }
+      };
+      const buildSequentially = async () => {
+        for (const filePath of circuitFiles) {
+          const relative10 = path47.relative(projectDir, filePath);
+          console.log(`Building ${relative10}...`);
+          const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
+          const outputPath = path47.join(distDir, outputDirName, "circuit.json");
+          const buildOutcome = await buildFile(filePath, outputPath, projectDir, buildOptions);
+          await processBuildResult(filePath, outputPath, buildOutcome);
+        }
+      };
+      const buildWithMultithreading = async () => {
+        const buildTasks = circuitFiles.map((filePath) => {
+          const relative10 = path47.relative(projectDir, filePath);
+          const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
+          const outputPath = path47.join(distDir, outputDirName, "circuit.json");
+          return {
+            filePath,
+            outputPath,
+            projectDir,
+            options: buildOptions
+          };
+        });
+        const handles = buildTasks.map((task) => spawn(move(task), async (i3) => {
+          const { registerStaticAssetLoaders: registerStaticAssetLoaders2 } = await Promise.resolve().then(() => (init_register_static_asset_loaders(), exports_register_static_asset_loaders));
+          registerStaticAssetLoaders2();
+          const { buildFile: b3 } = await Promise.resolve().then(() => (init_build_file(), exports_build_file));
+          const r4 = await b3(i3.filePath, i3.outputPath, i3.projectDir, i3.options);
+          return {
+            filePath: i3.filePath,
+            outputPath: i3.outputPath,
+            ok: r4.ok,
+            circuitJson: r4.circuitJson,
+            logs: [],
+            errors: []
+          };
+        }));
+        const results = await Promise.all(handles.map((h3) => h3.join()));
+        for (let i3 = 0;i3 < results.length; i3++) {
+          const result = results[i3];
+          const task = buildTasks[i3];
+          const relative10 = path47.relative(projectDir, task.filePath);
+          if (!result.ok) {
+            console.error(kleur_default.red(`Failed to build ${relative10}: ${result.error}`));
+            await processBuildResult(task.filePath, task.outputPath, {
+              ok: false
+            });
+            continue;
+          }
+          const buildResult = result.value;
+          console.log(`[${relative10}]`);
+          if (buildResult.logs.length > 0) {
+            for (const log of buildResult.logs) {
+              console.log(`  ${log}`);
+            }
+          }
+          if (buildResult.errors.length > 0) {
+            for (const err of buildResult.errors) {
+              console.error(kleur_default.red(`  ${err}`));
+            }
+          }
+          await processBuildResult(task.filePath, task.outputPath, {
+            ok: buildResult.ok,
+            circuitJson: buildResult.circuitJson
+          });
+        }
+      };
+      if (concurrencyValue > 1) {
+        await buildWithMultithreading();
+      } else {
+        await buildSequentially();
       }
       if (hasErrors && !resolvedOptions?.ignoreErrors) {
         process.exit(1);
@@ -173909,6 +176713,9 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
+init_kleur();
+init_generate_circuit_json();
+init_get_complete_platform_config();
 import fs49 from "node:fs";
 import path48 from "node:path";
 import looksSame2 from "looks-same";
@@ -174221,6 +177028,7 @@ var registerSetup = (program3) => {
 };
 
 // cli/auth/setup-npmrc/register.ts
+init_kleur();
 function registerAuthSetupNpmrc(program3) {
   program3.commands.find((c3) => c3.name() === "auth").command("setup-npmrc").description("Configure your global .npmrc file with authentication for tscircuit private packages").action(async () => {
     const sessionToken = getSessionToken();
@@ -174233,6 +177041,7 @@ function registerAuthSetupNpmrc(program3) {
 }
 
 // cli/convert/register.ts
+init_kleur();
 import fs51 from "node:fs/promises";
 import path50 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
@@ -174372,6 +177181,9 @@ var registerConvert = (program3) => {
   });
 };
 
+// cli/simulate/register.ts
+init_generate_circuit_json();
+
 // lib/shared/result-to-table.ts
 var formatNumber = (n3) => {
   return n3.toExponential(6);
@@ -174514,37 +177326,8 @@ var registerTranspile = (program3) => {
   });
 };
 
-// lib/shared/register-static-asset-loaders.ts
-var TEXT_STATIC_ASSET_EXTENSIONS = [
-  ".gltf",
-  ".step",
-  ".kicad_mod",
-  ".kicad_pcb",
-  ".kicad_pro",
-  ".kicad_sch"
-];
-var staticAssetFilter = new RegExp(`(${TEXT_STATIC_ASSET_EXTENSIONS.map((ext) => ext.replace(".", "\\.")).join("|")})$`, "i");
-var registered = false;
-var registerStaticAssetLoaders = () => {
-  if (registered)
-    return;
-  registered = true;
-  if (typeof Bun !== "undefined" && typeof Bun.plugin === "function") {
-    Bun.plugin({
-      name: "tsci-static-assets",
-      setup(build) {
-        build.onLoad({ filter: staticAssetFilter }, (args) => {
-          return {
-            contents: `export default ${JSON.stringify(args.path)};`,
-            loader: "js"
-          };
-        });
-      }
-    });
-  }
-};
-
 // cli/main.ts
+init_register_static_asset_loaders();
 var program2 = new Command;
 program2.name("tsci").description("CLI for developing tscircuit packages");
 registerStaticAssetLoaders();