@tscircuit/cli 0.1.2401 → 0.1.2402

package/dist/cli/snapshot/snapshot.worker.js

@@ -20336,7 +20336,7 @@ var require_dist2 = __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;
@@ -20401,7 +20401,7 @@ var require_dist2 = __commonJS(function(exports, module) {
           base = m[0];
           previous = "";
           if (isWindows && !knownHard[base]) {
-            fs2.lstatSync(base);
+            fs3.lstatSync(base);
             knownHard[base] = true;
           }
         }
@@ -20419,7 +20419,7 @@ var require_dist2 = __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)
@@ -20434,8 +20434,8 @@ var require_dist2 = __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)
@@ -20472,7 +20472,7 @@ var require_dist2 = __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;
@@ -20500,7 +20500,7 @@ var require_dist2 = __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)
@@ -20517,10 +20517,10 @@ var require_dist2 = __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);
@@ -20550,9 +20550,9 @@ var require_dist2 = __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();
@@ -20590,12 +20590,12 @@ var require_dist2 = __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;
       }
     }
   });
@@ -20821,8 +20821,8 @@ var require_dist2 = __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();
@@ -21313,8 +21313,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);
@@ -21404,8 +21404,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;
@@ -21459,7 +21459,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);
@@ -21468,13 +21468,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") {
@@ -21557,30 +21557,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));
         });
       }
     }
@@ -21594,7 +21594,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();
@@ -21724,7 +21724,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);
           }
@@ -21873,9 +21873,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 += "/";
           }
@@ -22062,7 +22062,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();
@@ -22345,7 +22345,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);
           }
@@ -22532,9 +22532,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 += "/";
           }
@@ -22627,12 +22627,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) {
@@ -22645,12 +22660,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,
@@ -22663,24 +22672,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;
   };
@@ -22691,7 +22693,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(`,
 `) + `
 }`;
       }
@@ -22700,12 +22702,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 {
@@ -22718,25 +22720,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}`);
   };
@@ -22815,7 +22802,7 @@ function convertCircuitJsonToPcbSvg(elements, options = {}) {
 
 // lib/shared/process-snapshot-file.ts
 import fs10 from "node:fs";
-import path9 from "node:path";
+import path11 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -23236,8 +23223,8 @@ var readCurrentCircuitJsonBuild = ({
 
 // lib/shared/generate-circuit-json.tsx
 import fs7 from "node:fs";
-import path7 from "node:path";
-import { pathToFileURL } from "node:url";
+import path9 from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 import Debug from "debug";
 
 // lib/utils/abbreviate-stringify-object.ts
@@ -23933,36 +23920,1045 @@ function attachAutoroutingArtifacts(root, filePath, projectDir = process.cwd())
 
 // lib/shared/importFromUserLand.ts
 import { createRequire as createRequire3 } from "node:module";
+import path6 from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+
+// node_modules/import-meta-resolve/lib/resolve.js
+import assert2 from "node:assert";
+import { statSync, realpathSync } from "node:fs";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } 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 = createRequire3(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 statSync(path);
+  } catch {}
+}
+function fileExists(url) {
+  const stats = statSync(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 = pathToFileURL(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 = pathToFileURL(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 = pathToFileURL(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 = createRequire3(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 [
+    pathToFileURL2(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 = pathToFileURL2(createRequire3(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",
@@ -23989,7 +24985,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");
   }
@@ -23997,7 +24993,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];
 };
@@ -24011,7 +25007,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;
@@ -24043,8 +25039,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: {
@@ -24061,7 +25057,7 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
 
 // lib/shared/solver-diagnostics.ts
 import fs6 from "node:fs";
-import path6 from "node:path";
+import path8 from "node:path";
 var escapeJsonPointerSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
 var cloneAsJson = (value, ancestors = new WeakMap, path = "#") => {
   if (value === undefined)
@@ -24162,7 +25158,7 @@ class SolverDiagnostics {
   finalize() {
     if (!this.options.enabled)
       return;
-    fs6.mkdirSync(path6.dirname(this.options.outputPath), { recursive: true });
+    fs6.mkdirSync(path8.dirname(this.options.outputPath), { recursive: true });
     fs6.writeFileSync(this.options.outputPath, `${JSON.stringify({
       format: "tscircuit_solver_debug_v1",
       entrypoint: this.options.entrypoint,
@@ -24206,7 +25202,7 @@ async function generateCircuitJson({
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
   const currentSourceFilesystemMd5Hash = sourceFilesystemMd5Hash ?? getSourceFilesystemMd5Hash(filePath);
-  const projectRootDir = path7.resolve(projectDirOption ?? process.cwd());
+  const projectRootDir = path9.resolve(projectDirOption ?? process.cwd());
   const React = await importFromUserLand("react", projectRootDir);
   globalThis.React = React;
   registerStaticAssetLoaders(platformConfig, projectRootDir);
@@ -24219,12 +25215,12 @@ async function generateCircuitJson({
   const solverDiagnostics = solverDiagnosticsOptions ? new SolverDiagnostics(solverDiagnosticsOptions) : null;
   solverDiagnostics?.attachToRootCircuit(runner);
   attachAutoroutingArtifacts(runner, filePath, projectRootDir);
-  const absoluteFilePath = path7.isAbsolute(filePath) ? filePath : path7.resolve(projectRootDir, filePath);
-  const sourceDir = path7.dirname(absoluteFilePath);
+  const absoluteFilePath = path9.isAbsolute(filePath) ? filePath : path9.resolve(projectRootDir, filePath);
+  const sourceDir = path9.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? sourceDir;
-  const relativeComponentPath = path7.relative(sourceDir, absoluteFilePath);
-  const baseFileName = outputFileName || path7.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path7.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path9.relative(sourceDir, absoluteFilePath);
+  const baseFileName = outputFileName || path9.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path9.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${sourceDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -24244,7 +25240,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path7.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path9.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -24252,32 +25248,41 @@ async function generateCircuitJson({
     })
   };
   debug(`fsMap: ${abbreviateStringifyObject(fsMap)}`);
-  const MainComponent = await import(pathToFileURL(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(pathToFileURL3(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}`);
@@ -24286,7 +25291,8 @@ async function generateCircuitJson({
   return {
     circuitJson,
     outputPath,
-    rootCircuit: runner
+    rootCircuit: runner,
+    modeling
   };
 }
 
@@ -24317,7 +25323,7 @@ var getOrGenerateCircuitJson = async (options) => {
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash as createHash3 } from "node:crypto";
 import fs8 from "node:fs";
-import path8 from "node:path";
+import path10 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
 
 // lib/shared/platform-config-utils.ts
@@ -24378,13 +25384,13 @@ var getPlatformFetch = (upstreamFetch = globalThis.fetch) => {
 };
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
-function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path10.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 = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        const filePath = path10.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
         return fs8.readFileSync(filePath, "utf-8");
       } catch {
         return null;
@@ -24395,7 +25401,7 @@ function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit
         fs8.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        const filePath = path10.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
         fs8.writeFileSync(filePath, value);
       } catch {}
     }
@@ -24404,7 +25410,7 @@ function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit
 function getPlatformConfigWithCliDefaults(userConfig, options) {
   const projectDir = options?.projectDir ?? process.cwd();
   const basePlatformConfig = getPlatformConfig();
-  const cacheDir = path8.join(projectDir, ".tscircuit", "cache");
+  const cacheDir = path10.join(projectDir, ".tscircuit", "cache");
   const defaultConfig = {
     ...basePlatformConfig,
     checkAvailability: true,
@@ -24415,14 +25421,14 @@ function getPlatformConfigWithCliDefaults(userConfig, options) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path8.resolve(projectDir, url);
+            const absolutePath = path10.resolve(projectDir, url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
             if (fs8.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path8.resolve(projectDir, relativePath);
+              const absolutePath = path10.resolve(projectDir, relativePath);
               if (fs8.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
@@ -24559,7 +25565,7 @@ var processSnapshotFile = async ({
   cameraPreset,
   pcbLayer
 }) => {
-  const relativeFilePath = path9.relative(projectDir, file);
+  const relativeFilePath = path11.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -24655,11 +25661,11 @@ var processSnapshotFile = async ({
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-        const fileDir = path9.dirname(file);
-        const relativeDir = path9.relative(projectDir, fileDir);
-        const snapDir = snapshotsDirName ? path9.join(projectDir, snapshotsDirName, relativeDir) : path9.join(fileDir, "__snapshots__");
-        const base = path9.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path9.join(snapDir, `${base}-3d.snap.png`);
+        const fileDir = path11.dirname(file);
+        const relativeDir = path11.relative(projectDir, fileDir);
+        const snapDir = snapshotsDirName ? path11.join(projectDir, snapshotsDirName, relativeDir) : path11.join(fileDir, "__snapshots__");
+        const base = path11.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path11.join(snapDir, `${base}-3d.snap.png`);
         const existing3dSnapshot = fs10.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
@@ -24671,7 +25677,7 @@ var processSnapshotFile = async ({
             errorMessage: kleur_default.red(`
 ❌ Failed to generate 3D snapshot for ${relativeFilePath}:
 `) + kleur_default.red(`   No pcb_board found in circuit JSON
-`) + kleur_default.red(`   Existing snapshot: ${path9.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path11.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -24692,9 +25698,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path9.join(projectDir, snapshotsDirName, path9.relative(projectDir, path9.dirname(file))) : path9.join(path9.dirname(file), "__snapshots__");
+  const snapDir = snapshotsDirName ? path11.join(projectDir, snapshotsDirName, path11.relative(projectDir, path11.dirname(file))) : path11.join(path11.dirname(file), "__snapshots__");
   fs10.mkdirSync(snapDir, { recursive: true });
-  const base = path9.basename(file).replace(/\.[^.]+$/, "");
+  const base = path11.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (!simulationOnly && (pcbOnly || !schematicOnly)) {
     let pcbSnapshotType = "pcb";
@@ -24735,13 +25741,13 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path9.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const snapPath = path11.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
     const existing = fs10.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
       fs10.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path9.relative(projectDir, snapPath));
+      successPaths.push(path11.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
@@ -24759,16 +25765,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal) {
-        successPaths.push(path9.relative(projectDir, snapPath));
+        successPaths.push(path11.relative(projectDir, snapPath));
       } else {
         fs10.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path9.relative(projectDir, snapPath));
+        successPaths.push(path11.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path9.relative(projectDir, snapPath));
+      successPaths.push(path11.relative(projectDir, snapPath));
     }
   }
   return {
@@ -24782,8 +25788,8 @@ var processSnapshotFile = async ({
 
 // lib/project-config/index.ts
 import * as fs11 from "node:fs";
-import * as path10 from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
+import * as path12 from "node:path";
+import { pathToFileURL as pathToFileURL4 } from "node:url";
 
 // lib/project-config/project-config-schema.ts
 import { z } from "zod";
@@ -24883,7 +25889,7 @@ var stripWrappingQuotes = (value) => {
 var loadProjectEnv = (projectDir) => {
   const initialEnvKeys = new Set(Object.keys(process.env));
   for (const envFileName of ENV_FILENAMES) {
-    const envPath = path10.join(projectDir, envFileName);
+    const envPath = path12.join(projectDir, envFileName);
     if (!fs11.existsSync(envPath))
       continue;
     const envContent = fs11.readFileSync(envPath, "utf8");
@@ -24904,7 +25910,7 @@ var loadProjectEnv = (projectDir) => {
   }
 };
 var loadProjectConfigSync = (projectDir = process.cwd(), options = {}) => {
-  const configPath = path10.join(projectDir, CONFIG_FILENAME);
+  const configPath = path12.join(projectDir, CONFIG_FILENAME);
   if (!fs11.existsSync(configPath)) {
     return null;
   }
@@ -24922,11 +25928,11 @@ var loadProjectConfigSync = (projectDir = process.cwd(), options = {}) => {
 var loadProjectConfigModule = async (projectDir, options = {}) => {
   loadProjectEnv(projectDir);
   for (const configFileName of CONFIG_MODULE_FILENAMES) {
-    const configPath = path10.join(projectDir, configFileName);
+    const configPath = path12.join(projectDir, configFileName);
     if (!fs11.existsSync(configPath))
       continue;
     try {
-      const moduleUrl = pathToFileURL2(configPath);
+      const moduleUrl = pathToFileURL4(configPath);
       const stat = fs11.statSync(configPath);
       moduleUrl.searchParams.set("tsci", String(stat.mtimeMs));
       const importedModule = await import(moduleUrl.href);
@@ -24983,7 +25989,7 @@ var getSnapshotsDir = (projectDir = process.cwd()) => {
   return config?.snapshotsDir;
 };
 var saveProjectConfig = (config, projectDir = process.cwd()) => {
-  const configPath = path10.join(projectDir, CONFIG_FILENAME);
+  const configPath = path12.join(projectDir, CONFIG_FILENAME);
   try {
     const configWithSchema = {
       $schema: CONFIG_SCHEMA_URL,