@tscircuit/cli 0.1.1194 → 0.1.1195

package/dist/cli/main.js

@@ -95346,18 +95346,18 @@ globstar while`, file, fr3, pattern, pr3, swallowee);
           abs = abs.replace(/\\/g, "/");
         return abs;
       }
-      function isIgnored(self2, path47) {
+      function isIgnored(self2, path48) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return item.matcher.match(path47) || !!(item.gmatcher && item.gmatcher.match(path47));
+          return item.matcher.match(path48) || !!(item.gmatcher && item.gmatcher.match(path48));
         });
       }
-      function childrenIgnored(self2, path47) {
+      function childrenIgnored(self2, path48) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return !!(item.gmatcher && item.gmatcher.match(path47));
+          return !!(item.gmatcher && item.gmatcher.match(path48));
         });
       }
     }
@@ -99964,7 +99964,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1193";
+var version = "0.1.1194";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -239559,6 +239559,7 @@ react/cjs/react-jsx-runtime.development.js:
 */
 
 // cli/check/routing-difficulty/register.ts
+import path42 from "node:path";
 var checkRoutingDifficulty = async (file) => {
   const resolvedInputFilePath = await resolveCheckInputFilePath(file);
   const circuitJson = await getCircuitJsonForCheck({
@@ -239570,7 +239571,11 @@ var checkRoutingDifficulty = async (file) => {
     allowPrebuiltCircuitJson: true
   });
   const analysis = await analyzeRouting(circuitJson);
-  return analysis.getString();
+  const result = analysis.getString();
+  if (!result) {
+    return `No congested regions in ${path42.basename(resolvedInputFilePath)}`;
+  }
+  return result;
 };
 var registerCheckRoutingDifficulty = (program2) => {
   program2.commands.find((c3) => c3.name() === "check").command("routing-difficulty").description("Analyze routing difficulty").argument("[file]", "Path to the entry file").action(async (file) => {
@@ -239593,25 +239598,25 @@ var registerCheckRouting = (program2) => {
 
 // cli/clone/register.ts
 import * as fs43 from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 
 // cli/clone/clone-bug-report.ts
 var import_jszip3 = __toESM2(require_lib4(), 1);
 var import_prompts4 = __toESM2(require_prompts3(), 1);
 import * as fs42 from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 
 // cli/clone/handle-existing-directory.ts
 var import_prompts3 = __toESM2(require_prompts3(), 1);
 import * as fs41 from "node:fs";
-import * as path42 from "node:path";
+import * as path43 from "node:path";
 var handleExistingDirectory = async (dirPath) => {
   if (!fs41.existsSync(dirPath))
     return;
   const response = await import_prompts3.default({
     type: "select",
     name: "action",
-    message: `Directory "${path42.basename(dirPath)}" already exists. What would you like to do?`,
+    message: `Directory "${path43.basename(dirPath)}" already exists. What would you like to do?`,
     choices: [
       { title: "Merge files into existing directory", value: "merge" },
       {
@@ -239652,12 +239657,12 @@ var getCommonDirectoryPrefix = (paths) => {
   return commonSegments.join("/");
 };
 var sanitizeRelativePath = (relativePath) => {
-  const normalizedPath = path43.normalize(relativePath);
+  const normalizedPath = path44.normalize(relativePath);
   if (!normalizedPath)
     return null;
-  if (path43.isAbsolute(normalizedPath))
+  if (path44.isAbsolute(normalizedPath))
     return null;
-  const segments = normalizedPath.split(path43.sep);
+  const segments = normalizedPath.split(path44.sep);
   if (segments.some((segment2) => segment2 === ".." || segment2 === "")) {
     return null;
   }
@@ -239672,7 +239677,7 @@ var cloneBugReport = async ({
     console.error("Bug report ID must not be empty.");
     process.exit(1);
   }
-  let dirPath = path43.resolve(`bug-report-${trimmedBugReportId}`);
+  let dirPath = path44.resolve(`bug-report-${trimmedBugReportId}`);
   await handleExistingDirectory(dirPath);
   const ky3 = getRegistryApiKy();
   let zipBuffer;
@@ -239702,25 +239707,25 @@ var cloneBugReport = async ({
       console.warn(`Skipping potentially unsafe path: ${fileName}`);
       continue;
     }
-    const fullPath = path43.join(dirPath, sanitizedRelativePath);
-    fs42.mkdirSync(path43.dirname(fullPath), { recursive: true });
+    const fullPath = path44.join(dirPath, sanitizedRelativePath);
+    fs42.mkdirSync(path44.dirname(fullPath), { recursive: true });
     const fileContent = await entry.async("nodebuffer");
     fs42.writeFileSync(fullPath, fileContent);
   }
-  const packageJsonPath = path43.join(dirPath, "package.json");
+  const packageJsonPath = path44.join(dirPath, "package.json");
   if (fs42.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs42.readFileSync(packageJsonPath, "utf-8"));
       const packageName = packageJson?.name;
       if (typeof packageName === "string" && packageName.trim()) {
         const sanitizedName = packageName.replace(/[^a-zA-Z0-9]/g, "_");
-        const suggestedDirPath = path43.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
+        const suggestedDirPath = path44.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
         if (suggestedDirPath !== dirPath) {
           const response = await import_prompts4.default({
             type: "confirm",
             name: "rename",
             initial: true,
-            message: `Rename the directory to "${path43.basename(suggestedDirPath)}"?`
+            message: `Rename the directory to "${path44.basename(suggestedDirPath)}"?`
           });
           if (response.rename) {
             await handleExistingDirectory(suggestedDirPath);
@@ -239733,9 +239738,9 @@ var cloneBugReport = async ({
       console.warn("Unable to read package name for renaming:", error);
     }
   }
-  fs42.writeFileSync(path43.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+  fs42.writeFileSync(path44.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
   generateTsConfig(dirPath);
-  const relativeDirPath = path43.relative(originalCwd, dirPath);
+  const relativeDirPath = path44.relative(originalCwd, dirPath);
   console.log(kleur_default.green(`
 Successfully cloned bug report to:`));
   console.log(`  ${dirPath}/
@@ -239774,7 +239779,7 @@ var registerClone = (program2) => {
     const [, author, packageName] = match;
     console.log(`Cloning ${author}/${packageName}...`);
     const userSettingToIncludeAuthor = options.includeAuthor || cliConfig.get("alwaysCloneWithAuthorName");
-    const dirPath = userSettingToIncludeAuthor ? path44.resolve(`${author}.${packageName}`) : path44.resolve(packageName);
+    const dirPath = userSettingToIncludeAuthor ? path45.resolve(`${author}.${packageName}`) : path45.resolve(packageName);
     await handleExistingDirectory(dirPath);
     const ky3 = getRegistryApiKy();
     let packageFileList = {
@@ -239800,8 +239805,8 @@ var registerClone = (program2) => {
       const filePath = fileInfo.file_path.replace(/^\/+/, "");
       if (!filePath)
         continue;
-      const fullPath = path44.join(dirPath, filePath);
-      fs43.mkdirSync(path44.dirname(fullPath), { recursive: true });
+      const fullPath = path45.join(dirPath, filePath);
+      fs43.mkdirSync(path45.dirname(fullPath), { recursive: true });
       try {
         const fileContent = await ky3.get("package_files/get", {
           searchParams: {
@@ -239827,10 +239832,10 @@ var registerClone = (program2) => {
         console.warn(`Skipping ${filePath} due to error:`, error instanceof Error ? error.message : error);
       }
     }
-    fs43.writeFileSync(path44.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+    fs43.writeFileSync(path45.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
     generateTsConfig(dirPath);
     await setupTsciProject(dirPath);
-    const relativeDirPath = path44.relative(originalCwd, dirPath);
+    const relativeDirPath = path45.relative(originalCwd, dirPath);
     console.log(kleur_default.green(`
 Successfully cloned to:`));
     console.log(`  ${dirPath}/
@@ -239898,7 +239903,7 @@ var registerConfigSet = (program2) => {
 
 // cli/convert/register.ts
 import fs44 from "node:fs/promises";
-import path45 from "node:path";
+import path46 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -240019,14 +240024,14 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program2) => {
   program2.command("convert").description("Convert a .kicad_mod footprint to a tscircuit component").argument("<file>", "Path to the .kicad_mod file").option("-o, --output <path>", "Output TSX file path").option("-n, --name <component>", "Component name for export").action(async (file, options) => {
     try {
-      const inputPath = path45.resolve(file);
+      const inputPath = path46.resolve(file);
       const modContent = await fs44.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path45.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path46.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path45.resolve(options.output) : path45.join(path45.dirname(inputPath), `${componentName}.tsx`);
+      const outputPath = options.output ? path46.resolve(options.output) : path46.join(path46.dirname(inputPath), `${componentName}.tsx`);
       await fs44.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
@@ -240039,11 +240044,11 @@ var registerConvert = (program2) => {
 // cli/dev/register.ts
 import * as fs51 from "node:fs";
 import * as net from "node:net";
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 
 // cli/dev/DevServer.ts
 import fs49 from "node:fs";
-import path51 from "node:path";
+import path52 from "node:path";
 
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -240122,7 +240127,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path46) => statMethod(path46, { bigint: true });
+      this._stat = (path47) => statMethod(path47, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -240147,8 +240152,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path46, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path46));
+          const { path: path47, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path47));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -240188,20 +240193,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path46, depth) {
+  async _exploreDir(path47, depth) {
     let files;
     try {
-      files = await readdir(path46, this._rdOptions);
+      files = await readdir(path47, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path46 };
+    return { files, depth, path: path47 };
   }
-  async _formatEntry(dirent, path46) {
+  async _formatEntry(dirent, path47) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path46, basename4));
+      const fullPath = presolve(pjoin(path47, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -240599,16 +240604,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path46, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path47, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path46);
-    emitRaw(rawEvent, evPath, { watchedPath: path46 });
-    if (evPath && path46 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path46, evPath), KEY_LISTENERS, sysPath.join(path46, evPath));
+    listener(path47);
+    emitRaw(rawEvent, evPath, { watchedPath: path47 });
+    if (evPath && path47 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path47, evPath), KEY_LISTENERS, sysPath.join(path47, evPath));
     }
   };
   try {
-    return fs_watch(path46, {
+    return fs_watch(path47, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -240624,12 +240629,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path46, fullPath, options, handlers) => {
+var setFsWatchListener = (path47, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path46, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path47, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -240639,7 +240644,7 @@ var setFsWatchListener = (path46, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path46, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path47, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -240648,7 +240653,7 @@ var setFsWatchListener = (path46, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd3 = await open(path46, "r");
+          const fd3 = await open(path47, "r");
           await fd3.close();
           broadcastErr(error);
         } catch (err) {}
@@ -240678,7 +240683,7 @@ var setFsWatchListener = (path46, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path46, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path47, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -240700,7 +240705,7 @@ var setFsWatchFileListener = (path46, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path46, curr));
+          foreach(cont.listeners, (listener2) => listener2(path47, curr));
         }
       })
     };
@@ -240723,13 +240728,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path46, listener) {
+  _watchWithNodeFs(path47, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path46);
-    const basename5 = sysPath.basename(path46);
+    const directory = sysPath.dirname(path47);
+    const basename5 = sysPath.basename(path47);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sysPath.resolve(path46);
+    const absolutePath = sysPath.resolve(path47);
     const options = {
       persistent: opts.persistent
     };
@@ -240739,12 +240744,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path46, absolutePath, options, {
+      closer = setFsWatchFileListener(path47, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path46, absolutePath, options, {
+      closer = setFsWatchListener(path47, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -240762,7 +240767,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path46, newStats) => {
+    const listener = async (path47, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -240776,11 +240781,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path46);
+            this.fsw._closeFile(path47);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path46, closer2);
+              this.fsw._addPathCloser(path47, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -240804,7 +240809,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path46, item) {
+  async _handleSymlink(entry, directory, path47, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -240814,7 +240819,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path46);
+        linkPath = await fsrealpath(path47);
       } catch (e4) {
         this.fsw._emitReady();
         return true;
@@ -240824,12 +240829,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path46, entry.stats);
+          this.fsw._emit(EV.CHANGE, path47, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path46, entry.stats);
+        this.fsw._emit(EV.ADD, path47, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -240858,9 +240863,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path46 = sysPath.join(directory, item);
+      let path47 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path46, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path47, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -240869,8 +240874,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path46 = sysPath.join(dir, sysPath.relative(dir, path46));
-        this._addToNodeFs(path46, initialAdd, wh3, depth + 1);
+        path47 = sysPath.join(dir, sysPath.relative(dir, path47));
+        this._addToNodeFs(path47, initialAdd, wh3, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve7, reject) => {
@@ -240919,13 +240924,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path46, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path47, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path46) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path47) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh3 = this.fsw._getWatchHelpers(path46);
+    const wh3 = this.fsw._getWatchHelpers(path47);
     if (priorWh) {
       wh3.filterPath = (entry) => priorWh.filterPath(entry);
       wh3.filterDir = (entry) => priorWh.filterDir(entry);
@@ -240941,8 +240946,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path46);
-        const targetPath = follow ? await fsrealpath(path46) : path46;
+        const absPath = sysPath.resolve(path47);
+        const targetPath = follow ? await fsrealpath(path47) : path47;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh3.watchPath, stats, initialAdd, depth, target, wh3, targetPath);
@@ -240952,29 +240957,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path46) : path46;
+        const targetPath = follow ? await fsrealpath(path47) : path47;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh3.watchPath);
         this.fsw._getWatchedDir(parent).add(wh3.watchPath);
         this.fsw._emit(EV.ADD, wh3.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path46, wh3, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path47, wh3, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path46), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path47), targetPath);
         }
       } else {
         closer = this._handleFile(wh3.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path46, closer);
+        this.fsw._addPathCloser(path47, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path46;
+        return path47;
       }
     }
   }
@@ -241017,26 +241022,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path46) {
-  if (typeof path46 !== "string")
+function normalizePath(path47) {
+  if (typeof path47 !== "string")
     throw new Error("string expected");
-  path46 = sysPath2.normalize(path46);
-  path46 = path46.replace(/\\/g, "/");
+  path47 = sysPath2.normalize(path47);
+  path47 = path47.replace(/\\/g, "/");
   let prepend2 = false;
-  if (path46.startsWith("//"))
+  if (path47.startsWith("//"))
     prepend2 = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path46.match(DOUBLE_SLASH_RE2))
-    path46 = path46.replace(DOUBLE_SLASH_RE2, "/");
+  while (path47.match(DOUBLE_SLASH_RE2))
+    path47 = path47.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend2)
-    path46 = "/" + path46;
-  return path46;
+    path47 = "/" + path47;
+  return path47;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path46 = normalizePath(testString);
+  const path47 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path46, stats)) {
+    if (pattern(path47, stats)) {
       return true;
     }
   }
@@ -241076,19 +241081,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path46) => toUnix(sysPath2.normalize(toUnix(path46)));
-var normalizeIgnored = (cwd = "") => (path46) => {
-  if (typeof path46 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path46) ? path46 : sysPath2.join(cwd, path46));
+var normalizePathToUnix = (path47) => toUnix(sysPath2.normalize(toUnix(path47)));
+var normalizeIgnored = (cwd = "") => (path47) => {
+  if (typeof path47 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path47) ? path47 : sysPath2.join(cwd, path47));
   } else {
-    return path46;
+    return path47;
   }
 };
-var getAbsolutePath = (path46, cwd) => {
-  if (sysPath2.isAbsolute(path46)) {
-    return path46;
+var getAbsolutePath = (path47, cwd) => {
+  if (sysPath2.isAbsolute(path47)) {
+    return path47;
   }
-  return sysPath2.join(cwd, path46);
+  return sysPath2.join(cwd, path47);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -241145,10 +241150,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path46, follow, fsw) {
+  constructor(path47, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path46;
-    this.path = path46 = path46.replace(REPLACER_RE, "");
+    const watchPath = path47;
+    this.path = path47 = path47.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -241261,20 +241266,20 @@ class FSWatcher extends EventEmitter {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path46) => {
-        const absPath = getAbsolutePath(path46, cwd);
+      paths = paths.map((path47) => {
+        const absPath = getAbsolutePath(path47, cwd);
         return absPath;
       });
     }
-    paths.forEach((path46) => {
-      this._removeIgnoredPath(path46);
+    paths.forEach((path47) => {
+      this._removeIgnoredPath(path47);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path46) => {
-      const res2 = await this._nodeFsHandler._addToNodeFs(path46, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path47) => {
+      const res2 = await this._nodeFsHandler._addToNodeFs(path47, !_internal, undefined, 0, _origAdd);
       if (res2)
         this._emitReady();
       return res2;
@@ -241293,17 +241298,17 @@ class FSWatcher extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path46) => {
-      if (!sysPath2.isAbsolute(path46) && !this._closers.has(path46)) {
+    paths.forEach((path47) => {
+      if (!sysPath2.isAbsolute(path47) && !this._closers.has(path47)) {
         if (cwd)
-          path46 = sysPath2.join(cwd, path46);
-        path46 = sysPath2.resolve(path46);
+          path47 = sysPath2.join(cwd, path47);
+        path47 = sysPath2.resolve(path47);
       }
-      this._closePath(path46);
-      this._addIgnoredPath(path46);
-      if (this._watched.has(path46)) {
+      this._closePath(path47);
+      this._addIgnoredPath(path47);
+      if (this._watched.has(path47)) {
         this._addIgnoredPath({
-          path: path46,
+          path: path47,
           recursive: true
         });
       }
@@ -241352,38 +241357,38 @@ class FSWatcher extends EventEmitter {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, ...args);
   }
-  async _emit(event, path46, stats) {
+  async _emit(event, path47, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path46 = sysPath2.normalize(path46);
+      path47 = sysPath2.normalize(path47);
     if (opts.cwd)
-      path46 = sysPath2.relative(opts.cwd, path46);
-    const args = [event, path46];
+      path47 = sysPath2.relative(opts.cwd, path47);
+    const args = [event, path47];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path46))) {
+    if (awf && (pw = this._pendingWrites.get(path47))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path46, args);
+        this._pendingUnlinks.set(path47, args);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path47) => {
+          this._pendingUnlinks.forEach((entry, path48) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path47);
+            this._pendingUnlinks.delete(path48);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path46)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path47)) {
         event = args[0] = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path46);
+        this._pendingUnlinks.delete(path47);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -241401,16 +241406,16 @@ class FSWatcher extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path46, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path47, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path46, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path47, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path46) : path46;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path47) : path47;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -241429,23 +241434,23 @@ class FSWatcher extends EventEmitter {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path46, timeout2) {
+  _throttle(actionType, path47, timeout2) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, new Map);
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path46);
+    const actionPath = action.get(path47);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path46);
+      const item = action.get(path47);
       const count = item ? item.count : 0;
-      action.delete(path46);
+      action.delete(path47);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -241453,50 +241458,50 @@ class FSWatcher extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout2);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path46, thr);
+    action.set(path47, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path46, threshold, event, awfEmit) {
+  _awaitWriteFinish(path47, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path46;
-    if (this.options.cwd && !sysPath2.isAbsolute(path46)) {
-      fullPath = sysPath2.join(this.options.cwd, path46);
+    let fullPath = path47;
+    if (this.options.cwd && !sysPath2.isAbsolute(path47)) {
+      fullPath = sysPath2.join(this.options.cwd, path47);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path46)) {
+        if (err || !writes.has(path47)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path46).lastChange = now2;
+          writes.get(path47).lastChange = now2;
         }
-        const pw = writes.get(path46);
+        const pw = writes.get(path47);
         const df3 = now2 - pw.lastChange;
         if (df3 >= threshold) {
-          writes.delete(path46);
+          writes.delete(path47);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path46)) {
-      writes.set(path46, {
+    if (!writes.has(path47)) {
+      writes.set(path47, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path46);
+          writes.delete(path47);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -241504,8 +241509,8 @@ class FSWatcher extends EventEmitter {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path46, stats) {
-    if (this.options.atomic && DOT_RE.test(path46))
+  _isIgnored(path47, stats) {
+    if (this.options.atomic && DOT_RE.test(path47))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -241515,13 +241520,13 @@ class FSWatcher extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path46, stats);
+    return this._userIgnored(path47, stats);
   }
-  _isntIgnored(path46, stat4) {
-    return !this._isIgnored(path46, stat4);
+  _isntIgnored(path47, stat4) {
+    return !this._isIgnored(path47, stat4);
   }
-  _getWatchHelpers(path46) {
-    return new WatchHelper(path46, this.options.followSymlinks, this);
+  _getWatchHelpers(path47) {
+    return new WatchHelper(path47, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -241535,57 +241540,57 @@ class FSWatcher extends EventEmitter {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory2) {
-    const path46 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path46);
-    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path46) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path46, 100))
+    const path47 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path47);
+    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path47) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path47, 100))
       return;
     if (!isDirectory2 && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp3 = this._getWatchedDir(path46);
+    const wp3 = this._getWatchedDir(path47);
     const nestedDirectoryChildren = wp3.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path46, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path47, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path46;
+    let relPath = path47;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path46);
+      relPath = sysPath2.relative(this.options.cwd, path47);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path46);
+    this._watched.delete(path47);
     this._watched.delete(fullPath);
     const eventName = isDirectory2 ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path46))
-      this._emit(eventName, path46);
-    this._closePath(path46);
+    if (wasTracked && !this._isIgnored(path47))
+      this._emit(eventName, path47);
+    this._closePath(path47);
   }
-  _closePath(path46) {
-    this._closeFile(path46);
-    const dir = sysPath2.dirname(path46);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path46));
+  _closePath(path47) {
+    this._closeFile(path47);
+    const dir = sysPath2.dirname(path47);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path47));
   }
-  _closeFile(path46) {
-    const closers = this._closers.get(path46);
+  _closeFile(path47) {
+    const closers = this._closers.get(path47);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path46);
+    this._closers.delete(path47);
   }
-  _addPathCloser(path46, closer) {
+  _addPathCloser(path47, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path46);
+    let list = this._closers.get(path47);
     if (!list) {
       list = [];
-      this._closers.set(path46, list);
+      this._closers.set(path47, list);
     }
     list.push(closer);
   }
@@ -241618,10 +241623,10 @@ import Debug3 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts3 from "typescript";
-import * as path46 from "path";
+import * as path47 from "path";
 import * as fs45 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path46.join(projectDir, "package.json");
+  const packageJsonPath = path47.join(projectDir, "package.json");
   const allPackages = new Set;
   if (!fs45.existsSync(packageJsonPath)) {
     return allPackages;
@@ -241642,7 +241647,7 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path46.resolve(filePath);
+  const absolutePath = path47.resolve(filePath);
   if (!fs45.existsSync(absolutePath)) {
     return [];
   }
@@ -241696,17 +241701,17 @@ function resolveNodeModuleImport({
 }) {
   const packageName = getPackageNameFromImport(importPath);
   const searchPaths = [
-    path46.join(projectDir, "node_modules", packageName)
+    path47.join(projectDir, "node_modules", packageName)
   ];
   if (searchFromDir) {
-    let currentDir = path46.dirname(searchFromDir);
-    const projectDirNormalized = path46.normalize(projectDir);
+    let currentDir = path47.dirname(searchFromDir);
+    const projectDirNormalized = path47.normalize(projectDir);
     while (currentDir.startsWith(projectDirNormalized)) {
-      const candidatePath = path46.join(currentDir, "node_modules", packageName);
+      const candidatePath = path47.join(currentDir, "node_modules", packageName);
       if (!searchPaths.includes(candidatePath)) {
         searchPaths.push(candidatePath);
       }
-      const parentDir = path46.dirname(currentDir);
+      const parentDir = path47.dirname(currentDir);
       if (parentDir === currentDir)
         break;
       currentDir = parentDir;
@@ -241722,22 +241727,22 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path46.join(packageDir, "package.json");
+  const packageJsonPath = path47.join(packageDir, "package.json");
   const hasPackageJson = fs45.existsSync(packageJsonPath);
   const packageJson = hasPackageJson ? JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8")) : null;
   const resolvedFiles = [];
   if (importPath !== packageName) {
     const subpath = importPath.slice(packageName.length + 1);
     const possiblePaths = [
-      path46.join(packageDir, subpath),
-      path46.join(packageDir, `${subpath}.js`),
-      path46.join(packageDir, `${subpath}.mjs`),
-      path46.join(packageDir, `${subpath}.ts`),
-      path46.join(packageDir, `${subpath}.tsx`),
-      path46.join(packageDir, subpath, "index.js"),
-      path46.join(packageDir, subpath, "index.mjs"),
-      path46.join(packageDir, subpath, "index.ts"),
-      path46.join(packageDir, subpath, "index.tsx")
+      path47.join(packageDir, subpath),
+      path47.join(packageDir, `${subpath}.js`),
+      path47.join(packageDir, `${subpath}.mjs`),
+      path47.join(packageDir, `${subpath}.ts`),
+      path47.join(packageDir, `${subpath}.tsx`),
+      path47.join(packageDir, subpath, "index.js"),
+      path47.join(packageDir, subpath, "index.mjs"),
+      path47.join(packageDir, subpath, "index.ts"),
+      path47.join(packageDir, subpath, "index.tsx")
     ];
     for (const p3 of possiblePaths) {
       if (fs45.existsSync(p3) && fs45.statSync(p3).isFile()) {
@@ -241772,22 +241777,22 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path46.join(packageDir, entry);
+    const entryPath = path47.join(packageDir, entry);
     if (fs45.existsSync(entryPath) && fs45.statSync(entryPath).isFile()) {
       resolvedFiles.push(entryPath);
     }
   }
   if (resolvedFiles.length === 0) {
     const fallbackPaths = [
-      path46.join(packageDir, "index.js"),
-      path46.join(packageDir, "index.mjs"),
-      path46.join(packageDir, "index.ts"),
-      path46.join(packageDir, "index.tsx"),
-      path46.join(packageDir, "dist", "index.js"),
-      path46.join(packageDir, "dist", "index.mjs"),
-      path46.join(packageDir, "lib", "index.js"),
-      path46.join(packageDir, "src", "index.ts"),
-      path46.join(packageDir, "src", "index.tsx")
+      path47.join(packageDir, "index.js"),
+      path47.join(packageDir, "index.mjs"),
+      path47.join(packageDir, "index.ts"),
+      path47.join(packageDir, "index.tsx"),
+      path47.join(packageDir, "dist", "index.js"),
+      path47.join(packageDir, "dist", "index.mjs"),
+      path47.join(packageDir, "lib", "index.js"),
+      path47.join(packageDir, "src", "index.ts"),
+      path47.join(packageDir, "src", "index.tsx")
     ];
     for (const p3 of fallbackPaths) {
       if (fs45.existsSync(p3) && fs45.statSync(p3).isFile()) {
@@ -241828,8 +241833,8 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path46.resolve(filePath);
-    const baseDir = path46.dirname(absolutePath);
+    const absolutePath = path47.resolve(filePath);
+    const baseDir = path47.dirname(absolutePath);
     if (!fs45.existsSync(absolutePath)) {
       return [];
     }
@@ -241855,7 +241860,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path46.resolve(baseDir, importPath);
+    const resolvedPath = path47.resolve(baseDir, importPath);
     if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
@@ -241867,7 +241872,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
     if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path46.join(resolvedPath, `index${ext}`);
+        const indexPath = path47.join(resolvedPath, `index${ext}`);
         if (fs45.existsSync(indexPath)) {
           return indexPath;
         }
@@ -241893,11 +241898,11 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path46.join(packageDir, dirName);
+    const dirPath = path47.join(packageDir, dirName);
     if (fs45.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path46.join(packageDir, "package.json");
+        const packageJsonPath = path47.join(packageDir, "package.json");
         if (fs45.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
@@ -241913,7 +241918,7 @@ function walkDirectory(dir, excludedDirs) {
     return files;
   const entries = fs45.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path46.join(dir, entry.name);
+    const fullPath = path47.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirs.has(entry.name)) {
         continue;
@@ -241974,10 +241979,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
       processedPackages.add(packageName);
       if (resolvedFiles.length > 0) {
         const firstResolvedFile = resolvedFiles[0];
-        let packageDir = path46.dirname(firstResolvedFile);
+        let packageDir = path47.dirname(firstResolvedFile);
         let hasPackageJson = false;
         while (packageDir.includes("node_modules")) {
-          const packageJsonPath = path46.join(packageDir, "package.json");
+          const packageJsonPath = path47.join(packageDir, "package.json");
           if (fs45.existsSync(packageJsonPath)) {
             try {
               const pkgJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
@@ -241988,10 +241993,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
             } catch {}
           }
           const expectedPackagePath = packageName.startsWith("@") ? `node_modules/${packageName}` : `node_modules/${packageName}`;
-          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path46.sep))) {
+          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path47.sep))) {
             break;
           }
-          const parentDir = path46.dirname(packageDir);
+          const parentDir = path47.dirname(packageDir);
           if (parentDir === packageDir)
             break;
           packageDir = parentDir;
@@ -242765,10 +242770,10 @@ var databaseSchema = z7.object({
   files: z7.array(fileSchema).default([]),
   events: z7.array(eventSchema).default([])
 });
-function normalizePath2(path47) {
-  if (!path47 || path47 === "/")
+function normalizePath2(path48) {
+  if (!path48 || path48 === "/")
     return "";
-  let normalized = path47.replace(/\\+/g, "/").replace(/\/\/+/, "/");
+  let normalized = path48.replace(/\\+/g, "/").replace(/\/\/+/, "/");
   if (normalized.startsWith("/")) {
     normalized = normalized.slice(1);
   }
@@ -243626,13 +243631,13 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 
 // lib/server/kicad-pcm-proxy.ts
 import * as fs46 from "node:fs";
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 var getSourceFilesChecksum = (projectDir) => {
   const sourceFiles = globbySync(["**/*.tsx", "**/*.ts", "**/*.json", "!node_modules/**", "!dist/**"], { cwd: projectDir });
   let checksum = "";
   for (const file of sourceFiles) {
     try {
-      const stat4 = fs46.statSync(path47.join(projectDir, file));
+      const stat4 = fs46.statSync(path48.join(projectDir, file));
       checksum += `${file}:${stat4.mtimeMs};`;
     } catch {}
   }
@@ -243652,9 +243657,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url2, res2) => {
     const requestedFile = url2.pathname.replace(/^\/pcm\/?/, "") || "repository.json";
-    const distDir = path47.join(projectDir, "dist");
-    const pcmDir = path47.join(distDir, "pcm");
-    const filePath = path47.join(pcmDir, requestedFile);
+    const distDir = path48.join(projectDir, "dist");
+    const pcmDir = path48.join(distDir, "pcm");
+    const filePath = path48.join(pcmDir, requestedFile);
     const currentChecksum = getSourceFilesChecksum(projectDir);
     const needsRebuild = currentChecksum !== pcmState.lastFileChecksum;
     if (needsRebuild) {
@@ -243704,7 +243709,7 @@ Rebuilding KiCad PCM assets...`));
       res2.end(`PCM file not found: ${requestedFile}`);
       return;
     }
-    const ext = path47.extname(filePath).toLowerCase();
+    const ext = path48.extname(filePath).toLowerCase();
     let contentType = "application/octet-stream";
     if (ext === ".json") {
       contentType = "application/json";
@@ -243836,7 +243841,7 @@ var createHttpServer = async ({
 // lib/shared/push-snippet.ts
 var import_semver3 = __toESM2(require_semver2(), 1);
 import * as fs48 from "node:fs";
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 import Debug2 from "debug";
 
 // lib/utils/validate-package-name.ts
@@ -243854,7 +243859,7 @@ var validatePackageName = (name) => {
 };
 
 // cli/dev/get-package-file-paths.ts
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 var getPackageFilePaths = (projectDir, ignored = []) => {
   const ignorePatterns = [
     ...DEFAULT_IGNORED_PATTERNS,
@@ -243865,7 +243870,7 @@ var getPackageFilePaths = (projectDir, ignored = []) => {
     ignore: ignorePatterns
   });
   fileNames.sort();
-  return fileNames.map((fileName) => path48.join(projectDir, fileName));
+  return fileNames.map((fileName) => path49.join(projectDir, fileName));
 };
 
 // lib/utils/check-org-access.ts
@@ -243881,7 +243886,7 @@ var checkOrgAccess = async (ky3, orgTscircuitHandle) => {
 };
 
 // lib/shared/is-binary-file.ts
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 var BINARY_FILE_EXTENSIONS = new Set([
   ".glb",
   ".gltf",
@@ -243897,7 +243902,7 @@ var BINARY_FILE_EXTENSIONS = new Set([
   ".tar"
 ]);
 var isBinaryFile = (filePath) => {
-  const ext = path49.extname(filePath).toLowerCase();
+  const ext = path50.extname(filePath).toLowerCase();
   return BINARY_FILE_EXTENSIONS.has(ext);
 };
 
@@ -243923,7 +243928,7 @@ var debug11 = Debug2("tsci:push-snippet");
 var getArchivePayload = async (filePaths, projectDir, packageNameWithVersion) => {
   const zip = new import_jszip4.default;
   for (const fullFilePath of filePaths) {
-    const relativeFilePath = path50.relative(projectDir, fullFilePath);
+    const relativeFilePath = path51.relative(projectDir, fullFilePath);
     zip.file(relativeFilePath, fs48.readFileSync(fullFilePath));
   }
   const archive = await zip.generateAsync({
@@ -243962,10 +243967,10 @@ var pushSnippet = async ({
     return onExit(1);
   }
   const packageJsonPath = [
-    path50.resolve(path50.join(path50.dirname(snippetFilePath), "package.json")),
-    path50.resolve(path50.join(process.cwd(), "package.json"))
-  ].find((path51) => fs48.existsSync(path51));
-  const projectDir = packageJsonPath ? path50.dirname(packageJsonPath) : path50.dirname(snippetFilePath);
+    path51.resolve(path51.join(path51.dirname(snippetFilePath), "package.json")),
+    path51.resolve(path51.join(process.cwd(), "package.json"))
+  ].find((path52) => fs48.existsSync(path52));
+  const projectDir = packageJsonPath ? path51.dirname(packageJsonPath) : path51.dirname(snippetFilePath);
   if (!packageJsonPath) {
     onError("No package.json found, try running 'tsci init' to bootstrap the project");
     return onExit(1);
@@ -244159,7 +244164,7 @@ var pushSnippet = async ({
         json: archivePayload
       });
       for (const fullFilePath of filePaths) {
-        const relativeFilePath = path50.relative(projectDir, fullFilePath);
+        const relativeFilePath = path51.relative(projectDir, fullFilePath);
         uploadResults.succeeded.push(relativeFilePath);
       }
       log(kleur_default.gray(`\uD83D\uDCE6 Uploaded archive with ${filePaths.length} files`));
@@ -244169,7 +244174,7 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path50.relative(projectDir, fullFilePath);
+      const relativeFilePath = path51.relative(projectDir, fullFilePath);
       const fileBuffer = fs48.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
@@ -244259,7 +244264,7 @@ class DevServer {
   }) {
     this.port = port;
     this.componentFilePath = componentFilePath;
-    this.projectDir = projectDir ?? path51.dirname(componentFilePath);
+    this.projectDir = projectDir ?? path52.dirname(componentFilePath);
     this.kicadPcm = kicadPcm ?? false;
     const projectConfig2 = loadProjectConfig(this.projectDir);
     this.ignoredFiles = projectConfig2?.ignoredFiles ?? [];
@@ -244270,7 +244275,7 @@ class DevServer {
   async start() {
     const { server } = await createHttpServer({
       port: this.port,
-      defaultMainComponentPath: path51.relative(this.projectDir, this.componentFilePath),
+      defaultMainComponentPath: path52.relative(this.projectDir, this.componentFilePath),
       kicadPcm: this.kicadPcm,
       projectDir: this.projectDir,
       entryFile: this.componentFilePath
@@ -244286,7 +244291,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p3) => shouldIgnorePath(path51.relative(this.projectDir, p3), this.ignoredFiles)
+      ignored: (p3) => shouldIgnorePath(path52.relative(this.projectDir, p3), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -244301,8 +244306,8 @@ class DevServer {
     const { file } = await this.fsKy.get("api/files/get", {
       searchParams: { file_path: ev.file_path }
     }).json();
-    const fullPath = path51.join(this.projectDir, ev.file_path);
-    const dirPath = path51.dirname(fullPath);
+    const fullPath = path52.join(this.projectDir, ev.file_path);
+    const dirPath = path52.dirname(fullPath);
     if (!fs49.existsSync(dirPath)) {
       fs49.mkdirSync(dirPath, { recursive: true });
     }
@@ -244314,14 +244319,14 @@ class DevServer {
     }
   }
   async handleFileDeletedEventFromServer(ev) {
-    const fullPath = path51.join(this.projectDir, ev.file_path);
+    const fullPath = path52.join(this.projectDir, ev.file_path);
     if (fs49.existsSync(fullPath)) {
       debug13(`Deleting file ${ev.file_path} from filesystem`);
       fs49.unlinkSync(fullPath);
     }
   }
   async handleFileChangedOnFilesystem(absoluteFilePath) {
-    const relativeFilePath = path51.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path52.relative(this.projectDir, absoluteFilePath);
     if (relativeFilePath.includes("manual-edits.json"))
       return;
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
@@ -244336,14 +244341,14 @@ class DevServer {
     await this.checkAndUploadNewNodeModules(absoluteFilePath);
   }
   async checkAndUploadNewNodeModules(filePath) {
-    const ext = path51.extname(filePath).toLowerCase();
+    const ext = path52.extname(filePath).toLowerCase();
     const isSourceFile = [".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext);
     if (!isSourceFile)
       return;
     try {
       const nodeModuleFiles = getAllNodeModuleFilePaths(filePath, this.projectDir);
       const newFiles = nodeModuleFiles.filter((file) => {
-        const relativePath = path51.relative(this.projectDir, file);
+        const relativePath = path52.relative(this.projectDir, file);
         return !this.uploadedNodeModules.has(relativePath);
       });
       if (newFiles.length === 0)
@@ -244356,7 +244361,7 @@ class DevServer {
     }
   }
   async handleFileRemovedFromFilesystem(absoluteFilePath) {
-    const relativeFilePath = path51.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path52.relative(this.projectDir, absoluteFilePath);
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
       return;
     if (!relativeFilePath || relativeFilePath.trim() === "") {
@@ -244394,8 +244399,8 @@ class DevServer {
     debug13(`Successfully deleted file ${relativeFilePath} from server`);
   }
   async handleFileRename(oldPath, newPath) {
-    const oldRelativePath = path51.relative(this.projectDir, oldPath);
-    const newRelativePath = path51.relative(this.projectDir, newPath);
+    const oldRelativePath = path52.relative(this.projectDir, oldPath);
+    const newRelativePath = path52.relative(this.projectDir, newPath);
     if (shouldIgnorePath(oldRelativePath, this.ignoredFiles) || shouldIgnorePath(newRelativePath, this.ignoredFiles))
       return;
     await this.handleFileRemovedFromFilesystem(oldPath);
@@ -244413,7 +244418,7 @@ class DevServer {
     });
     const filePaths = getPackageFilePaths(this.projectDir, this.ignoredFiles);
     for (const filePath of filePaths) {
-      const relativeFilePath = path51.relative(this.projectDir, filePath);
+      const relativeFilePath = path52.relative(this.projectDir, filePath);
       const filePayload = this.createFileUploadPayload(filePath, relativeFilePath);
       await this.postFileUpsert({
         filePath: relativeFilePath,
@@ -244445,7 +244450,7 @@ class DevServer {
   }
   async uploadNodeModuleFiles(files) {
     for (const nodeModuleFile of files) {
-      const relativeFilePath = path51.relative(this.projectDir, nodeModuleFile);
+      const relativeFilePath = path52.relative(this.projectDir, nodeModuleFile);
       this.uploadedNodeModules.add(relativeFilePath);
       const filePayload = this.createFileUploadPayload(nodeModuleFile, relativeFilePath);
       await this.postFileUpsert({
@@ -244490,7 +244495,7 @@ class DevServer {
     formData.set("file_path", filePath);
     formData.set("initiator", initiator);
     const binaryBytes = Uint8Array.from(binaryContent);
-    formData.set("binary_file", new Blob([binaryBytes]), path51.basename(filePath));
+    formData.set("binary_file", new Blob([binaryBytes]), path52.basename(filePath));
     const response = await fetch(`http://localhost:${this.port}/api/files/upsert-multipart`, {
       method: "POST",
       body: formData
@@ -244530,7 +244535,7 @@ class DevServer {
     await this.filesystemWatcher?.close();
   }
   createFileUploadPayload(absoluteFilePath, relativeFilePath) {
-    const ext = path51.extname(relativeFilePath).toLowerCase();
+    const ext = path52.extname(relativeFilePath).toLowerCase();
     if (BINARY_FILE_EXTENSIONS2.has(ext)) {
       const fileBuffer = fs49.readFileSync(absoluteFilePath);
       return { binary_content: fileBuffer };
@@ -244566,7 +244571,7 @@ class DevServer {
 
 // cli/dev/resolve-dev-target.ts
 import * as fs50 from "node:fs";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 var findSelectableFiles = (projectDir) => {
   const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs50.existsSync(file)).sort();
   if (boardFiles.length > 0) {
@@ -244576,7 +244581,7 @@ var findSelectableFiles = (projectDir) => {
     cwd: projectDir,
     ignore: DEFAULT_IGNORED_PATTERNS
   });
-  return files.map((file) => path52.resolve(projectDir, file)).filter((file) => fs50.existsSync(file)).sort();
+  return files.map((file) => path53.resolve(projectDir, file)).filter((file) => fs50.existsSync(file)).sort();
 };
 var isValidDevFile = (filePath) => {
   return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
@@ -244584,7 +244589,7 @@ var isValidDevFile = (filePath) => {
 var resolveDevTarget = async (file) => {
   let projectDir = process.cwd();
   if (file) {
-    const resolvedPath = path52.resolve(file);
+    const resolvedPath = path53.resolve(file);
     if (fs50.existsSync(resolvedPath) && fs50.statSync(resolvedPath).isDirectory()) {
       projectDir = resolvedPath;
       const availableFiles2 = findSelectableFiles(projectDir);
@@ -244592,7 +244597,7 @@ var resolveDevTarget = async (file) => {
         console.log(`No .tsx, .ts, or .circuit.json files found in ${projectDir}. Run 'tsci init' to bootstrap a basic project.`);
         return null;
       }
-      console.log("Selected file:", path52.relative(projectDir, availableFiles2[0]));
+      console.log("Selected file:", path53.relative(projectDir, availableFiles2[0]));
       return { absolutePath: availableFiles2[0], projectDir };
     }
     if (!fs50.existsSync(resolvedPath)) {
@@ -244615,7 +244620,7 @@ var resolveDevTarget = async (file) => {
     console.log("No .tsx, .ts, or .circuit.json files found in the project. Run 'tsci init' to bootstrap a basic project.");
     return null;
   }
-  console.log("Selected file:", path52.relative(projectDir, availableFiles[0]));
+  console.log("Selected file:", path53.relative(projectDir, availableFiles[0]));
   return { absolutePath: availableFiles[0], projectDir };
 };
 
@@ -244631,7 +244636,7 @@ var isPortAvailable = (port) => {
   });
 };
 var warnIfTsconfigMissingTscircuitType = (projectDir) => {
-  const tsconfigPath = path53.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path54.join(projectDir, "tsconfig.json");
   if (!fs51.existsSync(tsconfigPath)) {
     return;
   }
@@ -244668,7 +244673,7 @@ var registerDev = (program2) => {
 
   ${kleur_default.green(`@tscircuit/cli@${getVersion()}`)} ${kleur_default.gray("ready in")} ${kleur_default.white(`${Math.round(timeToStart)}ms`)}`);
     console.log(`
-  ${kleur_default.bold("➜ Local:")}   ${kleur_default.underline(kleur_default.cyan(`http://localhost:${port}`))}${server.componentFilePath ? kleur_default.underline(kleur_default.cyan(`/#file=${encodeURIComponent(path53.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
+  ${kleur_default.bold("➜ Local:")}   ${kleur_default.underline(kleur_default.cyan(`http://localhost:${port}`))}${server.componentFilePath ? kleur_default.underline(kleur_default.cyan(`/#file=${encodeURIComponent(path54.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
 
 `);
     console.log(kleur_default.gray(`Watching ${kleur_default.underline(server.projectDir.split("/").slice(-2).join("/"))} for changes...`));
@@ -244698,13 +244703,13 @@ var checkLoggedIn = () => {
 import { spawnSync } from "node:child_process";
 import fs52 from "node:fs";
 import os7 from "node:os";
-import path54 from "node:path";
+import path55 from "node:path";
 var hasBunInstalled = () => {
   const result = spawnSync("bun", ["--version"], { stdio: "ignore" });
   return result.status === 0;
 };
 var createTempProject = (tempDir) => {
-  const packageJsonPath = path54.join(tempDir, "package.json");
+  const packageJsonPath = path55.join(tempDir, "package.json");
   const packageJson = {
     name: "tsci-doctor-check",
     version: "0.0.0",
@@ -244724,7 +244729,7 @@ var checkGlobalNpmrcRegistry = async () => {
       details: "Bun is required to verify registry settings. Install Bun and rerun `tsci doctor`."
     };
   }
-  const tempDir = fs52.mkdtempSync(path54.join(os7.tmpdir(), "tsci-doctor-"));
+  const tempDir = fs52.mkdtempSync(path55.join(os7.tmpdir(), "tsci-doctor-"));
   try {
     createTempProject(tempDir);
     const result = spawnSync("bun", ["install"], {
@@ -244796,7 +244801,7 @@ var registerDoctor = (program2) => {
 
 // lib/shared/export-snippet.ts
 import fs53 from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf4 } from "circuit-json-to-gltf";
 import {
@@ -245763,9 +245768,9 @@ var stringifyDsnJson = (dsnJson) => {
   const stringifyCoordinates = (coordinates) => {
     return coordinates.join(" ");
   };
-  const stringifyPath = (path55, level) => {
+  const stringifyPath = (path56, level) => {
     const padding = indent.repeat(level);
-    return `${padding}(path ${path55.layer} ${path55.width}  ${stringifyCoordinates(path55.coordinates)})`;
+    return `${padding}(path ${path56.layer} ${path56.width}  ${stringifyCoordinates(path56.coordinates)})`;
   };
   result += `(pcb ${dsnJson.filename ? dsnJson.filename : "./converted_dsn.dsn"}
 `;
@@ -249631,11 +249636,11 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
         continue;
       }
       const letterPaths = lineAlphabet2[char] || [];
-      for (const path55 of letterPaths) {
-        const x12 = anchoredX + path55.x1 * fontSize;
-        const y12 = anchoredY + path55.y1 * fontSize;
-        const x23 = anchoredX + path55.x2 * fontSize;
-        const y23 = anchoredY + path55.y2 * fontSize;
+      for (const path56 of letterPaths) {
+        const x12 = anchoredX + path56.x1 * fontSize;
+        const y12 = anchoredY + path56.y1 * fontSize;
+        const x23 = anchoredX + path56.x2 * fontSize;
+        const y23 = anchoredY + path56.y2 * fontSize;
         const p12 = applyTransform2({ x: x12, y: y12 });
         const p23 = applyTransform2({ x: x23, y: y23 });
         gerber.add("move_operation", { x: p12.x, y: mfy(p12.y) });
@@ -250402,10 +250407,10 @@ var exportSnippet = async ({
     onError(`Invalid format: ${format}`);
     return onExit(1);
   }
-  const projectDir = path55.dirname(filePath);
-  const outputBaseName = path55.basename(filePath).replace(/\.[^.]+$/, "");
+  const projectDir = path56.dirname(filePath);
+  const outputBaseName = path56.basename(filePath).replace(/\.[^.]+$/, "");
   const outputFileName = `${outputBaseName}${OUTPUT_EXTENSIONS[format]}`;
-  const outputDestination = path55.join(projectDir, outputPath ?? outputFileName);
+  const outputDestination = path56.join(projectDir, outputPath ?? outputFileName);
   if (format === "kicad-library") {
     try {
       const result = await convertToKicadLibrary({
@@ -250513,7 +250518,7 @@ var exportSnippet = async ({
       zip.file(`${outputBaseName}.kicad_pro`, proConverter.getOutputString());
       const platformFetch2 = platformConfig2?.platformFetch ?? globalThis.fetch;
       for (const modelPath of pcbConverter.getModel3dSourcePaths()) {
-        const fileName = path55.basename(modelPath);
+        const fileName = path56.basename(modelPath);
         const isRemote = modelPath.startsWith("http://") || modelPath.startsWith("https://");
         const shapesDir = isRemote ? "tscircuit_builtin.3dshapes" : `${outputBaseName}.3dshapes`;
         const zipPath = `3dmodels/${shapesDir}/${fileName}`;
@@ -250528,7 +250533,7 @@ var exportSnippet = async ({
             console.warn(`Failed to fetch 3D model from ${modelPath}`);
           }
         } else {
-          const resolvedPath = path55.resolve(projectDir, modelPath);
+          const resolvedPath = path56.resolve(projectDir, modelPath);
           if (fs53.existsSync(resolvedPath)) {
             zip.file(zipPath, await fs53.promises.readFile(resolvedPath));
           }
@@ -250704,11 +250709,11 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 
 // lib/eecircuit-engine/run-simulation.ts
 import { promises as fs54, existsSync as existsSync13 } from "node:fs";
-import path56 from "node:path";
+import path57 from "node:path";
 import os8 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path56.join(os8.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  const tempFilePath = path57.join(os8.tmpdir(), "eecircuit-engine-1.5.2.mjs");
   if (!existsSync13(tempFilePath)) {
     const url2 = "https://cdn.jsdelivr.net/npm/eecircuit-engine@1.5.2/+esm";
     const response = await fetch(url2);
@@ -250805,7 +250810,7 @@ var resultToCsv = (result) => {
 };
 
 // cli/export/register.ts
-import path57 from "node:path";
+import path58 from "node:path";
 import { promises as fs55 } from "node:fs";
 var registerExport = (program2) => {
   program2.command("export").description("Export tscircuit code to various formats").argument("<file>", "Path to the package file").option("-f, --format <format>", `Output format (${ALLOWED_EXPORT_FORMATS.join(", ")})`).option("-o, --output <path>", "Output file path").option("--disable-parts-engine", "Disable the parts engine").option("--show-courtyards", "Show courtyard outlines in PCB SVG output").action(async (file, options) => {
@@ -250818,7 +250823,7 @@ var registerExport = (program2) => {
       });
       if (circuitJson) {
         const spiceString = getSpiceWithPaddedSim(circuitJson);
-        const outputSpicePath = options.output ?? path57.join(path57.dirname(file), `${path57.basename(file, path57.extname(file))}.spice.cir`);
+        const outputSpicePath = options.output ?? path58.join(path58.dirname(file), `${path58.basename(file, path58.extname(file))}.spice.cir`);
         await fs55.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
@@ -251545,8 +251550,8 @@ function getErrorMap2() {
   return overrideErrorMap2;
 }
 var makeIssue2 = (params2) => {
-  const { data, path: path58, errorMaps, issueData } = params2;
-  const fullPath = [...path58, ...issueData.path || []];
+  const { data, path: path59, errorMaps, issueData } = params2;
+  const fullPath = [...path59, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -251654,11 +251659,11 @@ var errorUtil2;
   errorUtil22.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil2 || (errorUtil2 = {}));
 var ParseInputLazyPath2 = class {
-  constructor(parent, value, path58, key) {
+  constructor(parent, value, path59, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path58;
+    this._path = path59;
     this._key = key;
   }
   get path() {
@@ -259316,15 +259321,15 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path58 = [];
+  const path59 = [];
   for (let i2 = 0;i2 <= numPoints; i2++) {
     const t17 = i2 / numPoints;
     const angle2 = startAngle + t17 * (endAngle - startAngle);
     const x3 = centerX + radius * Math.cos(angle2);
     const y4 = centerY + radius * Math.sin(angle2);
-    path58.push({ x: x3, y: y4 });
+    path59.push({ x: x3, y: y4 });
   }
-  return path58;
+  return path59;
 }
 var mil10ToMm = (value) => value * 10 * 0.0254;
 var normalizePinLabels = (inputPinLabels) => {
@@ -260296,7 +260301,7 @@ var parsePin = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path58 = pathMatch ? pathMatch[1] : "";
+  const path59 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r4 = Number.parseFloat(rotation22);
@@ -260310,7 +260315,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r4) ? 0 : r4,
     label,
     labelColor,
-    path: path58,
+    path: path59,
     arrow
   };
 };
@@ -267136,14 +267141,14 @@ function normalizeManufacturerPartNumber2(partNumber) {
 
 // lib/import/import-component-from-jlcpcb.ts
 import fs56 from "node:fs/promises";
-import path58 from "node:path";
+import path59 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd(), options = {}) => {
   const rawEasy = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const betterEasy = EasyEdaJsonSchema2.parse(rawEasy);
   const rawPn = betterEasy.dataStr.head.c_para["Manufacturer Part"];
   const componentName = rawPn ? normalizeManufacturerPartNumber2(rawPn) : jlcpcbPartNumber;
   let tsx = await convertRawEasyToTsx({ rawEasy });
-  const componentDir = options.download ? path58.join(projectDir, "imports", componentName) : path58.join(projectDir, "imports");
+  const componentDir = options.download ? path59.join(projectDir, "imports", componentName) : path59.join(projectDir, "imports");
   await fs56.mkdir(componentDir, { recursive: true });
   if (options.download) {
     const platformConfig2 = getCompletePlatformConfig();
@@ -267155,7 +267160,7 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
     if (cadComponent?.model_step_url) {
       const stepFileName = `${componentName}.step`;
       const stepResp = await platformFetch2(cadComponent.model_step_url);
-      await fs56.writeFile(path58.join(componentDir, stepFileName), Buffer.from(await stepResp.arrayBuffer()));
+      await fs56.writeFile(path59.join(componentDir, stepFileName), Buffer.from(await stepResp.arrayBuffer()));
       tsx = `import stepPath from "./${stepFileName}"
 ` + tsx;
       tsx = tsx.replace(`"${cadComponent.model_step_url}"`, "stepPath");
@@ -267163,13 +267168,13 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
     if (cadComponent?.model_obj_url) {
       const objFileName = `${componentName}.obj`;
       const objResp = await platformFetch2(cadComponent.model_obj_url);
-      await fs56.writeFile(path58.join(componentDir, objFileName), Buffer.from(await objResp.arrayBuffer()));
+      await fs56.writeFile(path59.join(componentDir, objFileName), Buffer.from(await objResp.arrayBuffer()));
       tsx = `import objPath from "./${objFileName}"
 ` + tsx;
       tsx = tsx.replace(`"${cadComponent.model_obj_url}"`, "objPath");
     }
   }
-  const filePath = path58.join(componentDir, `${componentName}.tsx`);
+  const filePath = path59.join(componentDir, `${componentName}.tsx`);
   await fs56.writeFile(filePath, tsx);
   return { filePath };
 };
@@ -268618,12 +268623,12 @@ var registerImport = (program2) => {
 
 // cli/init/register.ts
 import * as fs58 from "node:fs";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 
 // lib/shared/generate-gitignore-file.ts
-import path59 from "node:path";
+import path60 from "node:path";
 var generateGitIgnoreFile = (dir) => {
-  const gitignorePath = path59.join(dir, ".gitignore");
+  const gitignorePath = path60.join(dir, ".gitignore");
   const gitignoreContent = `# Dependencies
 node_modules/
 
@@ -268659,7 +268664,7 @@ yarn-error.log*
 
 // lib/shared/setup-tscircuit-skill.ts
 import * as fs57 from "node:fs";
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 var SKILL_REPO_API_URL = "https://api.github.com/repos/tscircuit/skill/contents";
 var SKILL_INSTALL_PATHS = [
   ".claude/skills/tscircuit",
@@ -268682,7 +268687,7 @@ async function fetchFileContent(downloadUrl) {
 async function downloadDirectory(apiUrl, targetDir) {
   const contents = await fetchGitHubContents(apiUrl);
   for (const item of contents) {
-    const targetPath = path60.join(targetDir, item.name);
+    const targetPath = path61.join(targetDir, item.name);
     if (item.type === "dir") {
       fs57.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${apiUrl}/${item.name}`, targetPath);
@@ -268699,7 +268704,7 @@ async function downloadSkillRepo(targetDir) {
     if (item.name === ".git" || item.name === ".github") {
       continue;
     }
-    const targetPath = path60.join(targetDir, item.name);
+    const targetPath = path61.join(targetDir, item.name);
     if (item.type === "dir") {
       fs57.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${SKILL_REPO_API_URL}/${item.name}`, targetPath);
@@ -268710,7 +268715,7 @@ async function downloadSkillRepo(targetDir) {
   }
 }
 async function setupTscircuitSkill(projectDir, skipPrompt = false) {
-  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs57.existsSync(path60.join(projectDir, skillPath, "SKILL.md")));
+  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs57.existsSync(path61.join(projectDir, skillPath, "SKILL.md")));
   if (missingSkillPaths.length === 0) {
     console.log("TSCircuit AI skills already exist, skipping...");
     return true;
@@ -268730,7 +268735,7 @@ async function setupTscircuitSkill(projectDir, skipPrompt = false) {
   console.info("Setting up tscircuit AI skills...");
   try {
     for (const skillPath of missingSkillPaths) {
-      const targetDir = path60.join(projectDir, skillPath);
+      const targetDir = path61.join(projectDir, skillPath);
       await downloadSkillRepo(targetDir);
       console.info(`tscircuit skill installed at ${skillPath}`);
     }
@@ -268834,7 +268839,7 @@ var registerInit = (program3) => {
         }
       }
     }
-    const projectDir = directory ? path61.resolve(process.cwd(), directory) : process.cwd();
+    const projectDir = directory ? path62.resolve(process.cwd(), directory) : process.cwd();
     let tsciHandle = null;
     const token = getSessionToken();
     if (token) {
@@ -268845,7 +268850,7 @@ var registerInit = (program3) => {
         }
       } catch {}
     }
-    const dirName = path61.basename(projectDir);
+    const dirName = path62.basename(projectDir);
     let defaultPackageName = dirName;
     if (tsciHandle) {
       defaultPackageName = `@tsci/${tsciHandle}.${dirName}`;
@@ -268864,7 +268869,7 @@ var registerInit = (program3) => {
       }
     }
     fs58.mkdirSync(projectDir, { recursive: true });
-    writeFileIfNotExists(path61.join(projectDir, "index.circuit.tsx"), `
+    writeFileIfNotExists(path62.join(projectDir, "index.circuit.tsx"), `
 export default () => (
   <board>
     <resistor resistance="1k" footprint="0402" name="R1" />
@@ -268876,7 +268881,7 @@ export default () => (
     if (saveProjectConfig(null, projectDir)) {
       console.log("Created tscircuit.config.json with schema");
     }
-    writeFileIfNotExists(path61.join(projectDir, ".npmrc"), `
+    writeFileIfNotExists(path62.join(projectDir, ".npmrc"), `
 @tsci:registry=https://npm.tscircuit.com
 `);
     console.log("Generating package.json");
@@ -269008,9 +269013,9 @@ var registerRegistryPackagesCreate = (program3) => {
 
 // cli/registry/packages/update/register.ts
 import fs59 from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 var getCurrentDirectoryPackageName = () => {
-  const packageJsonPath = path62.join(process.cwd(), "package.json");
+  const packageJsonPath = path63.join(process.cwd(), "package.json");
   if (!fs59.existsSync(packageJsonPath))
     return;
   try {
@@ -269150,14 +269155,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path63 = null;
+  let path64 = null;
   let id2 = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path63 = createKeyPath(key);
+    path64 = createKeyPath(key);
     id2 = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -269171,11 +269176,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path63 = createKeyPath(name);
+    path64 = createKeyPath(name);
     id2 = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path63, id: id2, weight, src, getFn };
+  return { path: path64, id: id2, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -269183,34 +269188,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path63) {
+function get(obj, path64) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path64, index) => {
+  const deepGet = (obj2, path65, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path64[index]) {
+    if (!path65[index]) {
       list.push(obj2);
     } else {
-      let key = path64[index];
+      let key = path65[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path64.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
+      if (index === path65.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
         list.push(toString2(value));
       } else if (isArray(value)) {
         arr = true;
         for (let i2 = 0, len = value.length;i2 < len; i2 += 1) {
-          deepGet(value[i2], path64, index + 1);
+          deepGet(value[i2], path65, index + 1);
         }
-      } else if (path64.length) {
-        deepGet(value, path64, index + 1);
+      } else if (path65.length) {
+        deepGet(value, path65, index + 1);
       }
     }
   };
-  deepGet(obj, isString2(path63) ? path63.split(".") : path63, 0);
+  deepGet(obj, isString2(path64) ? path64.split(".") : path64, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -270406,9 +270411,9 @@ var registerSearch = (program3) => {
     }
     if (opts.json) {
       const unifiedResults = [
-        ...kicadResults.map((path63) => ({
+        ...kicadResults.map((path64) => ({
           source: "kicad",
-          path: path63
+          path: path64
         })),
         ...results.packages.map((pkg) => ({
           source: "tscircuit",
@@ -270436,8 +270441,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path63, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path63.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path64, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path64.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (results.packages.length) {
@@ -270462,20 +270467,20 @@ var registerSearch = (program3) => {
 
 // lib/shared/setup-github-actions.ts
 import fs60 from "node:fs";
-import path63 from "node:path";
+import path64 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path63.resolve(startDir);
-    while (dir !== path63.parse(dir).root) {
-      if (fs60.existsSync(path63.join(dir, ".git"))) {
+    let dir = path64.resolve(startDir);
+    while (dir !== path64.parse(dir).root) {
+      if (fs60.existsSync(path64.join(dir, ".git"))) {
         return dir;
       }
-      dir = path63.dirname(dir);
+      dir = path64.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path63.join(gitRoot, ".github", "workflows");
+  const workflowsDir = path64.join(gitRoot, ".github", "workflows");
   fs60.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
@@ -270515,8 +270520,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path63.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path63.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path64.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path64.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -270684,21 +270689,21 @@ function applyCameraPreset(preset, cam) {
 
 // lib/shared/snapshot-project.ts
 import fs64 from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 
 // cli/snapshot/worker-pool.ts
 import fs61 from "node:fs";
-import path64 from "node:path";
+import path65 from "node:path";
 var getWorkerEntrypointPath2 = () => {
-  const tsPath = path64.join(import.meta.dir, "snapshot.worker.ts");
+  const tsPath = path65.join(import.meta.dir, "snapshot.worker.ts");
   if (fs61.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path64.join(import.meta.dir, "snapshot", "snapshot.worker.js");
+  const jsBundledPath = path65.join(import.meta.dir, "snapshot", "snapshot.worker.js");
   if (fs61.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path64.join(import.meta.dir, "snapshot.worker.js");
+  return path65.join(import.meta.dir, "snapshot.worker.js");
 };
 var snapshotFilesWithWorkerPool = async (options) => {
   const cancellationError = new Error("Snapshot cancelled due to file failure");
@@ -270767,7 +270772,7 @@ var snapshotFilesWithWorkerPool = async (options) => {
 
 // lib/shared/process-snapshot-file.ts
 import fs63 from "node:fs";
-import path65 from "node:path";
+import path66 from "node:path";
 import {
   convertCircuitJsonToGltf as convertCircuitJsonToGltf5,
   getBestCameraPosition
@@ -273508,7 +273513,7 @@ var processSnapshotFile = async ({
   createDiff: createDiff2,
   cameraPreset
 }) => {
-  const relativeFilePath = path65.relative(projectDir, file);
+  const relativeFilePath = path66.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -273589,11 +273594,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 = path65.dirname(file);
-        const relativeDir = path65.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path65.join(projectDir, snapshotsDirName, relativeDir) : path65.join(fileDir, "__snapshots__");
-        const base2 = path65.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path65.join(snapDir2, `${base2}-3d.snap.png`);
+        const fileDir = path66.dirname(file);
+        const relativeDir = path66.relative(projectDir, fileDir);
+        const snapDir2 = snapshotsDirName ? path66.join(projectDir, snapshotsDirName, relativeDir) : path66.join(fileDir, "__snapshots__");
+        const base2 = path66.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path66.join(snapDir2, `${base2}-3d.snap.png`);
         const existing3dSnapshot = fs63.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
@@ -273605,7 +273610,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: ${path65.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path66.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -273626,9 +273631,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path65.join(projectDir, snapshotsDirName, path65.relative(projectDir, path65.dirname(file))) : path65.join(path65.dirname(file), "__snapshots__");
+  const snapDir = snapshotsDirName ? path66.join(projectDir, snapshotsDirName, path66.relative(projectDir, path66.dirname(file))) : path66.join(path66.dirname(file), "__snapshots__");
   fs63.mkdirSync(snapDir, { recursive: true });
-  const base = path65.basename(file).replace(/\.[^.]+$/, "");
+  const base = path66.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (pcbOnly || !schematicOnly) {
     snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -273642,13 +273647,13 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path65.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const snapPath = path66.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
     const existing = fs63.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
       fs63.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path65.relative(projectDir, snapPath));
+      successPaths.push(path66.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
@@ -273664,16 +273669,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal2) {
-        successPaths.push(path65.relative(projectDir, snapPath));
+        successPaths.push(path66.relative(projectDir, snapPath));
       } else {
         fs63.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path65.relative(projectDir, snapPath));
+        successPaths.push(path66.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal2) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path65.relative(projectDir, snapPath));
+      successPaths.push(path66.relative(projectDir, snapPath));
     }
   }
   return {
@@ -273717,7 +273722,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path66.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path67.resolve(projectDir, f2));
   const explicitDirectoryTarget = resolvedPaths.find((resolvedPath) => {
     if (!fs64.existsSync(resolvedPath)) {
       return false;
@@ -273731,7 +273736,7 @@ var snapshotProject = async ({
   });
   if (boardFiles.length === 0) {
     if (explicitDirectoryTarget) {
-      const relativeDirectory = path66.relative(projectDir, explicitDirectoryTarget) || ".";
+      const relativeDirectory = path67.relative(projectDir, explicitDirectoryTarget) || ".";
       const includeBoardFilePatterns = getBoardFilePatterns(projectDir);
       const patternSourceMessage = hasConfiguredIncludeBoardFiles(projectDir) ? "Searched using tscircuit.config.json includeBoardFiles" : "Searched using default includeBoardFiles";
       onError([
@@ -273868,7 +273873,7 @@ var registerSnapshot = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path67 from "node:path";
+import path68 from "node:path";
 var registerTranspile = (program3) => {
   program3.command("transpile").description("Transpile TypeScript/TSX to JavaScript (ESM, CommonJS, and type declarations)").argument("[file]", "Path to the entry file").action(async (file) => {
     try {
@@ -273876,7 +273881,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path67.join(projectDir, "dist");
+      const distDir = path68.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];
@@ -273914,12 +273919,12 @@ function registerUpgradeCommand(program3) {
 }
 
 // lib/shared/update-package.ts
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 import * as fs65 from "node:fs";
 async function updatePackage(packageSpec, projectDir = process.cwd()) {
   const packageManager = getPackageManager();
   if (!packageSpec) {
-    const pkgJsonPath = path68.join(projectDir, "package.json");
+    const pkgJsonPath = path69.join(projectDir, "package.json");
     if (!fs65.existsSync(pkgJsonPath)) {
       console.log(kleur_default.yellow("No package.json found. Cannot update all packages."));
       return;