@tscircuit/cli 0.1.2401 → 0.1.2403

package/dist/cli/build/build.worker.js

@@ -96,7 +96,7 @@ var require_dist = __commonJS(function(exports, module) {
     "node_modules/fs.realpath/old.js"(exports2) {
       var pathModule = __require("path");
       var isWindows = process.platform === "win32";
-      var fs2 = __require("fs");
+      var fs3 = __require("fs");
       var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
       function rethrow() {
         var callback;
@@ -161,7 +161,7 @@ var require_dist = __commonJS(function(exports, module) {
           base = m[0];
           previous = "";
           if (isWindows && !knownHard[base]) {
-            fs2.lstatSync(base);
+            fs3.lstatSync(base);
             knownHard[base] = true;
           }
         }
@@ -179,7 +179,7 @@ var require_dist = __commonJS(function(exports, module) {
           if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
             resolvedLink = cache[base];
           } else {
-            var stat = fs2.lstatSync(base);
+            var stat = fs3.lstatSync(base);
             if (!stat.isSymbolicLink()) {
               knownHard[base] = true;
               if (cache)
@@ -194,8 +194,8 @@ var require_dist = __commonJS(function(exports, module) {
               }
             }
             if (linkTarget === null) {
-              fs2.statSync(base);
-              linkTarget = fs2.readlinkSync(base);
+              fs3.statSync(base);
+              linkTarget = fs3.readlinkSync(base);
             }
             resolvedLink = pathModule.resolve(previous, linkTarget);
             if (cache)
@@ -232,7 +232,7 @@ var require_dist = __commonJS(function(exports, module) {
           base = m[0];
           previous = "";
           if (isWindows && !knownHard[base]) {
-            fs2.lstat(base, function(err) {
+            fs3.lstat(base, function(err) {
               if (err)
                 return cb(err);
               knownHard[base] = true;
@@ -260,7 +260,7 @@ var require_dist = __commonJS(function(exports, module) {
           if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
             return gotResolvedLink(cache[base]);
           }
-          return fs2.lstat(base, gotStat);
+          return fs3.lstat(base, gotStat);
         }
         function gotStat(err, stat) {
           if (err)
@@ -277,10 +277,10 @@ var require_dist = __commonJS(function(exports, module) {
               return gotTarget(null, seenLinks[id], base);
             }
           }
-          fs2.stat(base, function(err2) {
+          fs3.stat(base, function(err2) {
             if (err2)
               return cb(err2);
-            fs2.readlink(base, function(err3, target) {
+            fs3.readlink(base, function(err3, target) {
               if (!isWindows)
                 seenLinks[id] = target;
               gotTarget(err3, target);
@@ -310,9 +310,9 @@ var require_dist = __commonJS(function(exports, module) {
       realpath.realpathSync = realpathSync;
       realpath.monkeypatch = monkeypatch;
       realpath.unmonkeypatch = unmonkeypatch;
-      var fs2 = __require("fs");
-      var origRealpath = fs2.realpath;
-      var origRealpathSync = fs2.realpathSync;
+      var fs3 = __require("fs");
+      var origRealpath = fs3.realpath;
+      var origRealpathSync = fs3.realpathSync;
       var version = process.version;
       var ok = /^v[0-5]\./.test(version);
       var old = require_old();
@@ -350,12 +350,12 @@ var require_dist = __commonJS(function(exports, module) {
         }
       }
       function monkeypatch() {
-        fs2.realpath = realpath;
-        fs2.realpathSync = realpathSync;
+        fs3.realpath = realpath;
+        fs3.realpathSync = realpathSync;
       }
       function unmonkeypatch() {
-        fs2.realpath = origRealpath;
-        fs2.realpathSync = origRealpathSync;
+        fs3.realpath = origRealpath;
+        fs3.realpathSync = origRealpathSync;
       }
     }
   });
@@ -581,8 +581,8 @@ var require_dist = __commonJS(function(exports, module) {
         return new Minimatch(pattern, options).match(p);
       };
       module2.exports = minimatch;
-      var path2 = require_path();
-      minimatch.sep = path2.sep;
+      var path3 = require_path();
+      minimatch.sep = path3.sep;
       var GLOBSTAR = Symbol("globstar **");
       minimatch.GLOBSTAR = GLOBSTAR;
       var expand = require_brace_expansion();
@@ -1073,8 +1073,8 @@ globstar while`, file, fr, pattern, pr, swallowee);
           if (f === "/" && partial)
             return true;
           const options = this.options;
-          if (path2.sep !== "/") {
-            f = f.split(path2.sep).join("/");
+          if (path3.sep !== "/") {
+            f = f.split(path3.sep).join("/");
           }
           f = f.split(slashSplit);
           this.debug(this.pattern, "split", f);
@@ -1164,8 +1164,8 @@ globstar while`, file, fr, pattern, pr, swallowee);
       function ownProp(obj, field) {
         return Object.prototype.hasOwnProperty.call(obj, field);
       }
-      var fs2 = __require("fs");
-      var path2 = __require("path");
+      var fs3 = __require("fs");
+      var path3 = __require("path");
       var minimatch = require_minimatch();
       var isAbsolute = __require("path").isAbsolute;
       var Minimatch = minimatch.Minimatch;
@@ -1219,7 +1219,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
         self.stat = !!options.stat;
         self.noprocess = !!options.noprocess;
         self.absolute = !!options.absolute;
-        self.fs = options.fs || fs2;
+        self.fs = options.fs || fs3;
         self.maxLength = options.maxLength || Infinity;
         self.cache = options.cache || /* @__PURE__ */ Object.create(null);
         self.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -1228,13 +1228,13 @@ globstar while`, file, fr, pattern, pr, swallowee);
         self.changedCwd = false;
         var cwd = process.cwd();
         if (!ownProp(options, "cwd"))
-          self.cwd = path2.resolve(cwd);
+          self.cwd = path3.resolve(cwd);
         else {
-          self.cwd = path2.resolve(options.cwd);
+          self.cwd = path3.resolve(options.cwd);
           self.changedCwd = self.cwd !== cwd;
         }
-        self.root = options.root || path2.resolve(self.cwd, "/");
-        self.root = path2.resolve(self.root);
+        self.root = options.root || path3.resolve(self.cwd, "/");
+        self.root = path3.resolve(self.root);
         self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
         self.nomount = !!options.nomount;
         if (process.platform === "win32") {
@@ -1317,30 +1317,30 @@ globstar while`, file, fr, pattern, pr, swallowee);
       function makeAbs(self, f) {
         var abs = f;
         if (f.charAt(0) === "/") {
-          abs = path2.join(self.root, f);
+          abs = path3.join(self.root, f);
         } else if (isAbsolute(f) || f === "") {
           abs = f;
         } else if (self.changedCwd) {
-          abs = path2.resolve(self.cwd, f);
+          abs = path3.resolve(self.cwd, f);
         } else {
-          abs = path2.resolve(f);
+          abs = path3.resolve(f);
         }
         if (process.platform === "win32")
           abs = abs.replace(/\\/g, "/");
         return abs;
       }
-      function isIgnored(self, path3) {
+      function isIgnored(self, path4) {
         if (!self.ignore.length)
           return false;
         return self.ignore.some(function(item) {
-          return item.matcher.match(path3) || !!(item.gmatcher && item.gmatcher.match(path3));
+          return item.matcher.match(path4) || !!(item.gmatcher && item.gmatcher.match(path4));
         });
       }
-      function childrenIgnored(self, path3) {
+      function childrenIgnored(self, path4) {
         if (!self.ignore.length)
           return false;
         return self.ignore.some(function(item) {
-          return !!(item.gmatcher && item.gmatcher.match(path3));
+          return !!(item.gmatcher && item.gmatcher.match(path4));
         });
       }
     }
@@ -1354,7 +1354,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
       var Minimatch = minimatch.Minimatch;
       var Glob = require_glob().Glob;
       var util = __require("util");
-      var path2 = __require("path");
+      var path3 = __require("path");
       var assert = __require("assert");
       var isAbsolute = __require("path").isAbsolute;
       var common = require_common();
@@ -1484,7 +1484,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
                 e = prefix + e;
             }
             if (e.charAt(0) === "/" && !this.nomount) {
-              e = path2.join(this.root, e);
+              e = path3.join(this.root, e);
             }
             this._emitMatch(index, e);
           }
@@ -1633,9 +1633,9 @@ See: https://github.com/isaacs/node-glob/issues/167`);
         if (prefix && isAbsolute(prefix) && !this.nomount) {
           var trail = /[\/\\]$/.test(prefix);
           if (prefix.charAt(0) === "/") {
-            prefix = path2.join(this.root, prefix);
+            prefix = path3.join(this.root, prefix);
           } else {
-            prefix = path2.resolve(this.root, prefix);
+            prefix = path3.resolve(this.root, prefix);
             if (trail)
               prefix += "/";
           }
@@ -1822,7 +1822,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
       var Minimatch = minimatch.Minimatch;
       var inherits = require_inherits();
       var EE = __require("events").EventEmitter;
-      var path2 = __require("path");
+      var path3 = __require("path");
       var assert = __require("assert");
       var isAbsolute = __require("path").isAbsolute;
       var globSync = require_sync();
@@ -2105,7 +2105,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
                 e = prefix + e;
             }
             if (e.charAt(0) === "/" && !this.nomount) {
-              e = path2.join(this.root, e);
+              e = path3.join(this.root, e);
             }
             this._emitMatch(index, e);
           }
@@ -2292,9 +2292,9 @@ See: https://github.com/isaacs/node-glob/issues/167`);
         if (prefix && isAbsolute(prefix) && !this.nomount) {
           var trail = /[\/\\]$/.test(prefix);
           if (prefix.charAt(0) === "/") {
-            prefix = path2.join(this.root, prefix);
+            prefix = path3.join(this.root, prefix);
           } else {
-            prefix = path2.resolve(this.root, prefix);
+            prefix = path3.resolve(this.root, prefix);
             if (trail)
               prefix += "/";
           }
@@ -2387,12 +2387,27 @@ See: https://github.com/isaacs/node-glob/issues/167`);
   __export(src_exports, {
     getMatchingFilePaths: () => getMatchingFilePaths,
     getVirtualFileSystemFromDirPath: () => getVirtualFileSystemFromDirPath,
-    getVirtualFilesystemModuleFromDirPath: () => getVirtualFilesystemModuleFromDirPath
+    getVirtualFilesystemModuleFromDirPath: () => getVirtualFilesystemModuleFromDirPath,
+    writeVfsToDirectory: () => writeVfsToDirectory
   });
   module.exports = __toCommonJS(src_exports);
   var import_glob_promise = __toESM(require_lib());
-  var import_path = __toESM(__require("path"));
+  var import_path2 = __toESM(__require("path"));
   var import_promises = __toESM(__require("fs/promises"));
+  var import_fs = __toESM(__require("fs"));
+  var import_path = __toESM(__require("path"));
+  var writeVfsToDirectory = async (opts) => {
+    const { vfs, vfsDir, outDir } = opts;
+    for (const [filePath, content] of Object.entries(vfs)) {
+      if (vfsDir && !filePath.startsWith(vfsDir)) {
+        continue;
+      }
+      const relativePath = vfsDir ? import_path.default.relative(vfsDir, filePath) : filePath;
+      const outputPath = import_path.default.join(outDir, relativePath);
+      await import_fs.default.promises.mkdir(import_path.default.dirname(outputPath), { recursive: true });
+      await import_fs.default.promises.writeFile(outputPath, content);
+    }
+  };
   var charsSafeToLeaveEncoded = "{}.,<>?/:'[]!@#$^&*() -_=+".split("");
   var replaceSafeEncodedChars = (s) => {
     for (const char of charsSafeToLeaveEncoded) {
@@ -2405,12 +2420,6 @@ See: https://github.com/isaacs/node-glob/issues/167`);
   function idsafe(s) {
     return "_" + s.replace(/[^a-zA-Z0-9]/g, "_");
   }
-  var toPosixPath = (pathStr) => {
-    if (!pathStr)
-      return pathStr;
-    pathStr = pathStr.replace(/^[A-Za-z]:/, "");
-    return pathStr.split(import_path.default.sep).join("/");
-  };
   var getMatchingFilePaths = async ({
     dirPath,
     extensions,
@@ -2423,24 +2432,17 @@ See: https://github.com/isaacs/node-glob/issues/167`);
     }
     if (!fileMatchFn)
       fileMatchFn = () => true;
-    const files = await (0, import_glob_promise.default)("**/*", {
-      cwd: dirPath,
-      nodir: true,
-      dot: true,
-      absolute: false,
-      windowsPathsNoEscape: true
-    });
-    return files.map((f) => toPosixPath(f)).filter((filename) => fileMatchFn(filename, import_path.default.join(dirPath, filename)));
+    return (await (0, import_glob_promise.default)("**/*", { cwd: dirPath, nodir: true })).filter((filename) => fileMatchFn(filename, import_path2.default.resolve(dirPath, filename)));
   };
   var getVirtualFileSystemFromDirPath = async (opts) => {
-    const { dirPath, contentFormat = "string" } = opts;
+    const { dirPath, contentFormat } = opts;
     const filePaths = await getMatchingFilePaths(opts);
     const vfs = {};
     for (const filePath of filePaths) {
-      const fullPath = import_path.default.join(dirPath, filePath);
-      const content = await import_promises.default.readFile(fullPath);
-      const normalizedPath = toPosixPath(filePath);
-      vfs[normalizedPath] = content.toString();
+      vfs[filePath] = await import_promises.default.readFile(import_path2.default.resolve(dirPath, filePath));
+      if (contentFormat === "string") {
+        vfs[filePath] = vfs[filePath].toString();
+      }
     }
     return vfs;
   };
@@ -2451,7 +2453,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
       case "buffer":
       case "string": {
         return `export default {
-` + Object.entries(vfs).map(([filePath, content]) => cf === "buffer" ? `  "${toPosixPath(filePath)}": Buffer.from("${content.toString("base64")}", "base64")` : `  "${toPosixPath(filePath)}": decodeURIComponent("${replaceSafeEncodedChars(encodeURIComponent(content.toString()))}")`).join(`,
+` + Object.entries(vfs).map(([path3, content]) => cf === "buffer" ? `  "${path3}": Buffer.from("${content.toString("base64")}")` : `  "${path3}": decodeURIComponent("${replaceSafeEncodedChars(encodeURIComponent(content.toString()))}")`).join(`,
 `) + `
 }`;
       }
@@ -2460,12 +2462,12 @@ See: https://github.com/isaacs/node-glob/issues/167`);
       case "import-star": {
         if (!opts.targetPath)
           throw new Error(`targetPath is required when using content-format of require,import-default,import-star`);
-        const basePath = import_path.default.relative(import_path.default.dirname(opts.targetPath), opts.dirPath);
+        const basePath = import_path2.default.relative(import_path2.default.dirname(opts.targetPath), opts.dirPath);
         let fps = Object.keys(vfs);
         if (opts.noImportExt) {
           fps = fps.map((fp) => fp.replace(/\.[^.]+$/, ""));
         }
-        return `${fps.map((fp) => cf === "require" ? `const ${idsafe(fp)} = require("./${import_path.default.join(basePath, fp)}")` : cf === "import-default" ? `import ${idsafe(fp)} from "./${import_path.default.join(basePath, fp)}"` : `import * as ${idsafe(fp)} from "./${import_path.default.join(basePath, fp)}"`).join(`
+        return `${fps.map((fp) => cf === "require" ? `const ${idsafe(fp)} = require("./${import_path2.default.join(basePath, fp)}")` : cf === "import-default" ? `import ${idsafe(fp)} from "./${import_path2.default.join(basePath, fp)}"` : `import * as ${idsafe(fp)} from "./${import_path2.default.join(basePath, fp)}"`).join(`
 `)}
 
 export default {
@@ -2478,25 +2480,10 @@ export default {
       }
       case "export-pathlist": {
         return `export default [
-` + Object.keys(vfs).map((path2) => `  "${path2}"`).join(`,
+` + Object.keys(vfs).map((path3) => `  "${path3}"`).join(`,
 `) + `
 ]`;
       }
-      case "import-bunfile": {
-        if (!opts.targetPath)
-          throw new Error(`targetPath is required when using content-format of require,import-default,import-star`);
-        const basePath = import_path.default.relative(import_path.default.dirname(opts.targetPath), opts.dirPath);
-        let fps = Object.keys(vfs);
-        return `${fps.map((fp) => `import ${idsafe(fp)} from "./${import_path.default.join(basePath, fp)}" with { type: "file" };`).join(`
-`)}
-
-import { file } from "bun";
-
-export default {
-` + fps.map((fp) => `  "${fp}": file(${idsafe(fp)})`).join(`,
-`) + `
-}`;
-      }
     }
     throw new Error(`Unknown content format: ${cf}`);
   };
@@ -31913,7 +31900,7 @@ import { parentPort } from "node:worker_threads";
 
 // cli/build/worker-build-handlers.ts
 import fs15 from "node:fs";
-import path19 from "node:path";
+import path21 from "node:path";
 
 // lib/project-config/index.ts
 import * as fs from "node:fs";
@@ -32169,8 +32156,8 @@ function formatCircuitJsonDiagnostics({
 
 // lib/shared/generate-circuit-json.tsx
 import fs8 from "node:fs";
-import path8 from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
+import path10 from "node:path";
+import { pathToFileURL as pathToFileURL4 } from "node:url";
 import Debug from "debug";
 
 // lib/utils/abbreviate-stringify-object.ts
@@ -32963,36 +32950,1045 @@ function attachAutoroutingArtifacts(root, filePath, projectDir = process.cwd())
 
 // lib/shared/importFromUserLand.ts
 import { createRequire as createRequire2 } from "node:module";
+import path6 from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+
+// node_modules/import-meta-resolve/lib/resolve.js
+import assert2 from "node:assert";
+import { statSync as statSync2, realpathSync } from "node:fs";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+import path5 from "node:path";
+import { builtinModules } from "node:module";
+
+// node_modules/import-meta-resolve/lib/get-format.js
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// node_modules/import-meta-resolve/lib/package-json-reader.js
 import fs4 from "node:fs";
 import path4 from "node:path";
-async function importFromUserLand(moduleName, projectDir = process.cwd()) {
-  const userModulePath = path4.join(projectDir, "node_modules", moduleName);
-  if (fs4.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path4.join(projectDir, "noop.js"));
+import { fileURLToPath } from "node:url";
+
+// node_modules/import-meta-resolve/lib/errors.js
+import v8 from "node:v8";
+import assert from "node:assert";
+import { format, inspect } from "node:util";
+var own = {}.hasOwnProperty;
+var classRegExp = /^([A-Z][a-z\d]*)+$/;
+var kTypes = new Set([
+  "string",
+  "function",
+  "number",
+  "object",
+  "Function",
+  "Object",
+  "boolean",
+  "bigint",
+  "symbol"
+]);
+var codes = {};
+function formatList(array, type = "and") {
+  return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`;
+}
+var messages = new Map;
+var nodeInternalPrefix = "__node_internal_";
+var userStackTraceLimit;
+codes.ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
+  assert.ok(typeof name === "string", "'name' must be a string");
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+  let message = "The ";
+  if (name.endsWith(" argument")) {
+    message += `${name} `;
+  } else {
+    const type = name.includes(".") ? "property" : "argument";
+    message += `"${name}" ${type} `;
+  }
+  message += "must be ";
+  const types = [];
+  const instances = [];
+  const other = [];
+  for (const value of expected) {
+    assert.ok(typeof value === "string", "All expected entries have to be of type string");
+    if (kTypes.has(value)) {
+      types.push(value.toLowerCase());
+    } else if (classRegExp.exec(value) === null) {
+      assert.ok(value !== "object", 'The value "object" should be written as "Object"');
+      other.push(value);
+    } else {
+      instances.push(value);
+    }
+  }
+  if (instances.length > 0) {
+    const pos = types.indexOf("object");
+    if (pos !== -1) {
+      types.slice(pos, 1);
+      instances.push("Object");
+    }
+  }
+  if (types.length > 0) {
+    message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(types, "or")}`;
+    if (instances.length > 0 || other.length > 0)
+      message += " or ";
+  }
+  if (instances.length > 0) {
+    message += `an instance of ${formatList(instances, "or")}`;
+    if (other.length > 0)
+      message += " or ";
+  }
+  if (other.length > 0) {
+    if (other.length > 1) {
+      message += `one of ${formatList(other, "or")}`;
+    } else {
+      if (other[0].toLowerCase() !== other[0])
+        message += "an ";
+      message += `${other[0]}`;
+    }
+  }
+  message += `. Received ${determineSpecificType(actual)}`;
+  return message;
+}, TypeError);
+codes.ERR_INVALID_MODULE_SPECIFIER = createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base = undefined) => {
+  return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+}, TypeError);
+codes.ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path, base, message) => {
+  return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+}, Error);
+codes.ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (packagePath, key, target, isImport = false, base = undefined) => {
+  const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+  if (key === ".") {
+    assert.ok(isImport === false);
+    return `Invalid "exports" main target ${JSON.stringify(target)} defined ` + `in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+  }
+  return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+}, Error);
+codes.ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path, base, exactUrl = false) => {
+  return `Cannot find ${exactUrl ? "module" : "package"} '${path}' imported from ${base}`;
+}, Error);
+codes.ERR_NETWORK_IMPORT_DISALLOWED = createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
+  return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+}, TypeError);
+codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (packagePath, subpath, base = undefined) => {
+  if (subpath === ".")
+    return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+  return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+}, Error);
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported " + "resolving ES modules imported from %s", Error);
+codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError("ERR_UNSUPPORTED_RESOLVE_REQUEST", 'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.', TypeError);
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path) => {
+  return `Unknown file extension "${extension}" for ${path}`;
+}, TypeError);
+codes.ERR_INVALID_ARG_VALUE = createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
+  let inspected = inspect(value);
+  if (inspected.length > 128) {
+    inspected = `${inspected.slice(0, 128)}...`;
+  }
+  const type = name.includes(".") ? "property" : "argument";
+  return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+}, TypeError);
+function createError(sym, value, constructor) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(constructor, sym);
+}
+function makeNodeErrorWithCode(Base, key) {
+  return NodeError;
+  function NodeError(...parameters) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable())
+      Error.stackTraceLimit = 0;
+    const error = new Base;
+    if (isErrorStackTraceLimitWritable())
+      Error.stackTraceLimit = limit;
+    const message = getMessage(key, parameters, error);
+    Object.defineProperties(error, {
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        value() {
+          return `${this.name} [${key}]: ${this.message}`;
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    captureLargerStackTrace(error);
+    error.code = key;
+    return error;
+  }
+}
+function isErrorStackTraceLimitWritable() {
+  try {
+    if (v8.startupSnapshot.isBuildingSnapshot()) {
+      return false;
+    }
+  } catch {}
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === undefined) {
+    return Object.isExtensible(Error);
+  }
+  return own.call(desc, "writable") && desc.writable !== undefined ? desc.writable : desc.set !== undefined;
+}
+function hideStackFrames(wrappedFunction) {
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, "name", { value: hidden });
+  return wrappedFunction;
+}
+var captureLargerStackTrace = hideStackFrames(function(error) {
+  const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+  if (stackTraceLimitIsWritable) {
+    userStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+  }
+  Error.captureStackTrace(error);
+  if (stackTraceLimitIsWritable)
+    Error.stackTraceLimit = userStackTraceLimit;
+  return error;
+});
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  assert.ok(message !== undefined, "expected `message` to be found");
+  if (typeof message === "function") {
+    assert.ok(message.length <= parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not ` + `match the required ones (${message.length}).`);
+    return Reflect.apply(message, self, parameters);
+  }
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null)
+    expectedLength++;
+  assert.ok(expectedLength === parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not ` + `match the required ones (${expectedLength}).`);
+  if (parameters.length === 0)
+    return message;
+  parameters.unshift(message);
+  return Reflect.apply(format, null, parameters);
+}
+function determineSpecificType(value) {
+  if (value === null || value === undefined) {
+    return String(value);
+  }
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${inspect(value, { depth: -1 })}`;
+  }
+  let inspected = inspect(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
+}
+
+// node_modules/import-meta-resolve/lib/package-json-reader.js
+var hasOwnProperty = {}.hasOwnProperty;
+var { ERR_INVALID_PACKAGE_CONFIG } = codes;
+var cache = new Map;
+function read(jsonPath, { base, specifier }) {
+  const existing = cache.get(jsonPath);
+  if (existing) {
+    return existing;
+  }
+  let string;
+  try {
+    string = fs4.readFileSync(path4.toNamespacedPath(jsonPath), "utf8");
+  } catch (error) {
+    const exception = error;
+    if (exception.code !== "ENOENT") {
+      throw exception;
+    }
+  }
+  const result = {
+    exists: false,
+    pjsonPath: jsonPath,
+    main: undefined,
+    name: undefined,
+    type: "none",
+    exports: undefined,
+    imports: undefined
+  };
+  if (string !== undefined) {
+    let parsed;
     try {
-      const resolvedUserPath = userRequire.resolve(moduleName);
-      return await import(resolvedUserPath);
-    } catch (error) {
-      if (error?.code !== "MODULE_NOT_FOUND") {
+      parsed = JSON.parse(string);
+    } catch (error_) {
+      const cause = error_;
+      const error = new ERR_INVALID_PACKAGE_CONFIG(jsonPath, (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier), cause.message);
+      error.cause = cause;
+      throw error;
+    }
+    result.exists = true;
+    if (hasOwnProperty.call(parsed, "name") && typeof parsed.name === "string") {
+      result.name = parsed.name;
+    }
+    if (hasOwnProperty.call(parsed, "main") && typeof parsed.main === "string") {
+      result.main = parsed.main;
+    }
+    if (hasOwnProperty.call(parsed, "exports")) {
+      result.exports = parsed.exports;
+    }
+    if (hasOwnProperty.call(parsed, "imports")) {
+      result.imports = parsed.imports;
+    }
+    if (hasOwnProperty.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
+      result.type = parsed.type;
+    }
+  }
+  cache.set(jsonPath, result);
+  return result;
+}
+function getPackageScopeConfig(resolved) {
+  let packageJSONUrl = new URL("package.json", resolved);
+  while (true) {
+    const packageJSONPath = packageJSONUrl.pathname;
+    if (packageJSONPath.endsWith("node_modules/package.json")) {
+      break;
+    }
+    const packageConfig = read(fileURLToPath(packageJSONUrl), {
+      specifier: resolved
+    });
+    if (packageConfig.exists) {
+      return packageConfig;
+    }
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL("../package.json", packageJSONUrl);
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
+      break;
+    }
+  }
+  const packageJSONPath = fileURLToPath(packageJSONUrl);
+  return {
+    pjsonPath: packageJSONPath,
+    exists: false,
+    type: "none"
+  };
+}
+function getPackageType(url) {
+  return getPackageScopeConfig(url).type;
+}
+
+// node_modules/import-meta-resolve/lib/get-format.js
+var { ERR_UNKNOWN_FILE_EXTENSION } = codes;
+var hasOwnProperty2 = {}.hasOwnProperty;
+var extensionFormatMap = {
+  __proto__: null,
+  ".cjs": "commonjs",
+  ".js": "module",
+  ".json": "json",
+  ".mjs": "module"
+};
+function mimeToFormat(mime) {
+  if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime))
+    return "module";
+  if (mime === "application/json")
+    return "json";
+  return null;
+}
+var protocolHandlers = {
+  __proto__: null,
+  "data:": getDataProtocolModuleFormat,
+  "file:": getFileProtocolModuleFormat,
+  "http:": getHttpProtocolModuleFormat,
+  "https:": getHttpProtocolModuleFormat,
+  "node:"() {
+    return "builtin";
+  }
+};
+function getDataProtocolModuleFormat(parsed) {
+  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [null, null, null];
+  return mimeToFormat(mime);
+}
+function extname(url) {
+  const pathname = url.pathname;
+  let index = pathname.length;
+  while (index--) {
+    const code = pathname.codePointAt(index);
+    if (code === 47) {
+      return "";
+    }
+    if (code === 46) {
+      return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+    }
+  }
+  return "";
+}
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+  const value = extname(url);
+  if (value === ".js") {
+    const packageType = getPackageType(url);
+    if (packageType !== "none") {
+      return packageType;
+    }
+    return "commonjs";
+  }
+  if (value === "") {
+    const packageType = getPackageType(url);
+    if (packageType === "none" || packageType === "commonjs") {
+      return "commonjs";
+    }
+    return "module";
+  }
+  const format = extensionFormatMap[value];
+  if (format)
+    return format;
+  if (ignoreErrors) {
+    return;
+  }
+  const filepath = fileURLToPath2(url);
+  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath);
+}
+function getHttpProtocolModuleFormat() {}
+function defaultGetFormatWithoutErrors(url, context) {
+  const protocol = url.protocol;
+  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
+    return null;
+  }
+  return protocolHandlers[protocol](url, context, true) || null;
+}
+
+// node_modules/import-meta-resolve/lib/utils.js
+var { ERR_INVALID_ARG_VALUE } = codes;
+var DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
+var DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+function getDefaultConditions() {
+  return DEFAULT_CONDITIONS;
+}
+function getDefaultConditionsSet() {
+  return DEFAULT_CONDITIONS_SET;
+}
+function getConditionsSet(conditions) {
+  if (conditions !== undefined && conditions !== getDefaultConditions()) {
+    if (!Array.isArray(conditions)) {
+      throw new ERR_INVALID_ARG_VALUE("conditions", conditions, "expected an array");
+    }
+    return new Set(conditions);
+  }
+  return getDefaultConditionsSet();
+}
+
+// node_modules/import-meta-resolve/lib/resolve.js
+var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+var {
+  ERR_NETWORK_IMPORT_DISALLOWED,
+  ERR_INVALID_MODULE_SPECIFIER,
+  ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG2,
+  ERR_INVALID_PACKAGE_TARGET,
+  ERR_MODULE_NOT_FOUND,
+  ERR_PACKAGE_IMPORT_NOT_DEFINED,
+  ERR_PACKAGE_PATH_NOT_EXPORTED,
+  ERR_UNSUPPORTED_DIR_IMPORT,
+  ERR_UNSUPPORTED_RESOLVE_REQUEST
+} = codes;
+var own2 = {}.hasOwnProperty;
+var invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
+var deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
+var invalidPackageNameRegEx = /^\.|%|\\/;
+var patternRegEx = /\*/g;
+var encodedSeparatorRegEx = /%2f|%5c/i;
+var emittedPackageWarnings = new Set;
+var doubleSlashRegEx = /[/\\]{2}/;
+function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
+  if (process2.noDeprecation) {
+    return;
+  }
+  const pjsonPath = fileURLToPath3(packageJsonUrl);
+  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+  process2.emitWarning(`Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module ` + `request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath3(base)}` : ""}.`, "DeprecationWarning", "DEP0166");
+}
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  if (process2.noDeprecation) {
+    return;
+  }
+  const format = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
+  if (format !== "module")
+    return;
+  const urlPath = fileURLToPath3(url.href);
+  const packagePath = fileURLToPath3(new URL(".", packageJsonUrl));
+  const basePath = fileURLToPath3(base);
+  if (!main) {
+    process2.emitWarning(`No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(packagePath.length)}", imported from ${basePath}.
+Default "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
+  } else if (path5.resolve(packagePath, main) !== urlPath) {
+    process2.emitWarning(`Package ${packagePath} has a "main" field set to "${main}", ` + `excluding the full filename and extension to the resolved file at "${urlPath.slice(packagePath.length)}", imported from ${basePath}.
+ Automatic extension resolution of the "main" field is ` + "deprecated for ES modules.", "DeprecationWarning", "DEP0151");
+  }
+}
+function tryStatSync(path) {
+  try {
+    return statSync2(path);
+  } catch {}
+}
+function fileExists(url) {
+  const stats = statSync2(url, { throwIfNoEntry: false });
+  const isFile = stats ? stats.isFile() : undefined;
+  return isFile === null || isFile === undefined ? false : isFile;
+}
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  let guess;
+  if (packageConfig.main !== undefined) {
+    guess = new URL(packageConfig.main, packageJsonUrl);
+    if (fileExists(guess))
+      return guess;
+    const tries = [
+      `./${packageConfig.main}.js`,
+      `./${packageConfig.main}.json`,
+      `./${packageConfig.main}.node`,
+      `./${packageConfig.main}/index.js`,
+      `./${packageConfig.main}/index.json`,
+      `./${packageConfig.main}/index.node`
+    ];
+    let i = -1;
+    while (++i < tries.length) {
+      guess = new URL(tries[i], packageJsonUrl);
+      if (fileExists(guess))
+        break;
+      guess = undefined;
+    }
+    if (guess) {
+      emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+      return guess;
+    }
+  }
+  const tries = ["./index.js", "./index.json", "./index.node"];
+  let i = -1;
+  while (++i < tries.length) {
+    guess = new URL(tries[i], packageJsonUrl);
+    if (fileExists(guess))
+      break;
+    guess = undefined;
+  }
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+    return guess;
+  }
+  throw new ERR_MODULE_NOT_FOUND(fileURLToPath3(new URL(".", packageJsonUrl)), fileURLToPath3(base));
+}
+function finalizeResolution(resolved, base, preserveSymlinks) {
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(resolved.pathname, 'must not include encoded "/" or "\\" characters', fileURLToPath3(base));
+  }
+  let filePath;
+  try {
+    filePath = fileURLToPath3(resolved);
+  } catch (error) {
+    const cause = error;
+    Object.defineProperty(cause, "input", { value: String(resolved) });
+    Object.defineProperty(cause, "module", { value: String(base) });
+    throw cause;
+  }
+  const stats = tryStatSync(filePath.endsWith("/") ? filePath.slice(-1) : filePath);
+  if (stats && stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath3(base));
+    error.url = String(resolved);
+    throw error;
+  }
+  if (!stats || !stats.isFile()) {
+    const error = new ERR_MODULE_NOT_FOUND(filePath || resolved.pathname, base && fileURLToPath3(base), true);
+    error.url = String(resolved);
+    throw error;
+  }
+  if (!preserveSymlinks) {
+    const real = realpathSync(filePath);
+    const { search, hash } = resolved;
+    resolved = pathToFileURL2(real + (filePath.endsWith(path5.sep) ? "/" : ""));
+    resolved.search = search;
+    resolved.hash = hash;
+  }
+  return resolved;
+}
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(specifier, packageJsonUrl && fileURLToPath3(new URL(".", packageJsonUrl)), fileURLToPath3(base));
+}
+function exportsNotFound(subpath, packageJsonUrl, base) {
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(fileURLToPath3(new URL(".", packageJsonUrl)), subpath, base && fileURLToPath3(base));
+}
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath3(packageJsonUrl)}`;
+  throw new ERR_INVALID_MODULE_SPECIFIER(request, reason, base && fileURLToPath3(base));
+}
+function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
+  target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
+  return new ERR_INVALID_PACKAGE_TARGET(fileURLToPath3(new URL(".", packageJsonUrl)), subpath, target, internal, base && fileURLToPath3(base));
+}
+function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
+  if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (!target.startsWith("./")) {
+    if (internal && !target.startsWith("../") && !target.startsWith("/")) {
+      let isURL = false;
+      try {
+        new URL(target);
+        isURL = true;
+      } catch {}
+      if (!isURL) {
+        const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target + subpath;
+        return packageResolve(exportTarget, packageJsonUrl, conditions);
+      }
+    }
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  }
+  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
+    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+      if (!isPathMap) {
+        const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target;
+        emitInvalidSegmentDeprecation(resolvedTarget, request, match, packageJsonUrl, internal, base, true);
+      }
+    } else {
+      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+    }
+  }
+  const resolved = new URL(target, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL(".", packageJsonUrl).pathname;
+  if (!resolvedPath.startsWith(packagePath))
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (subpath === "")
+    return resolved;
+  if (invalidSegmentRegEx.exec(subpath) !== null) {
+    const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+      if (!isPathMap) {
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target;
+        emitInvalidSegmentDeprecation(resolvedTarget, request, match, packageJsonUrl, internal, base, false);
+      }
+    } else {
+      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+    }
+  }
+  if (pattern) {
+    return new URL(RegExpPrototypeSymbolReplace.call(patternRegEx, resolved.href, () => subpath));
+  }
+  return new URL(subpath, resolved);
+}
+function isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key)
+    return false;
+  return keyNumber >= 0 && keyNumber < 4294967295;
+}
+function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
+  if (typeof target === "string") {
+    return resolvePackageTargetString(target, subpath, packageSubpath, packageJsonUrl, base, pattern, internal, isPathMap, conditions);
+  }
+  if (Array.isArray(target)) {
+    const targetList = target;
+    if (targetList.length === 0)
+      return null;
+    let lastException;
+    let i = -1;
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      let resolveResult;
+      try {
+        resolveResult = resolvePackageTarget(packageJsonUrl, targetItem, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
+      } catch (error) {
+        const exception = error;
+        lastException = exception;
+        if (exception.code === "ERR_INVALID_PACKAGE_TARGET")
+          continue;
+        throw error;
+      }
+      if (resolveResult === undefined)
+        continue;
+      if (resolveResult === null) {
+        lastException = null;
+        continue;
+      }
+      return resolveResult;
+    }
+    if (lastException === undefined || lastException === null) {
+      return null;
+    }
+    throw lastException;
+  }
+  if (typeof target === "object" && target !== null) {
+    const keys = Object.getOwnPropertyNames(target);
+    let i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG2(fileURLToPath3(packageJsonUrl), base, '"exports" cannot contain numeric property keys.');
+      }
+    }
+    i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (key === "default" || conditions && conditions.has(key)) {
+        const conditionalTarget = target[key];
+        const resolveResult = resolvePackageTarget(packageJsonUrl, conditionalTarget, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
+        if (resolveResult === undefined)
+          continue;
+        return resolveResult;
+      }
+    }
+    return null;
+  }
+  if (target === null) {
+    return null;
+  }
+  throw invalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base);
+}
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+  if (typeof exports === "string" || Array.isArray(exports))
+    return true;
+  if (typeof exports !== "object" || exports === null)
+    return false;
+  const keys = Object.getOwnPropertyNames(exports);
+  let isConditionalSugar = false;
+  let i = 0;
+  let keyIndex = -1;
+  while (++keyIndex < keys.length) {
+    const key = keys[keyIndex];
+    const currentIsConditionalSugar = key === "" || key[0] !== ".";
+    if (i++ === 0) {
+      isConditionalSugar = currentIsConditionalSugar;
+    } else if (isConditionalSugar !== currentIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG2(fileURLToPath3(packageJsonUrl), base, `"exports" cannot contain some keys starting with '.' and some not.` + " The exports object must either be an object of package subpath keys" + " or an object of main entry condition name keys only.");
+    }
+  }
+  return isConditionalSugar;
+}
+function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+  if (process2.noDeprecation) {
+    return;
+  }
+  const pjsonPath = fileURLToPath3(pjsonUrl);
+  if (emittedPackageWarnings.has(pjsonPath + "|" + match))
+    return;
+  emittedPackageWarnings.add(pjsonPath + "|" + match);
+  process2.emitWarning(`Use of deprecated trailing slash pattern mapping "${match}" in the ` + `"exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath3(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`, "DeprecationWarning", "DEP0155");
+}
+function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
+  let exports = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
+    exports = { ".": exports };
+  }
+  if (own2.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target = exports[packageSubpath];
+    const resolveResult = resolvePackageTarget(packageJsonUrl, target, "", packageSubpath, base, false, false, false, conditions);
+    if (resolveResult === null || resolveResult === undefined) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  let bestMatch = "";
+  let bestMatchSubpath = "";
+  const keys = Object.getOwnPropertyNames(exports);
+  let i = -1;
+  while (++i < keys.length) {
+    const key = keys[i];
+    const patternIndex = key.indexOf("*");
+    if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
+      if (packageSubpath.endsWith("/")) {
+        emitTrailingSlashPatternDeprecation(packageSubpath, packageJsonUrl, base);
+      }
+      const patternTrailer = key.slice(patternIndex + 1);
+      if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+        bestMatch = key;
+        bestMatchSubpath = packageSubpath.slice(patternIndex, packageSubpath.length - patternTrailer.length);
+      }
+    }
+  }
+  if (bestMatch) {
+    const target = exports[bestMatch];
+    const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, false, packageSubpath.endsWith("/"), conditions);
+    if (resolveResult === null || resolveResult === undefined) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+function patternKeyCompare(a, b) {
+  const aPatternIndex = a.indexOf("*");
+  const bPatternIndex = b.indexOf("*");
+  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
+  if (baseLengthA > baseLengthB)
+    return -1;
+  if (baseLengthB > baseLengthA)
+    return 1;
+  if (aPatternIndex === -1)
+    return 1;
+  if (bPatternIndex === -1)
+    return -1;
+  if (a.length > b.length)
+    return -1;
+  if (b.length > a.length)
+    return 1;
+  return 0;
+}
+function packageImportsResolve(name, base, conditions) {
+  if (name === "#" || name.startsWith("#/") || name.endsWith("/")) {
+    const reason = "is not a valid internal imports specifier name";
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath3(base));
+  }
+  let packageJsonUrl;
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL2(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own2.call(imports, name) && !name.includes("*")) {
+        const resolveResult = resolvePackageTarget(packageJsonUrl, imports[name], "", name, base, false, true, false, conditions);
+        if (resolveResult !== null && resolveResult !== undefined) {
+          return resolveResult;
+        }
+      } else {
+        let bestMatch = "";
+        let bestMatchSubpath = "";
+        const keys = Object.getOwnPropertyNames(imports);
+        let i = -1;
+        while (++i < keys.length) {
+          const key = keys[i];
+          const patternIndex = key.indexOf("*");
+          if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+            const patternTrailer = key.slice(patternIndex + 1);
+            if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+              bestMatch = key;
+              bestMatchSubpath = name.slice(patternIndex, name.length - patternTrailer.length);
+            }
+          }
+        }
+        if (bestMatch) {
+          const target = imports[bestMatch];
+          const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, true, false, conditions);
+          if (resolveResult !== null && resolveResult !== undefined) {
+            return resolveResult;
+          }
+        }
+      }
+    }
+  }
+  throw importNotDefined(name, packageJsonUrl, base);
+}
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf("/");
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === "@") {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+    }
+  }
+  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+  if (invalidPackageNameRegEx.exec(packageName) !== null) {
+    validPackageName = false;
+  }
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(specifier, "is not a valid package name", fileURLToPath3(base));
+  }
+  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
+  return { packageName, packageSubpath, isScoped };
+}
+function packageResolve(specifier, base, conditions) {
+  if (builtinModules.includes(specifier)) {
+    return new URL("node:" + specifier);
+  }
+  const { packageName, packageSubpath, isScoped } = parsePackageName(specifier, base);
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    const packageJsonUrl = pathToFileURL2(packageConfig.pjsonPath);
+    if (packageConfig.name === packageName && packageConfig.exports !== undefined && packageConfig.exports !== null) {
+      return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+    }
+  }
+  let packageJsonUrl = new URL("./node_modules/" + packageName + "/package.json", base);
+  let packageJsonPath = fileURLToPath3(packageJsonUrl);
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat || !stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl);
+      packageJsonPath = fileURLToPath3(packageJsonUrl);
+      continue;
+    }
+    const packageConfig = read(packageJsonPath, { base, specifier });
+    if (packageConfig.exports !== undefined && packageConfig.exports !== null) {
+      return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+    }
+    if (packageSubpath === ".") {
+      return legacyMainResolve(packageJsonUrl, packageConfig, base);
+    }
+    return new URL(packageSubpath, packageJsonUrl);
+  } while (packageJsonPath.length !== lastPath.length);
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath3(base), false);
+}
+function isRelativeSpecifier(specifier) {
+  if (specifier[0] === ".") {
+    if (specifier.length === 1 || specifier[1] === "/")
+      return true;
+    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === "")
+    return false;
+  if (specifier[0] === "/")
+    return true;
+  return isRelativeSpecifier(specifier);
+}
+function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  if (conditions === undefined) {
+    conditions = getConditionsSet();
+  }
+  const protocol = base.protocol;
+  const isData = protocol === "data:";
+  const isRemote = isData || protocol === "http:" || protocol === "https:";
+  let resolved;
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    try {
+      resolved = new URL(specifier, base);
+    } catch (error_) {
+      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+      error.cause = error_;
+      throw error;
+    }
+  } else if (protocol === "file:" && specifier[0] === "#") {
+    resolved = packageImportsResolve(specifier, base, conditions);
+  } else {
+    try {
+      resolved = new URL(specifier);
+    } catch (error_) {
+      if (isRemote && !builtinModules.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+        error.cause = error_;
         throw error;
       }
+      resolved = packageResolve(specifier, base, conditions);
+    }
+  }
+  assert2.ok(resolved !== undefined, "expected to be defined");
+  if (resolved.protocol !== "file:") {
+    return resolved;
+  }
+  return finalizeResolution(resolved, base, preserveSymlinks);
+}
+function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
+  if (parsedParentURL) {
+    const parentProtocol = parsedParentURL.protocol;
+    if (parentProtocol === "http:" || parentProtocol === "https:") {
+      if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+        const parsedProtocol = parsed?.protocol;
+        if (parsedProtocol && parsedProtocol !== "https:" && parsedProtocol !== "http:") {
+          throw new ERR_NETWORK_IMPORT_DISALLOWED(specifier, parsedParentURL, "remote imports cannot import from a local location.");
+        }
+        return { url: parsed?.href || "" };
+      }
+      if (builtinModules.includes(specifier)) {
+        throw new ERR_NETWORK_IMPORT_DISALLOWED(specifier, parsedParentURL, "remote imports cannot import from a local location.");
+      }
+      throw new ERR_NETWORK_IMPORT_DISALLOWED(specifier, parsedParentURL, "only relative and absolute specifiers are supported.");
+    }
+  }
+}
+function isURL(self) {
+  return Boolean(self && typeof self === "object" && "href" in self && typeof self.href === "string" && "protocol" in self && typeof self.protocol === "string" && self.href && self.protocol);
+}
+function throwIfInvalidParentURL(parentURL) {
+  if (parentURL === undefined) {
+    return;
+  }
+  if (typeof parentURL !== "string" && !isURL(parentURL)) {
+    throw new codes.ERR_INVALID_ARG_TYPE("parentURL", ["string", "URL"], parentURL);
+  }
+}
+function defaultResolve(specifier, context = {}) {
+  const { parentURL } = context;
+  assert2.ok(parentURL !== undefined, "expected `parentURL` to be defined");
+  throwIfInvalidParentURL(parentURL);
+  let parsedParentURL;
+  if (parentURL) {
+    try {
+      parsedParentURL = new URL(parentURL);
+    } catch {}
+  }
+  let parsed;
+  let protocol;
+  try {
+    parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier) ? new URL(specifier, parsedParentURL) : new URL(specifier);
+    protocol = parsed.protocol;
+    if (protocol === "data:") {
+      return { url: parsed.href, format: null };
     }
+  } catch {}
+  const maybeReturn = checkIfDisallowedImport(specifier, parsed, parsedParentURL);
+  if (maybeReturn)
+    return maybeReturn;
+  if (protocol === undefined && parsed) {
+    protocol = parsed.protocol;
+  }
+  if (protocol === "node:") {
+    return { url: specifier };
+  }
+  if (parsed && parsed.protocol === "node:")
+    return { url: specifier };
+  const conditions = getConditionsSet(context.conditions);
+  const url = moduleResolve(specifier, new URL(parentURL), conditions, false);
+  return {
+    url: url.href,
+    format: defaultGetFormatWithoutErrors(url, { parentURL })
+  };
+}
+
+// node_modules/import-meta-resolve/index.js
+function resolve(specifier, parent) {
+  if (!parent) {
+    throw new Error("Please pass `parent`: `import-meta-resolve` cannot ponyfill that");
   }
-  const cliRequire = createRequire2(import.meta.url);
   try {
-    const resolvedCliPath = cliRequire.resolve(moduleName);
-    return await import(resolvedCliPath);
+    return defaultResolve(specifier, { parentURL: parent }).url;
   } catch (error) {
-    if (error?.code !== "MODULE_NOT_FOUND") {
-      throw error;
+    const exception = error;
+    if ((exception.code === "ERR_UNSUPPORTED_DIR_IMPORT" || exception.code === "ERR_MODULE_NOT_FOUND") && typeof exception.url === "string") {
+      return exception.url;
     }
+    throw error;
+  }
+}
+
+// lib/shared/importFromUserLand.ts
+async function importFromUserLand(moduleName, projectDir = process.cwd()) {
+  for (const parent of [
+    pathToFileURL3(path6.join(projectDir, "noop.js")).href,
+    import.meta.url
+  ]) {
+    let resolved;
+    try {
+      resolved = resolve(moduleName, parent);
+    } catch (error) {
+      if (error?.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+        resolved = pathToFileURL3(createRequire2(parent).resolve(moduleName)).href;
+      } else if (error?.code === "ERR_MODULE_NOT_FOUND") {
+        continue;
+      } else {
+        throw error;
+      }
+    }
+    return import(resolved);
   }
   return import(moduleName);
 }
 
 // lib/shared/register-static-asset-loaders.ts
 import fs5 from "node:fs";
-import path5 from "node:path";
+import path7 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -33019,7 +34015,7 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sym"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
     return fs5.readFileSync(filePath, "utf-8");
   }
@@ -33027,7 +34023,7 @@ var readFileContentForStaticLoader = (filePath) => {
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path5.extname(filePath).toLowerCase();
+  const extWithDot = path7.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -33041,7 +34037,7 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = (projectDir) => {
-  const tsconfigPath = path5.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path7.join(projectDir, "tsconfig.json");
   try {
     if (!fs5.existsSync(tsconfigPath)) {
       return null;
@@ -33073,8 +34069,8 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path5.resolve(projectDir, baseUrl) : projectDir;
-          const relativePath = path5.relative(baseDir, args.path).split(path5.sep).join("/");
+          const baseDir = baseUrl ? path7.resolve(projectDir, baseUrl) : projectDir;
+          const relativePath = path7.relative(baseDir, args.path).split(path7.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -33091,7 +34087,7 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
 
 // lib/shared/circuit-json-build-cache.ts
 import fs6 from "node:fs";
-import path6 from "node:path";
+import path8 from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var SOURCE_FILE_EXTENSIONS = new Set([
   ".tsx",
@@ -33115,43 +34111,43 @@ var IGNORED_DIRECTORY_NAMES = new Set([
   ".git"
 ]);
 var isPathInside = (childPath, parentPath) => {
-  const relative = path6.relative(parentPath, childPath);
-  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+  const relative = path8.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
 };
 var findCircuitProjectDir = (filePath) => {
-  const absoluteFilePath = path6.resolve(filePath);
-  let currentDir = path6.dirname(absoluteFilePath);
+  const absoluteFilePath = path8.resolve(filePath);
+  let currentDir = path8.dirname(absoluteFilePath);
   while (true) {
-    if (fs6.existsSync(path6.join(currentDir, "package.json"))) {
+    if (fs6.existsSync(path8.join(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parentDir = path6.dirname(currentDir);
+    const parentDir = path8.dirname(currentDir);
     if (parentDir === currentDir)
       break;
     currentDir = parentDir;
   }
-  const cwd = path6.resolve(process.cwd());
-  return isPathInside(absoluteFilePath, cwd) ? cwd : path6.dirname(absoluteFilePath);
+  const cwd = path8.resolve(process.cwd());
+  return isPathInside(absoluteFilePath, cwd) ? cwd : path8.dirname(absoluteFilePath);
 };
 var getCircuitJsonOutputDirName = (relativePath) => {
   const normalizedRelativePath = relativePath.toLowerCase().replaceAll("\\", "/");
   if (normalizedRelativePath === "circuit.json" || normalizedRelativePath.endsWith("/circuit.json")) {
-    return path6.dirname(relativePath);
+    return path8.dirname(relativePath);
   }
   return relativePath.replace(/(\.board|\.circuit)?\.tsx$/, "").replace(/\.circuit\.json$/, "");
 };
 var getCircuitJsonBuildOutputPath = (filePath) => {
-  const absoluteFilePath = path6.resolve(filePath);
+  const absoluteFilePath = path8.resolve(filePath);
   const projectDir = findCircuitProjectDir(absoluteFilePath);
-  const relativePath = path6.relative(projectDir, absoluteFilePath);
-  return path6.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
+  const relativePath = path8.relative(projectDir, absoluteFilePath);
+  return path8.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
 };
 var getSourceFilePaths = (projectDir) => {
   const sourceFilePaths = [];
   const visit = (directoryPath) => {
     const entries = fs6.readdirSync(directoryPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const entryPath = path6.join(directoryPath, entry.name);
+      const entryPath = path8.join(directoryPath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".")) {
           continue;
@@ -33159,7 +34155,7 @@ var getSourceFilePaths = (projectDir) => {
         visit(entryPath);
         continue;
       }
-      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path6.extname(entry.name).toLowerCase())) {
+      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path8.extname(entry.name).toLowerCase())) {
         continue;
       }
       sourceFilePaths.push(entryPath);
@@ -33172,7 +34168,7 @@ var getSourceFilesystemMd5Hash = (filePath) => {
   const projectDir = findCircuitProjectDir(filePath);
   const hash = createHash2("md5");
   for (const sourceFilePath of getSourceFilePaths(projectDir)) {
-    const relativePath = path6.relative(projectDir, sourceFilePath).split(path6.sep).join("/");
+    const relativePath = path8.relative(projectDir, sourceFilePath).split(path8.sep).join("/");
     const content = fs6.readFileSync(sourceFilePath);
     hash.update(`${Buffer.byteLength(relativePath)}:`);
     hash.update(relativePath);
@@ -33223,7 +34219,7 @@ var readCurrentCircuitJsonBuild = ({
 
 // lib/shared/solver-diagnostics.ts
 import fs7 from "node:fs";
-import path7 from "node:path";
+import path9 from "node:path";
 var escapeJsonPointerSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
 var cloneAsJson = (value, ancestors = new WeakMap, path = "#") => {
   if (value === undefined)
@@ -33324,7 +34320,7 @@ class SolverDiagnostics {
   finalize() {
     if (!this.options.enabled)
       return;
-    fs7.mkdirSync(path7.dirname(this.options.outputPath), { recursive: true });
+    fs7.mkdirSync(path9.dirname(this.options.outputPath), { recursive: true });
     fs7.writeFileSync(this.options.outputPath, `${JSON.stringify({
       format: "tscircuit_solver_debug_v1",
       entrypoint: this.options.entrypoint,
@@ -33368,7 +34364,7 @@ async function generateCircuitJson({
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
   const currentSourceFilesystemMd5Hash = sourceFilesystemMd5Hash ?? getSourceFilesystemMd5Hash(filePath);
-  const projectRootDir = path8.resolve(projectDirOption ?? process.cwd());
+  const projectRootDir = path10.resolve(projectDirOption ?? process.cwd());
   const React = await importFromUserLand("react", projectRootDir);
   globalThis.React = React;
   registerStaticAssetLoaders(platformConfig, projectRootDir);
@@ -33381,12 +34377,12 @@ async function generateCircuitJson({
   const solverDiagnostics = solverDiagnosticsOptions ? new SolverDiagnostics(solverDiagnosticsOptions) : null;
   solverDiagnostics?.attachToRootCircuit(runner);
   attachAutoroutingArtifacts(runner, filePath, projectRootDir);
-  const absoluteFilePath = path8.isAbsolute(filePath) ? filePath : path8.resolve(projectRootDir, filePath);
-  const sourceDir = path8.dirname(absoluteFilePath);
+  const absoluteFilePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(projectRootDir, filePath);
+  const sourceDir = path10.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? sourceDir;
-  const relativeComponentPath = path8.relative(sourceDir, absoluteFilePath);
-  const baseFileName = outputFileName || path8.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path8.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path10.relative(sourceDir, absoluteFilePath);
+  const baseFileName = outputFileName || path10.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path10.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${sourceDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -33406,7 +34402,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path8.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path10.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -33414,32 +34410,41 @@ async function generateCircuitJson({
     })
   };
   debug(`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__ */ jsxDEV(Component, {
-    ...injectedProps ?? {}
-  }, undefined, false, undefined, this));
-  runner.render();
-  const loggedAsyncEffectNames = new Set;
-  while (!runner.isDoneRendering()) {
-    for (const asyncEffect of runner.getRunningAsyncEffects()) {
-      const asyncEffectName = asyncEffect.effectName;
-      if (!asyncEffectName || loggedAsyncEffectNames.has(asyncEffectName)) {
-        continue;
+  const MainComponent = await import(pathToFileURL4(absoluteFilePath).href);
+  let records;
+  if (Array.isArray(MainComponent.circuitJson)) {
+    records = MainComponent.circuitJson;
+  } else {
+    const namedComponent = Object.keys(MainComponent).find((key) => key[0] === key[0].toUpperCase());
+    const Component = MainComponent.default || (namedComponent ? MainComponent[namedComponent] : undefined);
+    if (!Component) {
+      throw new Error(`No component found in "${absoluteFilePath}". Make sure you export a component.`);
+    }
+    runner.add(/* @__PURE__ */ jsxDEV(Component, {
+      ...injectedProps ?? {}
+    }, undefined, false, undefined, this));
+    runner.render();
+    const loggedAsyncEffectNames = new Set;
+    while (!runner.isDoneRendering()) {
+      for (const asyncEffect of runner.getRunningAsyncEffects()) {
+        const asyncEffectName = asyncEffect.effectName;
+        if (!asyncEffectName || loggedAsyncEffectNames.has(asyncEffectName)) {
+          continue;
+        }
+        loggedAsyncEffectNames.add(asyncEffectName);
+        onAsyncEffectStatus?.(asyncEffectName);
       }
-      loggedAsyncEffectNames.add(asyncEffectName);
-      onAsyncEffectStatus?.(asyncEffectName);
+      autorouterDiagnostics.checkTimeout();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      runner.render();
     }
-    autorouterDiagnostics.checkTimeout();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    runner.render();
+    runner.emit("renderComplete");
+    solverDiagnostics?.finalize();
+    const hasImportedBoard = runner.children.some((component) => [component, ...component.getDescendants()].some((instance) => instance[Symbol.for("pcb-spice-pipeline.imported-board.v2")]));
+    records = hasImportedBoard ? (await importFromUserLand("@tscircuit/pcb-spice-pipeline/tsx", projectRootDir)).serializeSimulation(runner) : await runner.getCircuitJson();
   }
-  runner.emit("renderComplete");
-  solverDiagnostics?.finalize();
-  const circuitJson = addSourceFilesystemHash(await runner.getCircuitJson(), currentSourceFilesystemMd5Hash);
+  const modeling = MainComponent.modeling;
+  const circuitJson = addSourceFilesystemHash(records, currentSourceFilesystemMd5Hash);
   await autorouterDiagnostics.finalize(circuitJson);
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
@@ -33448,14 +34453,15 @@ async function generateCircuitJson({
   return {
     circuitJson,
     outputPath,
-    rootCircuit: runner
+    rootCircuit: runner,
+    modeling
   };
 }
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash as createHash3 } from "node:crypto";
 import fs9 from "node:fs";
-import path9 from "node:path";
+import path11 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
 
 // lib/shared/platform-config-utils.ts
@@ -33516,13 +34522,13 @@ var getPlatformFetch = (upstreamFetch = globalThis.fetch) => {
 };
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
-function createLocalCacheEngine(cacheDir = path9.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path11.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
         const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path9.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        const filePath = path11.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
         return fs9.readFileSync(filePath, "utf-8");
       } catch {
         return null;
@@ -33533,7 +34539,7 @@ function createLocalCacheEngine(cacheDir = path9.join(process.cwd(), ".tscircuit
         fs9.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path9.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        const filePath = path11.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
         fs9.writeFileSync(filePath, value);
       } catch {}
     }
@@ -33542,7 +34548,7 @@ function createLocalCacheEngine(cacheDir = path9.join(process.cwd(), ".tscircuit
 function getPlatformConfigWithCliDefaults(userConfig, options) {
   const projectDir = options?.projectDir ?? process.cwd();
   const basePlatformConfig = getPlatformConfig();
-  const cacheDir = path9.join(projectDir, ".tscircuit", "cache");
+  const cacheDir = path11.join(projectDir, ".tscircuit", "cache");
   const defaultConfig = {
     ...basePlatformConfig,
     checkAvailability: true,
@@ -33553,14 +34559,14 @@ function getPlatformConfigWithCliDefaults(userConfig, options) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path9.resolve(projectDir, url);
+            const absolutePath = path11.resolve(projectDir, url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
             if (fs9.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path9.resolve(projectDir, relativePath);
+              const absolutePath = path11.resolve(projectDir, relativePath);
               if (fs9.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
@@ -33819,7 +34825,7 @@ function convertCircuitJsonToPcbSvg2(elements, options = {}) {
 
 // cli/build/worker-output-generators.ts
 import fs14 from "node:fs";
-import path18 from "node:path";
+import path20 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -50554,7 +51560,7 @@ import { convertCircuitJsonToSchematicSvg } from "circuit-to-svg";
 // lib/shared/load-local-step-model-fs-map.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import path10 from "node:path";
+import path12 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -50566,7 +51572,7 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path10.resolve(process.cwd(), modelUrl);
+    const localPath = path12.resolve(process.cwd(), modelUrl);
     if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
@@ -50641,11 +51647,11 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
-import process7 from "node:process";
+import process8 from "node:process";
 import fs11 from "node:fs";
-import path14 from "node:path";
+import path16 from "node:path";
 import crypto from "node:crypto";
-import assert from "node:assert";
+import assert3 from "node:assert";
 
 // node_modules/dot-prop/index.js
 var isObject = (value) => {
@@ -50863,41 +51869,41 @@ function hasProperty(object, path) {
 }
 
 // node_modules/env-paths/index.js
-import path11 from "node:path";
+import path13 from "node:path";
 import os from "node:os";
-import process2 from "node:process";
+import process3 from "node:process";
 var homedir = os.homedir();
 var tmpdir = os.tmpdir();
-var { env } = process2;
+var { env } = process3;
 var macos = (name) => {
-  const library = path11.join(homedir, "Library");
+  const library = path13.join(homedir, "Library");
   return {
-    data: path11.join(library, "Application Support", name),
-    config: path11.join(library, "Preferences", name),
-    cache: path11.join(library, "Caches", name),
-    log: path11.join(library, "Logs", name),
-    temp: path11.join(tmpdir, name)
+    data: path13.join(library, "Application Support", name),
+    config: path13.join(library, "Preferences", name),
+    cache: path13.join(library, "Caches", name),
+    log: path13.join(library, "Logs", name),
+    temp: path13.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path11.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path11.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path13.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path13.join(homedir, "AppData", "Local");
   return {
-    data: path11.join(localAppData, name, "Data"),
-    config: path11.join(appData, name, "Config"),
-    cache: path11.join(localAppData, name, "Cache"),
-    log: path11.join(localAppData, name, "Log"),
-    temp: path11.join(tmpdir, name)
+    data: path13.join(localAppData, name, "Data"),
+    config: path13.join(appData, name, "Config"),
+    cache: path13.join(localAppData, name, "Cache"),
+    log: path13.join(localAppData, name, "Log"),
+    temp: path13.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path11.basename(homedir);
+  const username = path13.basename(homedir);
   return {
-    data: path11.join(env.XDG_DATA_HOME || path11.join(homedir, ".local", "share"), name),
-    config: path11.join(env.XDG_CONFIG_HOME || path11.join(homedir, ".config"), name),
-    cache: path11.join(env.XDG_CACHE_HOME || path11.join(homedir, ".cache"), name),
-    log: path11.join(env.XDG_STATE_HOME || path11.join(homedir, ".local", "state"), name),
-    temp: path11.join(tmpdir, username, name)
+    data: path13.join(env.XDG_DATA_HOME || path13.join(homedir, ".local", "share"), name),
+    config: path13.join(env.XDG_CONFIG_HOME || path13.join(homedir, ".config"), name),
+    cache: path13.join(env.XDG_CACHE_HOME || path13.join(homedir, ".cache"), name),
+    log: path13.join(env.XDG_STATE_HOME || path13.join(homedir, ".local", "state"), name),
+    temp: path13.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -50907,17 +51913,17 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
   if (suffix) {
     name += `-${suffix}`;
   }
-  if (process2.platform === "darwin") {
+  if (process3.platform === "darwin") {
     return macos(name);
   }
-  if (process2.platform === "win32") {
+  if (process3.platform === "win32") {
     return windows(name);
   }
   return linux(name);
 }
 
 // node_modules/atomically/dist/index.js
-import path13 from "node:path";
+import path15 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
 import fs10 from "node:fs";
@@ -50998,7 +52004,7 @@ var retryifySync = (fn, options) => {
 var retryify_sync_default = retryifySync;
 
 // node_modules/stubborn-fs/dist/constants.js
-import process3 from "node:process";
+import process4 from "node:process";
 
 // node_modules/stubborn-fs/dist/handlers.js
 var Handlers = {
@@ -51042,7 +52048,7 @@ var ATTEMPTIFY_NOOP_OPTIONS = {
     return;
   }
 };
-var IS_USER_ROOT = process3.getuid ? !process3.getuid() : false;
+var IS_USER_ROOT = process4.getuid ? !process4.getuid() : false;
 var RETRYIFY_OPTIONS = {
   isRetriable: handlers_default.isRetriableError
 };
@@ -51090,16 +52096,16 @@ var FS = {
 var dist_default = FS;
 
 // node_modules/atomically/dist/constants.js
-import process4 from "node:process";
+import process5 from "node:process";
 var DEFAULT_ENCODING = "utf8";
 var DEFAULT_FILE_MODE = 438;
 var DEFAULT_FOLDER_MODE = 511;
 var DEFAULT_WRITE_OPTIONS = {};
-var DEFAULT_USER_UID = process4.geteuid ? process4.geteuid() : -1;
-var DEFAULT_USER_GID = process4.getegid ? process4.getegid() : -1;
+var DEFAULT_USER_UID = process5.geteuid ? process5.geteuid() : -1;
+var DEFAULT_USER_GID = process5.getegid ? process5.getegid() : -1;
 var DEFAULT_TIMEOUT_SYNC = 1000;
-var IS_POSIX = !!process4.getuid;
-var IS_USER_ROOT2 = process4.getuid ? !process4.getuid() : false;
+var IS_POSIX = !!process5.getuid;
+var IS_USER_ROOT2 = process5.getuid ? !process5.getuid() : false;
 var LIMIT_BASENAME_LENGTH = 128;
 
 // node_modules/atomically/dist/utils/lang.js
@@ -51114,15 +52120,15 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path12 from "node:path";
+import path14 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
-import process6 from "node:process";
+import process7 from "node:process";
 
 // node_modules/when-exit/dist/node/constants.js
-import process5 from "node:process";
-var IS_LINUX = process5.platform === "linux";
-var IS_WINDOWS = process5.platform === "win32";
+import process6 from "node:process";
+var IS_LINUX = process6.platform === "linux";
+var IS_WINDOWS = process6.platform === "win32";
 
 // node_modules/when-exit/dist/node/signals.js
 var Signals = ["SIGHUP", "SIGINT", "SIGTERM"];
@@ -51148,17 +52154,17 @@ class Interceptor {
       }
       if (signal) {
         if (IS_WINDOWS && (signal !== "SIGINT" && signal !== "SIGTERM" && signal !== "SIGKILL")) {
-          process6.kill(process6.pid, "SIGTERM");
+          process7.kill(process7.pid, "SIGTERM");
         } else {
-          process6.kill(process6.pid, signal);
+          process7.kill(process7.pid, signal);
         }
       }
     };
     this.hook = () => {
-      process6.once("exit", () => this.exit());
+      process7.once("exit", () => this.exit());
       for (const signal of signals_default) {
         try {
-          process6.once(signal, () => this.exit(signal));
+          process7.once(signal, () => this.exit(signal));
         } catch {}
       }
     };
@@ -51214,7 +52220,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path12.basename(filePath);
+    const basename = path14.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -51256,7 +52262,7 @@ function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path13.dirname(filePath);
+      const parentPath = path15.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -51572,7 +52578,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path14.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path16.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -51583,7 +52589,7 @@ class Conf {
     }
     this._validate(store);
     try {
-      assert.deepEqual(fileStore, store);
+      assert3.deepEqual(fileStore, store);
     } catch {
       this.store = store;
     }
@@ -51746,7 +52752,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs11.mkdirSync(path14.dirname(this.path), { recursive: true });
+    fs11.mkdirSync(path16.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -51756,7 +52762,7 @@ class Conf {
       const cipher = crypto.createCipheriv(encryptionAlgorithm, password, initializationVector);
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
-    if (process7.env.SNAP) {
+    if (process8.env.SNAP) {
       fs11.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
@@ -51775,7 +52781,7 @@ class Conf {
     if (!fs11.existsSync(this.path)) {
       this._write(createPlainObject());
     }
-    if (process7.platform === "win32") {
+    if (process8.platform === "win32") {
       fs11.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
@@ -51918,12 +52924,12 @@ function jwtDecode(token, options) {
 // lib/cli-config/index.ts
 import fs13 from "node:fs";
 import os3 from "node:os";
-import path16 from "node:path";
+import path18 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
 import fs12 from "node:fs";
 import os2 from "node:os";
-import path15 from "node:path";
+import path17 from "node:path";
 var AUTH_TOKEN_REGEX = /^\/\/npm\.tscircuit\.com\/:_authToken=(.+)$/m;
 function isUnauthorizedError(error) {
   const output = [
@@ -51956,8 +52962,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path15.join(projectDir, ".npmrc"),
-    path15.join(os2.homedir(), ".npmrc")
+    path17.join(projectDir, ".npmrc"),
+    path17.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -51980,8 +52986,8 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path16.join(process.cwd(), ".npmrc"),
-    path16.join(os3.homedir(), ".npmrc")
+    path18.join(process.cwd(), ".npmrc"),
+    path18.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
     if (!fs13.existsSync(npmrcPath))
@@ -52024,8 +53030,8 @@ var getCircuitJsonToGltfOptions = ({
 };
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path17 from "node:path";
-import { pathToFileURL as pathToFileURL3 } from "node:url";
+import path19 from "node:path";
+import { pathToFileURL as pathToFileURL5 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys = [
     "model_glb_url",
@@ -52049,9 +53055,9 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.match(/^[a-zA-Z]+:\/\//))
           continue;
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
-          updated[key] = pathToFileURL3(value).href;
+          updated[key] = pathToFileURL5(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL3(path17.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL5(path19.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -52092,12 +53098,12 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   for (const simulationSvgAsset of simulationSvgAssets) {
     if (imageFormats.simulationSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation.svg";
-      fs14.writeFileSync(path18.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
+      fs14.writeFileSync(path20.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
       simulationFileNames.push(fileName);
     }
     if (imageFormats.simulationSchematicSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-schematic-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation-schematic.svg";
-      fs14.writeFileSync(path18.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
+      fs14.writeFileSync(path20.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
       schematicSimulationFileNames.push(fileName);
     }
   }
@@ -52107,7 +53113,7 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs14.mkdirSync(path18.dirname(glbOutputPath), { recursive: true });
+  fs14.mkdirSync(path20.dirname(glbOutputPath), { recursive: true });
   fs14.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
@@ -52117,7 +53123,7 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs14.mkdirSync(path18.dirname(stepOutputPath), { recursive: true });
+  fs14.mkdirSync(path20.dirname(stepOutputPath), { recursive: true });
   fs14.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
@@ -52126,30 +53132,30 @@ var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const hasSchematic = circuitJson.some((e) => e.type.startsWith("schematic_"));
   if (!hasSchematic) {
     if (imageFormats.schematicSvgs)
-      fs14.rmSync(path18.join(outputDir, "schematic.svg"), { force: true });
+      fs14.rmSync(path20.join(outputDir, "schematic.svg"), { force: true });
     if (imageFormats.schematicPngs)
-      fs14.rmSync(path18.join(outputDir, "schematic.png"), { force: true });
+      fs14.rmSync(path20.join(outputDir, "schematic.png"), { force: true });
   }
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs14.writeFileSync(path18.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs14.writeFileSync(path20.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs14.writeFileSync(path18.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs14.writeFileSync(path20.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs && hasSchematic) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs14.writeFileSync(path18.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs14.writeFileSync(path20.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   if (imageFormats.schematicPngs && hasSchematic) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs14.writeFileSync(path18.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
+    fs14.writeFileSync(path20.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await render3dThumbnail(circuitJson);
-    fs14.writeFileSync(path18.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs14.writeFileSync(path20.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
@@ -52163,7 +53169,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const warnings = [];
   const startedAt = options?.profile ? performance.now() : 0;
   try {
-    workerLog(`Generating circuit JSON for ${path19.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path21.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders(undefined, projectDir);
     const projectConfig = await loadRuntimeProjectConfig(projectDir);
     const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
@@ -52187,9 +53193,9 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs15.mkdirSync(path19.dirname(outputPath), { recursive: true });
+    fs15.mkdirSync(path21.dirname(outputPath), { recursive: true });
     fs15.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path19.relative(projectDir, outputPath)}`);
+    workerLog(`Circuit JSON written to ${path21.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -52219,7 +53225,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path19.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path21.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -52230,7 +53236,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path19.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path21.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -52241,8 +53247,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path19.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path19.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path21.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path21.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,