@tscircuit/cli 0.1.1092 → 0.1.1094

package/dist/cli/main.js

@@ -68605,18 +68605,18 @@ globstar while`, file, fr, pattern, pr, 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));
         });
       }
     }
@@ -71664,7 +71664,7 @@ var registerStaticAssetLoaders = () => {
 // cli/main.ts
 var import_perfect_cli = __toESM2(require_dist2(), 1);
 // package.json
-var version = "0.1.1090";
+var version = "0.1.1093";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -71693,7 +71693,7 @@ var package_default = {
     "@types/semver": "^7.5.8",
     "bun-match-svg": "^0.0.12",
     chokidar: "4.0.1",
-    "circuit-json": "^0.0.397",
+    "circuit-json": "^0.0.400",
     "circuit-json-to-kicad": "^0.0.84",
     "circuit-json-to-readable-netlist": "^0.0.14",
     "circuit-json-to-spice": "^0.0.10",
@@ -71728,7 +71728,7 @@ var package_default = {
     semver: "^7.6.3",
     sharp: "0.32.6",
     tempy: "^3.1.0",
-    tscircuit: "0.0.1479-libonly",
+    tscircuit: "0.0.1488-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
     zod: "^3.23.8"
@@ -81960,6 +81960,7 @@ class ThreadWorkerPool {
   initialized = false;
   stopped = false;
   stopReason = null;
+  heartbeatIntervalId = null;
   constructor(options) {
     this.options = options;
     this.concurrency = options.concurrency;
@@ -81970,13 +81971,68 @@ class ThreadWorkerPool {
     for (let i = 0;i < this.concurrency; i++) {
       this.workers.push(this.createThreadWorker());
     }
+    this.startHeartbeat();
     this.initialized = true;
   }
+  describeJob(job) {
+    if (this.options.describeJob) {
+      return this.options.describeJob(job);
+    }
+    if (typeof job === "object" && job !== null) {
+      const jobCandidate = job;
+      if (typeof jobCandidate.filePath === "string") {
+        return jobCandidate.filePath;
+      }
+      if (typeof jobCandidate.id === "string") {
+        return jobCandidate.id;
+      }
+      if (typeof jobCandidate.outputPath === "string") {
+        return jobCandidate.outputPath;
+      }
+    }
+    return "unknown-job";
+  }
+  startHeartbeat() {
+    if (!this.options.onLog || this.heartbeatIntervalId) {
+      return;
+    }
+    const heartbeatIntervalMs = this.options.heartbeatIntervalMs ?? 5000;
+    if (heartbeatIntervalMs <= 0) {
+      return;
+    }
+    this.heartbeatIntervalId = setInterval(() => {
+      const busyWorkers = this.workers.filter((worker) => worker.busy).length;
+      const totalWorkers = this.workers.length;
+      const idleWorkers = totalWorkers - busyWorkers;
+      const queuedJobs = this.jobQueue.length;
+      const now = Date.now();
+      const workerDetails = this.workers.map((worker, index) => {
+        if (!worker.busy || !worker.currentJob || !worker.currentJobStartedAt) {
+          return `w${index}:idle`;
+        }
+        const runningForMs = now - worker.currentJobStartedAt;
+        const jobDescription = this.describeJob(worker.currentJob.job);
+        return `w${index}:busy task=${jobDescription} running_ms=${runningForMs}`;
+      });
+      this.options.onLog?.([
+        `[worker-pool] heartbeat: workers busy=${busyWorkers}/${totalWorkers}, idle=${idleWorkers}, queued_jobs=${queuedJobs} | ${workerDetails.join(" | ")}`
+      ]);
+    }, heartbeatIntervalMs);
+    this.heartbeatIntervalId.unref?.();
+  }
+  stopHeartbeat() {
+    if (!this.heartbeatIntervalId) {
+      return;
+    }
+    clearInterval(this.heartbeatIntervalId);
+    this.heartbeatIntervalId = null;
+  }
   createThreadWorker() {
     const threadWorker = {
       worker: new Worker(this.options.workerEntrypointPath),
       busy: false,
       currentJob: null,
+      currentJobStartedAt: null,
       timeoutId: null
     };
     this.attachWorkerHandlers(threadWorker);
@@ -82016,6 +82072,7 @@ class ThreadWorkerPool {
     threadWorker.worker = new Worker(this.options.workerEntrypointPath);
     threadWorker.busy = false;
     threadWorker.currentJob = null;
+    threadWorker.currentJobStartedAt = null;
     this.attachWorkerHandlers(threadWorker);
   }
   finishJob(threadWorker, action) {
@@ -82025,6 +82082,7 @@ class ThreadWorkerPool {
     }
     this.clearWorkerTimeout(threadWorker);
     threadWorker.currentJob = null;
+    threadWorker.currentJobStartedAt = null;
     threadWorker.busy = false;
     action(job);
     this.processQueue();
@@ -82089,6 +82147,7 @@ class ThreadWorkerPool {
     }
     availableWorker.busy = true;
     availableWorker.currentJob = queuedJob;
+    availableWorker.currentJobStartedAt = Date.now();
     this.startJobTimeout(availableWorker);
     availableWorker.worker.postMessage(this.options.createMessage(queuedJob.job));
   }
@@ -82106,6 +82165,7 @@ class ThreadWorkerPool {
     if (this.stopped)
       return;
     this.stopped = true;
+    this.stopHeartbeat();
     this.stopReason = reason;
     for (const queuedJob of this.jobQueue) {
       queuedJob.reject(reason);
@@ -82113,6 +82173,7 @@ class ThreadWorkerPool {
     this.jobQueue = [];
   }
   async terminate() {
+    this.stopHeartbeat();
     await Promise.all(this.workers.map((worker) => {
       this.clearWorkerTimeout(worker);
       return worker.worker.terminate();
@@ -82989,9 +83050,76 @@ var registerCheckNetlist = (program2) => {
   });
 };
 
-// cli/check/placement/register.ts
+// cli/check/pin-specification/register.ts
 import fs38 from "node:fs";
+import { runAllPinSpecificationChecks } from "@tscircuit/checks";
 import path41 from "node:path";
+var resolveInputFilePath2 = async (file) => {
+  if (file) {
+    return path41.isAbsolute(file) ? file : path41.resolve(process.cwd(), file);
+  }
+  const entrypoint = await getEntrypoint({
+    projectDir: process.cwd()
+  });
+  if (!entrypoint) {
+    throw new Error("No input file provided and no entrypoint found");
+  }
+  return entrypoint;
+};
+var isPrebuiltCircuitJsonFile = (filePath) => {
+  const normalizedInputPath = filePath.toLowerCase().replaceAll("\\", "/");
+  return normalizedInputPath.endsWith(".circuit.json") || normalizedInputPath.endsWith("/circuit.json");
+};
+var getCircuitJsonForPinSpecificationCheck = async (filePath) => {
+  if (isPrebuiltCircuitJsonFile(filePath)) {
+    const parsedJson = JSON.parse(fs38.readFileSync(filePath, "utf-8"));
+    return Array.isArray(parsedJson) ? parsedJson : [];
+  }
+  const completePlatformConfig = getCompletePlatformConfig({
+    pcbDisabled: true,
+    routingDisabled: true,
+    placementDrcChecksDisabled: true
+  });
+  const { circuitJson } = await generateCircuitJson({
+    filePath,
+    platformConfig: completePlatformConfig
+  });
+  return circuitJson;
+};
+var checkPinSpecification = async (file) => {
+  const resolvedInputFilePath = await resolveInputFilePath2(file);
+  const typedCircuitJson = await getCircuitJsonForPinSpecificationCheck(resolvedInputFilePath);
+  const pinSpecificationIssues = await runAllPinSpecificationChecks(typedCircuitJson);
+  const errors = pinSpecificationIssues.filter((issue) => ("error_type" in issue));
+  const warnings = pinSpecificationIssues.filter((issue) => ("warning_type" in issue) || issue.type?.endsWith("_warning"));
+  const diagnosticsLines = [
+    `Errors: ${errors.length}`,
+    `Warnings: ${warnings.length}`
+  ];
+  if (pinSpecificationIssues.length > 0) {
+    diagnosticsLines.push(...pinSpecificationIssues.map((issue) => {
+      const issueType = issue.warning_type ?? issue.error_type ?? issue.type;
+      return `- ${issueType}: ${issue.message ?? ""}`;
+    }));
+  }
+  return diagnosticsLines.join(`
+`);
+};
+var registerCheckPinSpecification = (program2) => {
+  program2.commands.find((c) => c.name() === "check").command("pin_specification").description("Partially build and validate pin specification checks").argument("[file]", "Path to the entry file").action(async (file) => {
+    try {
+      const output = await checkPinSpecification(file);
+      console.log(output);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+};
+
+// cli/check/placement/register.ts
+import fs39 from "node:fs";
+import path42 from "node:path";
 
 // node_modules/@tscircuit/circuit-json-placement-analysis/dist/index.js
 var CENTER_ANCHOR = "center";
@@ -83518,13 +83646,13 @@ var analyzeAllPlacements = (circuitJson) => {
 };
 
 // cli/check/placement/register.ts
-var isPrebuiltCircuitJsonFile = (filePath) => {
+var isPrebuiltCircuitJsonFile2 = (filePath) => {
   const normalizedInputPath = filePath.toLowerCase().replaceAll("\\", "/");
   return normalizedInputPath.endsWith(".circuit.json") || normalizedInputPath.endsWith("/circuit.json");
 };
-var resolveInputFilePath2 = async (file) => {
+var resolveInputFilePath3 = async (file) => {
   if (file) {
-    return path41.isAbsolute(file) ? file : path41.resolve(process.cwd(), file);
+    return path42.isAbsolute(file) ? file : path42.resolve(process.cwd(), file);
   }
   const entrypoint = await getEntrypoint({
     projectDir: process.cwd()
@@ -83535,8 +83663,8 @@ var resolveInputFilePath2 = async (file) => {
   return entrypoint;
 };
 var getCircuitJsonForPlacementCheck = async (filePath) => {
-  if (isPrebuiltCircuitJsonFile(filePath)) {
-    const parsedJson = JSON.parse(fs38.readFileSync(filePath, "utf-8"));
+  if (isPrebuiltCircuitJsonFile2(filePath)) {
+    const parsedJson = JSON.parse(fs39.readFileSync(filePath, "utf-8"));
     return Array.isArray(parsedJson) ? parsedJson : [];
   }
   const completePlatformConfig = getCompletePlatformConfig({
@@ -83550,7 +83678,7 @@ var getCircuitJsonForPlacementCheck = async (filePath) => {
   return circuitJson;
 };
 var checkPlacement = async (file, refdes) => {
-  const resolvedInputFilePath = await resolveInputFilePath2(file);
+  const resolvedInputFilePath = await resolveInputFilePath3(file);
   const circuitJson = await getCircuitJsonForPlacementCheck(resolvedInputFilePath);
   const analysis = refdes ? analyzeComponentPlacement(circuitJson, refdes) : analyzeAllPlacements(circuitJson);
   return analysis.getString();
@@ -83580,26 +83708,26 @@ var registerCheckRouting = (program2) => {
 };
 
 // cli/clone/register.ts
-import * as fs41 from "node:fs";
-import * as path44 from "node:path";
+import * as fs42 from "node:fs";
+import * as path45 from "node:path";
 
 // cli/clone/clone-bug-report.ts
 var import_jszip2 = __toESM2(require_lib4(), 1);
 var import_prompts4 = __toESM2(require_prompts3(), 1);
-import * as fs40 from "node:fs";
-import * as path43 from "node:path";
+import * as fs41 from "node:fs";
+import * as path44 from "node:path";
 
 // cli/clone/handle-existing-directory.ts
 var import_prompts3 = __toESM2(require_prompts3(), 1);
-import * as fs39 from "node:fs";
-import * as path42 from "node:path";
+import * as fs40 from "node:fs";
+import * as path43 from "node:path";
 var handleExistingDirectory = async (dirPath) => {
-  if (!fs39.existsSync(dirPath))
+  if (!fs40.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" },
       {
@@ -83614,7 +83742,7 @@ var handleExistingDirectory = async (dirPath) => {
     process.exit(0);
   }
   if (response.action === "delete") {
-    fs39.rmSync(dirPath, { recursive: true, force: true });
+    fs40.rmSync(dirPath, { recursive: true, force: true });
     console.log(`Deleted existing directory: ${dirPath}`);
   } else if (response.action === "merge") {
     console.log(`Merging files into existing directory: ${dirPath}`);
@@ -83640,12 +83768,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((segment) => segment === ".." || segment === "")) {
     return null;
   }
@@ -83660,7 +83788,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 ky2 = getRegistryApiKy();
   let zipBuffer;
@@ -83678,7 +83806,7 @@ var cloneBugReport = async ({
     }
     process.exit(1);
   }
-  fs40.mkdirSync(dirPath, { recursive: true });
+  fs41.mkdirSync(dirPath, { recursive: true });
   const zip = await import_jszip2.default.loadAsync(zipBuffer);
   const fileEntries = Object.entries(zip.files).filter(([, entry]) => !entry.dir);
   const commonPrefix = getCommonDirectoryPrefix(fileEntries.map(([fileName]) => fileName));
@@ -83690,29 +83818,29 @@ var cloneBugReport = async ({
       console.warn(`Skipping potentially unsafe path: ${fileName}`);
       continue;
     }
-    const fullPath = path43.join(dirPath, sanitizedRelativePath);
-    fs40.mkdirSync(path43.dirname(fullPath), { recursive: true });
+    const fullPath = path44.join(dirPath, sanitizedRelativePath);
+    fs41.mkdirSync(path44.dirname(fullPath), { recursive: true });
     const fileContent = await entry.async("nodebuffer");
-    fs40.writeFileSync(fullPath, fileContent);
+    fs41.writeFileSync(fullPath, fileContent);
   }
-  const packageJsonPath = path43.join(dirPath, "package.json");
-  if (fs40.existsSync(packageJsonPath)) {
+  const packageJsonPath = path44.join(dirPath, "package.json");
+  if (fs41.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs40.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs41.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);
-            fs40.renameSync(dirPath, suggestedDirPath);
+            fs41.renameSync(dirPath, suggestedDirPath);
             dirPath = suggestedDirPath;
           }
         }
@@ -83721,9 +83849,9 @@ var cloneBugReport = async ({
       console.warn("Unable to read package name for renaming:", error);
     }
   }
-  fs40.writeFileSync(path43.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+  fs41.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}/
@@ -83762,7 +83890,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 ky2 = getRegistryApiKy();
     let packageFileList = {
@@ -83783,13 +83911,13 @@ var registerClone = (program2) => {
       console.error("Failed to fetch package files:", error instanceof Error ? error.message : error);
       process.exit(1);
     }
-    fs41.mkdirSync(dirPath, { recursive: true });
+    fs42.mkdirSync(dirPath, { recursive: true });
     for (const fileInfo of packageFileList.package_files) {
       const filePath = fileInfo.file_path.replace(/^\/+/, "");
       if (!filePath)
         continue;
-      const fullPath = path44.join(dirPath, filePath);
-      fs41.mkdirSync(path44.dirname(fullPath), { recursive: true });
+      const fullPath = path45.join(dirPath, filePath);
+      fs42.mkdirSync(path45.dirname(fullPath), { recursive: true });
       try {
         const fileContent = await ky2.get("package_files/get", {
           searchParams: {
@@ -83800,14 +83928,14 @@ var registerClone = (program2) => {
         }).json();
         const { is_text: isText, content_text: contentText } = fileContent.package_file;
         if (isText && typeof contentText === "string") {
-          fs41.writeFileSync(fullPath, contentText);
+          fs42.writeFileSync(fullPath, contentText);
         } else if (!isText) {
           const fileBuffer = await ky2.get("package_files/download", {
             searchParams: {
               package_file_id: fileContent.package_file.package_file_id
             }
           }).arrayBuffer();
-          fs41.writeFileSync(fullPath, Buffer.from(fileBuffer));
+          fs42.writeFileSync(fullPath, Buffer.from(fileBuffer));
         } else {
           console.warn(`Skipping ${filePath} due to empty content.`);
         }
@@ -83815,10 +83943,10 @@ var registerClone = (program2) => {
         console.warn(`Skipping ${filePath} due to error:`, error instanceof Error ? error.message : error);
       }
     }
-    fs41.writeFileSync(path44.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+    fs42.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}/
@@ -83885,8 +84013,8 @@ var registerConfigSet = (program2) => {
 };
 
 // cli/convert/register.ts
-import fs42 from "node:fs/promises";
-import path45 from "node:path";
+import fs43 from "node:fs/promises";
+import path46 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -84007,15 +84135,15 @@ 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 modContent = await fs42.readFile(inputPath, "utf-8");
+      const inputPath = path46.resolve(file);
+      const modContent = await fs43.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`);
-      await fs42.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path46.resolve(options.output) : path46.join(path46.dirname(inputPath), `${componentName}.tsx`);
+      await fs43.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
       console.error(kleur_default.red("Failed to convert footprint:"), error instanceof Error ? error.message : error);
@@ -84025,13 +84153,13 @@ var registerConvert = (program2) => {
 };
 
 // cli/dev/register.ts
-import * as fs49 from "node:fs";
+import * as fs50 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 fs47 from "node:fs";
-import path51 from "node:path";
+import fs48 from "node:fs";
+import path52 from "node:path";
 
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -84110,7 +84238,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;
     }
@@ -84135,8 +84263,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)
@@ -84176,20 +84304,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) {
@@ -84587,16 +84715,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) {
@@ -84612,12 +84740,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);
@@ -84627,7 +84755,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) => {
@@ -84636,7 +84764,7 @@ var setFsWatchListener = (path46, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path46, "r");
+          const fd = await open(path47, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -84666,7 +84794,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;
@@ -84688,7 +84816,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));
         }
       })
     };
@@ -84711,13 +84839,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
     };
@@ -84727,12 +84855,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
@@ -84750,7 +84878,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) {
@@ -84764,11 +84892,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;
           }
@@ -84792,7 +84920,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path46, item) {
+  async _handleSymlink(entry, directory, path47, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -84802,7 +84930,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path46);
+        linkPath = await fsrealpath(path47);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -84812,12 +84940,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;
@@ -84846,9 +84974,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path46 = sysPath.join(directory, item);
+      let path47 = sysPath.join(directory, item);
       current.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) {
@@ -84857,8 +84985,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, wh, depth + 1);
+        path47 = sysPath.join(dir, sysPath.relative(dir, path47));
+        this._addToNodeFs(path47, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve7, reject) => {
@@ -84907,13 +85035,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 wh = this.fsw._getWatchHelpers(path46);
+    const wh = this.fsw._getWatchHelpers(path47);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -84929,8 +85057,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(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -84940,29 +85068,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(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path46, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path47, wh, 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(wh.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;
       }
     }
   }
@@ -85005,26 +85133,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 prepend = false;
-  if (path46.startsWith("//"))
+  if (path47.startsWith("//"))
     prepend = 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 (prepend)
-    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;
     }
   }
@@ -85064,19 +85192,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);
 
@@ -85133,10 +85261,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 = [];
@@ -85249,20 +85377,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 res = await this._nodeFsHandler._addToNodeFs(path46, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path47) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path47, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -85281,17 +85409,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
         });
       }
@@ -85340,38 +85468,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) {
@@ -85389,16 +85517,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);
@@ -85417,23 +85545,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);
@@ -85441,50 +85569,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 df = now2 - pw.lastChange;
         if (df >= 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;
         }
@@ -85492,8 +85620,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;
@@ -85503,13 +85631,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);
@@ -85523,57 +85651,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 wp = this._getWatchedDir(path46);
+    const wp = this._getWatchedDir(path47);
     const nestedDirectoryChildren = wp.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);
   }
@@ -85606,16 +85734,16 @@ import Debug3 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts from "typescript";
-import * as path46 from "path";
-import * as fs43 from "fs";
+import * as path47 from "path";
+import * as fs44 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path46.join(projectDir, "package.json");
+  const packageJsonPath = path47.join(projectDir, "package.json");
   const allPackages = new Set;
-  if (!fs43.existsSync(packageJsonPath)) {
+  if (!fs44.existsSync(packageJsonPath)) {
     return allPackages;
   }
   try {
-    const packageJson = JSON.parse(fs43.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs44.readFileSync(packageJsonPath, "utf-8"));
     const deps = packageJson.dependencies || {};
     const devDeps = packageJson.devDependencies || {};
     for (const packageName of Object.keys(deps)) {
@@ -85630,11 +85758,11 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path46.resolve(filePath);
-  if (!fs43.existsSync(absolutePath)) {
+  const absolutePath = path47.resolve(filePath);
+  if (!fs44.existsSync(absolutePath)) {
     return [];
   }
-  const content = fs43.readFileSync(absolutePath, "utf-8");
+  const content = fs44.readFileSync(absolutePath, "utf-8");
   const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
   const imports = new Set;
   function visit(node) {
@@ -85684,17 +85812,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;
@@ -85702,7 +85830,7 @@ function resolveNodeModuleImport({
   }
   let packageDir;
   for (const candidatePath of searchPaths) {
-    if (fs43.existsSync(candidatePath)) {
+    if (fs44.existsSync(candidatePath)) {
       packageDir = candidatePath;
       break;
     }
@@ -85710,25 +85838,25 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path46.join(packageDir, "package.json");
-  const hasPackageJson = fs43.existsSync(packageJsonPath);
-  const packageJson = hasPackageJson ? JSON.parse(fs43.readFileSync(packageJsonPath, "utf-8")) : null;
+  const packageJsonPath = path47.join(packageDir, "package.json");
+  const hasPackageJson = fs44.existsSync(packageJsonPath);
+  const packageJson = hasPackageJson ? JSON.parse(fs44.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 p of possiblePaths) {
-      if (fs43.existsSync(p) && fs43.statSync(p).isFile()) {
+      if (fs44.existsSync(p) && fs44.statSync(p).isFile()) {
         resolvedFiles.push(p);
         break;
       }
@@ -85760,25 +85888,25 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path46.join(packageDir, entry);
-    if (fs43.existsSync(entryPath) && fs43.statSync(entryPath).isFile()) {
+    const entryPath = path47.join(packageDir, entry);
+    if (fs44.existsSync(entryPath) && fs44.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 p of fallbackPaths) {
-      if (fs43.existsSync(p) && fs43.statSync(p).isFile()) {
+      if (fs44.existsSync(p) && fs44.statSync(p).isFile()) {
         resolvedFiles.push(p);
         break;
       }
@@ -85816,12 +85944,12 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path46.resolve(filePath);
-    const baseDir = path46.dirname(absolutePath);
-    if (!fs43.existsSync(absolutePath)) {
+    const absolutePath = path47.resolve(filePath);
+    const baseDir = path47.dirname(absolutePath);
+    if (!fs44.existsSync(absolutePath)) {
       return [];
     }
-    const content = fs43.readFileSync(absolutePath, "utf-8");
+    const content = fs44.readFileSync(absolutePath, "utf-8");
     const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
     const dependencies = [];
     function visit(node) {
@@ -85843,20 +85971,20 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path46.resolve(baseDir, importPath);
-    if (fs43.existsSync(resolvedPath) && fs43.statSync(resolvedPath).isFile()) {
+    const resolvedPath = path47.resolve(baseDir, importPath);
+    if (fs44.existsSync(resolvedPath) && fs44.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
     for (const ext of extensions) {
       const pathWithExt = resolvedPath + ext;
-      if (fs43.existsSync(pathWithExt)) {
+      if (fs44.existsSync(pathWithExt)) {
         return pathWithExt;
       }
     }
-    if (fs43.existsSync(resolvedPath) && fs43.statSync(resolvedPath).isDirectory()) {
+    if (fs44.existsSync(resolvedPath) && fs44.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path46.join(resolvedPath, `index${ext}`);
-        if (fs43.existsSync(indexPath)) {
+        const indexPath = path47.join(resolvedPath, `index${ext}`);
+        if (fs44.existsSync(indexPath)) {
           return indexPath;
         }
       }
@@ -85881,12 +86009,12 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path46.join(packageDir, dirName);
-    if (fs43.existsSync(dirPath)) {
+    const dirPath = path47.join(packageDir, dirName);
+    if (fs44.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path46.join(packageDir, "package.json");
-        if (fs43.existsSync(packageJsonPath)) {
+        const packageJsonPath = path47.join(packageDir, "package.json");
+        if (fs44.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
         return files;
@@ -85897,11 +86025,11 @@ function collectLocalPackageFiles(packageDir) {
 }
 function walkDirectory(dir, excludedDirs) {
   const files = [];
-  if (!fs43.existsSync(dir))
+  if (!fs44.existsSync(dir))
     return files;
-  const entries = fs43.readdirSync(dir, { withFileTypes: true });
+  const entries = fs44.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;
@@ -85962,13 +86090,13 @@ 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");
-          if (fs43.existsSync(packageJsonPath)) {
+          const packageJsonPath = path47.join(packageDir, "package.json");
+          if (fs44.existsSync(packageJsonPath)) {
             try {
-              const pkgJson = JSON.parse(fs43.readFileSync(packageJsonPath, "utf-8"));
+              const pkgJson = JSON.parse(fs44.readFileSync(packageJsonPath, "utf-8"));
               if (pkgJson.name === packageName) {
                 hasPackageJson = true;
                 break;
@@ -85976,15 +86104,15 @@ 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;
         }
-        if (fs43.existsSync(packageDir)) {
+        if (fs44.existsSync(packageDir)) {
           if (hasPackageJson) {
             const packageFiles = collectLocalPackageFiles(packageDir);
             packageFiles.forEach((file) => allFiles.add(file));
@@ -86050,7 +86178,7 @@ class EventsWatcher extends EventEmitter2 {
 }
 
 // lib/server/createHttpServer.ts
-import * as fs45 from "node:fs";
+import * as fs46 from "node:fs";
 import * as http from "node:http";
 
 // node_modules/winterspec/dist/edge/transform-to-node.js
@@ -86753,10 +86881,10 @@ var databaseSchema = z5.object({
   files: z5.array(fileSchema).default([]),
   events: z5.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);
   }
@@ -87613,14 +87741,14 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 };
 
 // lib/server/kicad-pcm-proxy.ts
-import * as fs44 from "node:fs";
-import * as path47 from "node:path";
+import * as fs45 from "node:fs";
+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 = fs44.statSync(path47.join(projectDir, file));
+      const stat4 = fs45.statSync(path48.join(projectDir, file));
       checksum += `${file}:${stat4.mtimeMs};`;
     } catch {}
   }
@@ -87640,9 +87768,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url, res) => {
     const requestedFile = url.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) {
@@ -87687,12 +87815,12 @@ Rebuilding KiCad PCM assets...`));
         }
       }
     }
-    if (!fs44.existsSync(filePath)) {
+    if (!fs45.existsSync(filePath)) {
       res.writeHead(404);
       res.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";
@@ -87700,7 +87828,7 @@ Rebuilding KiCad PCM assets...`));
       contentType = "application/zip";
     }
     try {
-      const content = fs44.readFileSync(filePath);
+      const content = fs45.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch (error) {
@@ -87780,7 +87908,7 @@ var createHttpServer = async ({
         return;
       }
       try {
-        const content = fs45.readFileSync(standaloneFilePath, "utf8");
+        const content = fs46.readFileSync(standaloneFilePath, "utf8");
         res.writeHead(200, {
           "Content-Type": "application/javascript; charset=utf-8"
         });
@@ -87823,8 +87951,8 @@ var createHttpServer = async ({
 
 // lib/shared/push-snippet.ts
 var import_semver3 = __toESM2(require_semver2(), 1);
-import * as fs46 from "node:fs";
-import * as path50 from "node:path";
+import * as fs47 from "node:fs";
+import * as path51 from "node:path";
 import Debug2 from "debug";
 
 // lib/utils/validate-package-name.ts
@@ -87842,7 +87970,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,
@@ -87853,7 +87981,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
@@ -87869,7 +87997,7 @@ var checkOrgAccess = async (ky2, 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",
@@ -87885,7 +88013,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);
 };
 
@@ -87911,8 +88039,8 @@ var debug2 = Debug2("tsci:push-snippet");
 var getArchivePayload = async (filePaths, projectDir, packageNameWithVersion) => {
   const zip = new import_jszip3.default;
   for (const fullFilePath of filePaths) {
-    const relativeFilePath = path50.relative(projectDir, fullFilePath);
-    zip.file(relativeFilePath, fs46.readFileSync(fullFilePath));
+    const relativeFilePath = path51.relative(projectDir, fullFilePath);
+    zip.file(relativeFilePath, fs47.readFileSync(fullFilePath));
   }
   const archive = await zip.generateAsync({
     type: "uint8array",
@@ -87950,24 +88078,24 @@ 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) => fs46.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) => fs47.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);
   }
   let packageJson = {};
-  if (fs46.existsSync(packageJsonPath)) {
+  if (fs47.existsSync(packageJsonPath)) {
     try {
-      packageJson = JSON.parse(fs46.readFileSync(packageJsonPath).toString());
+      packageJson = JSON.parse(fs47.readFileSync(packageJsonPath).toString());
     } catch {
       onError("Invalid package.json");
       return onExit(1);
     }
   }
-  if (!fs46.existsSync(snippetFilePath)) {
+  if (!fs47.existsSync(snippetFilePath)) {
     onError(`File not found: ${snippetFilePath}`);
     return onExit(1);
   }
@@ -88008,7 +88136,7 @@ var pushSnippet = async ({
     }
     unscopedPackageName = inputName;
     packageJson.name = `@tsci/${currentUsername}.${unscopedPackageName}`;
-    fs46.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    fs47.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
   }
   let accountName = currentUsername;
   if (packageJsonAuthor && currentUsername !== packageJsonAuthor) {
@@ -88039,7 +88167,7 @@ var pushSnippet = async ({
   const updatePackageJsonVersion = (newVersion) => {
     try {
       packageJson.version = newVersion ?? `${packageVersion}`;
-      fs46.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      fs47.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
     } catch (error) {
       onError(`Failed to update package.json version: ${error}`);
     }
@@ -88147,7 +88275,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`));
@@ -88157,8 +88285,8 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path50.relative(projectDir, fullFilePath);
-      const fileBuffer = fs46.readFileSync(fullFilePath);
+      const relativeFilePath = path51.relative(projectDir, fullFilePath);
+      const fileBuffer = fs47.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
         file_path: relativeFilePath,
@@ -88247,7 +88375,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 projectConfig = loadProjectConfig(this.projectDir);
     this.ignoredFiles = projectConfig?.ignoredFiles ?? [];
@@ -88258,7 +88386,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
@@ -88274,7 +88402,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p) => shouldIgnorePath(path51.relative(this.projectDir, p), this.ignoredFiles)
+      ignored: (p) => shouldIgnorePath(path52.relative(this.projectDir, p), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -88289,27 +88417,27 @@ 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);
-    if (!fs47.existsSync(dirPath)) {
-      fs47.mkdirSync(dirPath, { recursive: true });
+    const fullPath = path52.join(this.projectDir, ev.file_path);
+    const dirPath = path52.dirname(fullPath);
+    if (!fs48.existsSync(dirPath)) {
+      fs48.mkdirSync(dirPath, { recursive: true });
     }
     if (file.binary_content_b64) {
       const decodedContent = Buffer.from(file.binary_content_b64, "base64");
-      fs47.writeFileSync(fullPath, decodedContent);
+      fs48.writeFileSync(fullPath, decodedContent);
     } else {
-      fs47.writeFileSync(fullPath, file.text_content ?? "", "utf-8");
+      fs48.writeFileSync(fullPath, file.text_content ?? "", "utf-8");
     }
   }
   async handleFileDeletedEventFromServer(ev) {
-    const fullPath = path51.join(this.projectDir, ev.file_path);
-    if (fs47.existsSync(fullPath)) {
+    const fullPath = path52.join(this.projectDir, ev.file_path);
+    if (fs48.existsSync(fullPath)) {
       debug3(`Deleting file ${ev.file_path} from filesystem`);
-      fs47.unlinkSync(fullPath);
+      fs48.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))
@@ -88324,14 +88452,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)
@@ -88344,7 +88472,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() === "") {
@@ -88382,8 +88510,8 @@ class DevServer {
     debug3(`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);
@@ -88401,7 +88529,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,
@@ -88433,7 +88561,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({
@@ -88478,7 +88606,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
@@ -88518,12 +88646,12 @@ 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 = fs47.readFileSync(absoluteFilePath);
+      const fileBuffer = fs48.readFileSync(absoluteFilePath);
       return { binary_content: fileBuffer };
     }
-    return { text_content: fs47.readFileSync(absoluteFilePath, "utf-8") };
+    return { text_content: fs48.readFileSync(absoluteFilePath, "utf-8") };
   }
   async handleInstallPackage(full_package_name) {
     const postEvent = async (event, message) => {
@@ -88553,10 +88681,10 @@ class DevServer {
 }
 
 // cli/dev/resolve-dev-target.ts
-import * as fs48 from "node:fs";
-import * as path52 from "node:path";
+import * as fs49 from "node:fs";
+import * as path53 from "node:path";
 var findSelectableFiles = (projectDir) => {
-  const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs48.existsSync(file)).sort();
+  const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs49.existsSync(file)).sort();
   if (boardFiles.length > 0) {
     return boardFiles;
   }
@@ -88564,7 +88692,7 @@ var findSelectableFiles = (projectDir) => {
     cwd: projectDir,
     ignore: DEFAULT_IGNORED_PATTERNS
   });
-  return files.map((file) => path52.resolve(projectDir, file)).filter((file) => fs48.existsSync(file)).sort();
+  return files.map((file) => path53.resolve(projectDir, file)).filter((file) => fs49.existsSync(file)).sort();
 };
 var isValidDevFile = (filePath) => {
   return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
@@ -88572,18 +88700,18 @@ var isValidDevFile = (filePath) => {
 var resolveDevTarget = async (file) => {
   let projectDir = process.cwd();
   if (file) {
-    const resolvedPath = path52.resolve(file);
-    if (fs48.existsSync(resolvedPath) && fs48.statSync(resolvedPath).isDirectory()) {
+    const resolvedPath = path53.resolve(file);
+    if (fs49.existsSync(resolvedPath) && fs49.statSync(resolvedPath).isDirectory()) {
       projectDir = resolvedPath;
       const availableFiles2 = findSelectableFiles(projectDir);
       if (availableFiles2.length === 0) {
         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 (!fs48.existsSync(resolvedPath)) {
+    if (!fs49.existsSync(resolvedPath)) {
       console.error(`Error: File not found: ${file}`);
       return null;
     }
@@ -88594,7 +88722,7 @@ var resolveDevTarget = async (file) => {
     return { absolutePath: resolvedPath, projectDir };
   }
   const entrypointPath = await getEntrypoint({ onError: () => {} });
-  if (entrypointPath && fs48.existsSync(entrypointPath)) {
+  if (entrypointPath && fs49.existsSync(entrypointPath)) {
     console.log("Found entrypoint at:", entrypointPath);
     return { absolutePath: entrypointPath, projectDir };
   }
@@ -88603,7 +88731,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 };
 };
 
@@ -88619,12 +88747,12 @@ var isPortAvailable = (port) => {
   });
 };
 var warnIfTsconfigMissingTscircuitType = (projectDir) => {
-  const tsconfigPath = path53.join(projectDir, "tsconfig.json");
-  if (!fs49.existsSync(tsconfigPath)) {
+  const tsconfigPath = path54.join(projectDir, "tsconfig.json");
+  if (!fs50.existsSync(tsconfigPath)) {
     return;
   }
   try {
-    const tsconfig = JSON.parse(fs49.readFileSync(tsconfigPath, "utf-8"));
+    const tsconfig = JSON.parse(fs50.readFileSync(tsconfigPath, "utf-8"));
     const types = tsconfig?.compilerOptions?.types;
     if (!Array.isArray(types) || !types.includes("tscircuit")) {
       console.warn(kleur_default.yellow('Warning: "tscircuit" is missing from tsconfig.json compilerOptions.types. Add it (e.g. "types": ["tscircuit"]) to ensure CLI-provided types work correctly.'));
@@ -88656,7 +88784,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...`));
@@ -88684,15 +88812,15 @@ var checkLoggedIn = () => {
 
 // cli/doctor/checks/check-npmrc-registry.ts
 import { spawnSync } from "node:child_process";
-import fs50 from "node:fs";
+import fs51 from "node:fs";
 import os5 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",
@@ -88701,7 +88829,7 @@ var createTempProject = (tempDir) => {
       "@tsci/does-not-exist": "0.0.0"
     }
   };
-  fs50.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  fs51.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
 };
 var checkGlobalNpmrcRegistry = async () => {
   const name = "Global .npmrc configured for tscircuit NPM registry?";
@@ -88712,7 +88840,7 @@ var checkGlobalNpmrcRegistry = async () => {
       details: "Bun is required to verify registry settings. Install Bun and rerun `tsci doctor`."
     };
   }
-  const tempDir = fs50.mkdtempSync(path54.join(os5.tmpdir(), "tsci-doctor-"));
+  const tempDir = fs51.mkdtempSync(path55.join(os5.tmpdir(), "tsci-doctor-"));
   try {
     createTempProject(tempDir);
     const result = spawnSync("bun", ["install"], {
@@ -88750,7 +88878,7 @@ ${result.stderr ?? ""}`;
     }
     return { name, success: true };
   } finally {
-    fs50.rmSync(tempDir, { recursive: true, force: true });
+    fs51.rmSync(tempDir, { recursive: true, force: true });
   }
 };
 
@@ -88783,8 +88911,8 @@ var registerDoctor = (program2) => {
 };
 
 // lib/shared/export-snippet.ts
-import fs51 from "node:fs";
-import path55 from "node:path";
+import fs52 from "node:fs";
+import path56 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf4 } from "circuit-json-to-gltf";
 import {
@@ -89623,9 +89751,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"}
 `;
@@ -89815,7 +89943,7 @@ var isCircuitJsonFile = (filePath) => {
 };
 
 // lib/shared/export-snippet.ts
-var writeFileAsync = promisify3(fs51.writeFile);
+var writeFileAsync = promisify3(fs52.writeFile);
 var ALLOWED_EXPORT_FORMATS = [
   "json",
   "circuit-json",
@@ -89862,10 +89990,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({
@@ -89884,7 +90012,7 @@ var exportSnippet = async ({
   }
   let circuitJson;
   if (isCircuitJsonFile(filePath)) {
-    const rawCircuitJson = await fs51.promises.readFile(filePath, "utf-8").catch((err) => {
+    const rawCircuitJson = await fs52.promises.readFile(filePath, "utf-8").catch((err) => {
       onError(`Error reading circuit JSON file: ${err}`);
       return null;
     });
@@ -90091,12 +90219,12 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 };
 
 // lib/eecircuit-engine/run-simulation.ts
-import { promises as fs52, existsSync as existsSync13 } from "node:fs";
-import path56 from "node:path";
+import { promises as fs53, existsSync as existsSync13 } from "node:fs";
+import path57 from "node:path";
 import os6 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path56.join(os6.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  const tempFilePath = path57.join(os6.tmpdir(), "eecircuit-engine-1.5.2.mjs");
   if (!existsSync13(tempFilePath)) {
     const url = "https://cdn.jsdelivr.net/npm/eecircuit-engine@1.5.2/+esm";
     const response = await fetch(url);
@@ -90104,7 +90232,7 @@ var fetchSimulation = async () => {
       throw new Error(`Failed to fetch eecircuit-engine from ${url}: ${response.statusText}`);
     }
     const scriptContent = await response.text();
-    await fs52.writeFile(tempFilePath, scriptContent);
+    await fs53.writeFile(tempFilePath, scriptContent);
   }
   const module2 = await import(tempFilePath);
   return module2.Simulation;
@@ -90193,8 +90321,8 @@ var resultToCsv = (result) => {
 };
 
 // cli/export/register.ts
-import path57 from "node:path";
-import { promises as fs53 } from "node:fs";
+import path58 from "node:path";
+import { promises as fs54 } 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").action(async (file, options) => {
     const formatOption = options.format ?? "json";
@@ -90206,12 +90334,12 @@ 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`);
-        await fs53.writeFile(outputSpicePath, spiceString);
+        const outputSpicePath = options.output ?? path58.join(path58.dirname(file), `${path58.basename(file, path58.extname(file))}.spice.cir`);
+        await fs54.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
         const outputCsvPath = outputSpicePath.replace(/\.spice\.cir$/, ".csv");
-        await fs53.writeFile(outputCsvPath, csvContent);
+        await fs54.writeFile(outputCsvPath, csvContent);
         console.log(`Exported to ${outputSpicePath} and ${outputCsvPath} (simulation results)!`);
       }
       process.exit(0);
@@ -91682,8 +91810,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (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
@@ -91791,11 +91919,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = 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() {
@@ -99982,7 +100110,7 @@ var ss = ys;
 var ms2 = { paths: { diag1: { type: "path", points: [{ x: -0.1, y: -0.1 }, { x: 0.1, y: 0.1 }], color: "primary", fill: false }, diag2: { type: "path", points: [{ x: -0.1, y: 0.1 }, { x: 0.1, y: -0.1 }], color: "primary", fill: false }, stem: { type: "path", points: [{ x: -0.2, y: 0 }, { x: 0, y: 0 }], color: "primary", fill: false } }, texts: {}, refblocks: { left1: { x: -0.2, y: 0 } }, bounds: { minX: -0.19, maxX: 0.2, minY: -0.12, maxY: 0.12, width: 0.39, height: 0.24, centerX: 0, centerY: 0 }, circles: {} };
 var { paths: Yd, bounds: ns, refblocks: Xd } = ms2;
 var U = e({ primitives: [...Object.values(Yd)], ports: [{ ...Xd.left1, labels: ["1"] }], center: { x: ns.centerX, y: ns.centerY } }).rotateRightFacingSymbol("right").labelPort("left1", ["1"]).build();
-var fs54 = r(U, "down");
+var fs55 = r(U, "down");
 var hs = r(U, "left");
 var cs = r(U, "up");
 var g = { paths: { path11: { type: "path", points: [{ x: -0.4, y: 0 }, { x: 0.06, y: -0.01 }], color: "primary", fill: false }, "path40-0": { type: "path", points: [{ x: 0.07, y: 0.27 }, { x: 0.07, y: -0.28 }], color: "primary", fill: false }, "path40-0-5": { type: "path", points: [{ x: 0.28, y: 0.24 }, { x: 0.08, y: 0.11 }], color: "primary", fill: false }, "path40-0-5-0": { type: "path", points: [{ x: 0.29, y: -0.24 }, { x: 0.09, y: -0.11 }], color: "primary", fill: false }, "path12-1-5": { type: "path", points: [{ x: 0.29, y: 0.25 }, { x: 0.29, y: 0.55 }], color: "primary", fill: false }, "path12-1-5-3": { type: "path", points: [{ x: 0.29, y: -0.55 }, { x: 0.29, y: -0.25 }], color: "primary", fill: false }, path15: { type: "path", points: [{ x: 0.19, y: -0.1 }, { x: 0.12, y: -0.2 }, { x: 0.22, y: -0.2 }, { x: 0.19, y: -0.1 }], color: "primary", fill: true } }, texts: { top1: { type: "text", text: "{REF}", x: -0.08, y: 0.36 }, bottom1: { type: "text", text: "{VAL}", x: -0.07, y: -0.41 } }, refblocks: { top1: { x: 0.29, y: 0.55 }, bottom1: { x: 0.29, y: -0.55 }, left1: { x: -0.4, y: 0 } }, bounds: { minX: -0.43, maxX: 0.43, minY: -0.58, maxY: 0.58, width: 0.85, height: 1.16, centerX: 0, centerY: 0 }, circles: { "path1-0": { type: "circle", x: 0.14, y: 0, radius: 0.29, color: "primary", fill: false } } };
@@ -100585,7 +100713,7 @@ var jb = Il.primitives.find((t) => t.type === "text" && t.text === "{VAL}");
 Vb.anchor = "middle_left";
 jb.anchor = "middle_right";
 var tf = Il;
-var ef = { ac_voltmeter_down: Wl, ac_voltmeter_horz: Zl, ac_voltmeter_left: Kl, ac_voltmeter_right: ep, ac_voltmeter_up: op, ac_voltmeter_vert: lp, avalanche_diode_down: ap, avalanche_diode_horz: yp, avalanche_diode_left: sp, avalanche_diode_right: mp, avalanche_diode_up: fp, avalanche_diode_vert: cp, backward_diode_down: bp, backward_diode_left: Ut, backward_diode_right: up, backward_diode_up: vp, battery_horz: Zt, battery_vert: Sp, boxresistor_down: Tp, boxresistor_left: Xp, boxresistor_right: jp, boxresistor_small_down: zp, boxresistor_small_left: Jp, boxresistor_small_right: Mp, boxresistor_small_up: Np, boxresistor_up: qp, bridged_ground_down: Up, bridged_ground_left: Zp, bridged_ground_right: re, bridged_ground_up: ta, capacitor_down: ra, capacitor_left: oa, capacitor_polarized_down: la, capacitor_polarized_left: pa, capacitor_polarized_right: ya, capacitor_polarized_up: sa, capacitor_right: ma, capacitor_up: fa, constant_current_diode_down: ca, constant_current_diode_horz: da, constant_current_diode_left: _a, constant_current_diode_right: ga, constant_current_diode_up: va, constant_current_diode_vert: Aa, crystal_4pin_down: Pa, crystal_4pin_left: Sa, crystal_4pin_right: Fa, crystal_4pin_up: Ra, crystal_down: Ea, crystal_left: Ya, crystal_right: Xa, crystal_up: Va, darlington_pair_transistor_down: ja, darlington_pair_transistor_horz: ka, darlington_pair_transistor_left: za, darlington_pair_transistor_right: Oa, darlington_pair_transistor_up: Ja, darlington_pair_transistor_vert: $a, dc_ammeter_horz: Pt, dc_ammeter_vert: Ia, dc_voltmeter_down: qa, dc_voltmeter_horz: Ga, dc_voltmeter_left: Wa, dc_voltmeter_right: Za, dc_voltmeter_up: Ka, dc_voltmeter_vert: ey, diac_down: ry, diac_horz: oy, diac_left: iy, diac_right: ly, diac_up: py, diac_vert: ay, digital_ground_down: xy, digital_ground_left: my, digital_ground_right: fy, digital_ground_up: cy, diode_down: by, diode_left: _y, diode_right: C, diode_up: gy, dpdt_normally_closed_switch_down: vy, dpdt_normally_closed_switch_left: wy, dpdt_normally_closed_switch_right: N, dpdt_normally_closed_switch_up: Ay, dpdt_switch_down: Sy, dpdt_switch_left: Fy, dpdt_switch_right: I, dpdt_switch_up: Ry, dpst_normally_closed_switch_down: Ey, dpst_normally_closed_switch_left: Yy, dpst_normally_closed_switch_right: B, dpst_normally_closed_switch_up: Xy5, dpst_switch_down: Vy, dpst_switch_left: jy, dpst_switch_right: q, dpst_switch_up: ky2, ferrite_bead_down: Oy, ferrite_bead_left: Jy, ferrite_bead_right: Te, ferrite_bead_up: Re, filled_diode_down: My, filled_diode_horz: Ny, filled_diode_left: By, filled_diode_right: Dy, filled_diode_up: Uy, filled_diode_vert: Hy, frequency_meter_horz: St, frequency_meter_vert: tx, fuse_horz: Oe, fuse_vert: ox, ground_down: ix, ground_horz: lx, ground_left: px, ground_right: ax, ground_up: yx, ground_vert: xx, gunn_diode_horz: sx, gunn_diode_vert: mx, icled_down: fx, icled_left: hx, icled_right: D, icled_up: cx, igbt_transistor_horz: Je, igbt_transistor_vert: _x, illuminated_push_button_normally_open_horz: $e, illuminated_push_button_normally_open_vert: wx, inductor_down: Fx, inductor_left: Rx, inductor_right: ut, inductor_up: Ce, laser_diode_down: Tx, laser_diode_left: Ex, laser_diode_right: G, laser_diode_up: Yx, led_down: jx, led_left: kx, led_right: vt, led_up: Ie, light_dependent_resistor_horz: qe, light_dependent_resistor_vert: Cx, mosfet_depletion_normally_on_horz: Ge, mosfet_depletion_normally_on_vert: qx, mushroom_head_normally_open_momentary_horz: We, mushroom_head_normally_open_momentary_vert: Wx, n_channel_d_mosfet_transistor_horz: Qe, n_channel_d_mosfet_transistor_vert: ts2, n_channel_e_mosfet_transistor_horz: t0, n_channel_e_mosfet_transistor_vert: ls, njfet_transistor_horz: r0, njfet_transistor_vert: ss, not_connected_down: fs54, not_connected_left: hs, not_connected_right: U, not_connected_up: cs, npn_bipolar_transistor_down: ds, npn_bipolar_transistor_horz: bs, npn_bipolar_transistor_left: _s, npn_bipolar_transistor_right: gs, npn_bipolar_transistor_up: us, npn_bipolar_transistor_vert: vs, opamp_no_power_down: As, opamp_no_power_left: Ps, opamp_no_power_right: W, opamp_no_power_up: Ss, opamp_with_power_down: Rs, opamp_with_power_left: Ts, opamp_with_power_right: H, opamp_with_power_up: Es, p_channel_d_mosfet_transistor_horz: x0, p_channel_d_mosfet_transistor_vert: js, p_channel_e_mosfet_transistor_horz: m0, p_channel_e_mosfet_transistor_vert: $s, photodiode_horz: n0, photodiode_vert: Is, pjfet_transistor_horz: h0, pjfet_transistor_vert: Us, pnp_bipolar_transistor_down: Ws, pnp_bipolar_transistor_horz: Hs, pnp_bipolar_transistor_left: Zs, pnp_bipolar_transistor_right: Qs, pnp_bipolar_transistor_up: Ks, pnp_bipolar_transistor_vert: tm, potentiometer_horz: v0, potentiometer_vert: im, potentiometer2_down: ym, potentiometer2_left: xm, potentiometer2_right: Z, potentiometer2_up: sm, potentiometer3_down: mm2, potentiometer3_left: nm, potentiometer3_right: fm, potentiometer3_up: hm, power_factor_meter_horz: R0, power_factor_meter_vert: _m, push_button_normally_closed_momentary_horz: E0, push_button_normally_closed_momentary_vert: wm, push_button_normally_open_momentary_horz: X0, push_button_normally_open_momentary_vert: Fm, rail_down: Tm, rail_left: Ym, rail_right: Lm, rail_up: jm, rectifier_diode_horz: j0, rectifier_diode_vert: Om, resistor_down: $m, resistor_left: Cm, resistor_right: Im, resistor_up: qm, resonator_down: Gm, resonator_horz: N0, resonator_left: Um, resonator_right: et, resonator_up: Wm, resonator_vert: Hm, schottky_diode_down: Qm, schottky_diode_left: Km, schottky_diode_right: rt, schottky_diode_up: tn, silicon_controlled_rectifier_horz: I0, silicon_controlled_rectifier_vert: on2, solderjumper2_bridged12_down: ln, solderjumper2_bridged12_left: pn, solderjumper2_bridged12_right: an, solderjumper2_bridged12_up: yn, solderjumper2_down: xn, solderjumper2_left: sn, solderjumper2_right: mn, solderjumper2_up: nn, solderjumper3_bridged12_down: fn, solderjumper3_bridged12_left: hn, solderjumper3_bridged12_right: cn, solderjumper3_bridged12_up: dn, solderjumper3_bridged123_down: bn, solderjumper3_bridged123_left: _n, solderjumper3_bridged123_right: gn, solderjumper3_bridged123_up: un, solderjumper3_bridged23_down: vn, solderjumper3_bridged23_left: wn, solderjumper3_bridged23_right: An, solderjumper3_bridged23_up: Pn, solderjumper3_down: Sn, solderjumper3_left: Fn, solderjumper3_right: Rn, solderjumper3_up: Tn, spdt_normally_closed_switch_down: Yn, spdt_normally_closed_switch_left: Xn, spdt_normally_closed_switch_right: xt, spdt_normally_closed_switch_up: Ln, spdt_switch_down: jn, spdt_switch_left: kn, spdt_switch_right: st, spdt_switch_up: zn, spst_normally_closed_switch_down: On, spst_normally_closed_switch_left: Jn, spst_normally_closed_switch_right: mt, spst_normally_closed_switch_up: $n, spst_switch_down: Mn, spst_switch_left: Cn, spst_switch_right: nt, spst_switch_up: Nn, square_wave_down: In, square_wave_left: Bn, square_wave_right: qn, square_wave_up: Dn, step_recovery_diode_horz: B0, step_recovery_diode_vert: Gn, tachometer_horz: Yt, tachometer_vert: Zn, testpoint_down: t1, testpoint_left: e1, testpoint_right: ht, testpoint_up: i1, tilted_ground_down: p1, tilted_ground_left: a1, tilted_ground_right: wt, tilted_ground_up: D0, triac_horz: G0, triac_vert: s1, tunnel_diode_horz: W0, tunnel_diode_vert: h1, unijunction_transistor_horz: Z0, unijunction_transistor_vert: u1, usbc: w1, var_meter_horz: K0, var_meter_vert: S1, varactor_diode_horz: er, varactor_diode_vert: E1, varistor_horz: or, varistor_vert: V1, varmeter_horz: Xt, varmeter_vert: O1, vcc_down: J1, vcc_left: $1, vcc_right: M1, vcc_up: C1, volt_meter_horz: lr, volt_meter_vert: N1, watt_hour_meter_horz: Lt, watt_hour_meter_vert: D1, wattmeter_horz: Vt, wattmeter_vert: H1, zener_diode_horz: xr, zener_diode_vert: tf };
+var ef = { ac_voltmeter_down: Wl, ac_voltmeter_horz: Zl, ac_voltmeter_left: Kl, ac_voltmeter_right: ep, ac_voltmeter_up: op, ac_voltmeter_vert: lp, avalanche_diode_down: ap, avalanche_diode_horz: yp, avalanche_diode_left: sp, avalanche_diode_right: mp, avalanche_diode_up: fp, avalanche_diode_vert: cp, backward_diode_down: bp, backward_diode_left: Ut, backward_diode_right: up, backward_diode_up: vp, battery_horz: Zt, battery_vert: Sp, boxresistor_down: Tp, boxresistor_left: Xp, boxresistor_right: jp, boxresistor_small_down: zp, boxresistor_small_left: Jp, boxresistor_small_right: Mp, boxresistor_small_up: Np, boxresistor_up: qp, bridged_ground_down: Up, bridged_ground_left: Zp, bridged_ground_right: re, bridged_ground_up: ta, capacitor_down: ra, capacitor_left: oa, capacitor_polarized_down: la, capacitor_polarized_left: pa, capacitor_polarized_right: ya, capacitor_polarized_up: sa, capacitor_right: ma, capacitor_up: fa, constant_current_diode_down: ca, constant_current_diode_horz: da, constant_current_diode_left: _a, constant_current_diode_right: ga, constant_current_diode_up: va, constant_current_diode_vert: Aa, crystal_4pin_down: Pa, crystal_4pin_left: Sa, crystal_4pin_right: Fa, crystal_4pin_up: Ra, crystal_down: Ea, crystal_left: Ya, crystal_right: Xa, crystal_up: Va, darlington_pair_transistor_down: ja, darlington_pair_transistor_horz: ka, darlington_pair_transistor_left: za, darlington_pair_transistor_right: Oa, darlington_pair_transistor_up: Ja, darlington_pair_transistor_vert: $a, dc_ammeter_horz: Pt, dc_ammeter_vert: Ia, dc_voltmeter_down: qa, dc_voltmeter_horz: Ga, dc_voltmeter_left: Wa, dc_voltmeter_right: Za, dc_voltmeter_up: Ka, dc_voltmeter_vert: ey, diac_down: ry, diac_horz: oy, diac_left: iy, diac_right: ly, diac_up: py, diac_vert: ay, digital_ground_down: xy, digital_ground_left: my, digital_ground_right: fy, digital_ground_up: cy, diode_down: by, diode_left: _y, diode_right: C, diode_up: gy, dpdt_normally_closed_switch_down: vy, dpdt_normally_closed_switch_left: wy, dpdt_normally_closed_switch_right: N, dpdt_normally_closed_switch_up: Ay, dpdt_switch_down: Sy, dpdt_switch_left: Fy, dpdt_switch_right: I, dpdt_switch_up: Ry, dpst_normally_closed_switch_down: Ey, dpst_normally_closed_switch_left: Yy, dpst_normally_closed_switch_right: B, dpst_normally_closed_switch_up: Xy5, dpst_switch_down: Vy, dpst_switch_left: jy, dpst_switch_right: q, dpst_switch_up: ky2, ferrite_bead_down: Oy, ferrite_bead_left: Jy, ferrite_bead_right: Te, ferrite_bead_up: Re, filled_diode_down: My, filled_diode_horz: Ny, filled_diode_left: By, filled_diode_right: Dy, filled_diode_up: Uy, filled_diode_vert: Hy, frequency_meter_horz: St, frequency_meter_vert: tx, fuse_horz: Oe, fuse_vert: ox, ground_down: ix, ground_horz: lx, ground_left: px, ground_right: ax, ground_up: yx, ground_vert: xx, gunn_diode_horz: sx, gunn_diode_vert: mx, icled_down: fx, icled_left: hx, icled_right: D, icled_up: cx, igbt_transistor_horz: Je, igbt_transistor_vert: _x, illuminated_push_button_normally_open_horz: $e, illuminated_push_button_normally_open_vert: wx, inductor_down: Fx, inductor_left: Rx, inductor_right: ut, inductor_up: Ce, laser_diode_down: Tx, laser_diode_left: Ex, laser_diode_right: G, laser_diode_up: Yx, led_down: jx, led_left: kx, led_right: vt, led_up: Ie, light_dependent_resistor_horz: qe, light_dependent_resistor_vert: Cx, mosfet_depletion_normally_on_horz: Ge, mosfet_depletion_normally_on_vert: qx, mushroom_head_normally_open_momentary_horz: We, mushroom_head_normally_open_momentary_vert: Wx, n_channel_d_mosfet_transistor_horz: Qe, n_channel_d_mosfet_transistor_vert: ts2, n_channel_e_mosfet_transistor_horz: t0, n_channel_e_mosfet_transistor_vert: ls, njfet_transistor_horz: r0, njfet_transistor_vert: ss, not_connected_down: fs55, not_connected_left: hs, not_connected_right: U, not_connected_up: cs, npn_bipolar_transistor_down: ds, npn_bipolar_transistor_horz: bs, npn_bipolar_transistor_left: _s, npn_bipolar_transistor_right: gs, npn_bipolar_transistor_up: us, npn_bipolar_transistor_vert: vs, opamp_no_power_down: As, opamp_no_power_left: Ps, opamp_no_power_right: W, opamp_no_power_up: Ss, opamp_with_power_down: Rs, opamp_with_power_left: Ts, opamp_with_power_right: H, opamp_with_power_up: Es, p_channel_d_mosfet_transistor_horz: x0, p_channel_d_mosfet_transistor_vert: js, p_channel_e_mosfet_transistor_horz: m0, p_channel_e_mosfet_transistor_vert: $s, photodiode_horz: n0, photodiode_vert: Is, pjfet_transistor_horz: h0, pjfet_transistor_vert: Us, pnp_bipolar_transistor_down: Ws, pnp_bipolar_transistor_horz: Hs, pnp_bipolar_transistor_left: Zs, pnp_bipolar_transistor_right: Qs, pnp_bipolar_transistor_up: Ks, pnp_bipolar_transistor_vert: tm, potentiometer_horz: v0, potentiometer_vert: im, potentiometer2_down: ym, potentiometer2_left: xm, potentiometer2_right: Z, potentiometer2_up: sm, potentiometer3_down: mm2, potentiometer3_left: nm, potentiometer3_right: fm, potentiometer3_up: hm, power_factor_meter_horz: R0, power_factor_meter_vert: _m, push_button_normally_closed_momentary_horz: E0, push_button_normally_closed_momentary_vert: wm, push_button_normally_open_momentary_horz: X0, push_button_normally_open_momentary_vert: Fm, rail_down: Tm, rail_left: Ym, rail_right: Lm, rail_up: jm, rectifier_diode_horz: j0, rectifier_diode_vert: Om, resistor_down: $m, resistor_left: Cm, resistor_right: Im, resistor_up: qm, resonator_down: Gm, resonator_horz: N0, resonator_left: Um, resonator_right: et, resonator_up: Wm, resonator_vert: Hm, schottky_diode_down: Qm, schottky_diode_left: Km, schottky_diode_right: rt, schottky_diode_up: tn, silicon_controlled_rectifier_horz: I0, silicon_controlled_rectifier_vert: on2, solderjumper2_bridged12_down: ln, solderjumper2_bridged12_left: pn, solderjumper2_bridged12_right: an, solderjumper2_bridged12_up: yn, solderjumper2_down: xn, solderjumper2_left: sn, solderjumper2_right: mn, solderjumper2_up: nn, solderjumper3_bridged12_down: fn, solderjumper3_bridged12_left: hn, solderjumper3_bridged12_right: cn, solderjumper3_bridged12_up: dn, solderjumper3_bridged123_down: bn, solderjumper3_bridged123_left: _n, solderjumper3_bridged123_right: gn, solderjumper3_bridged123_up: un, solderjumper3_bridged23_down: vn, solderjumper3_bridged23_left: wn, solderjumper3_bridged23_right: An, solderjumper3_bridged23_up: Pn, solderjumper3_down: Sn, solderjumper3_left: Fn, solderjumper3_right: Rn, solderjumper3_up: Tn, spdt_normally_closed_switch_down: Yn, spdt_normally_closed_switch_left: Xn, spdt_normally_closed_switch_right: xt, spdt_normally_closed_switch_up: Ln, spdt_switch_down: jn, spdt_switch_left: kn, spdt_switch_right: st, spdt_switch_up: zn, spst_normally_closed_switch_down: On, spst_normally_closed_switch_left: Jn, spst_normally_closed_switch_right: mt, spst_normally_closed_switch_up: $n, spst_switch_down: Mn, spst_switch_left: Cn, spst_switch_right: nt, spst_switch_up: Nn, square_wave_down: In, square_wave_left: Bn, square_wave_right: qn, square_wave_up: Dn, step_recovery_diode_horz: B0, step_recovery_diode_vert: Gn, tachometer_horz: Yt, tachometer_vert: Zn, testpoint_down: t1, testpoint_left: e1, testpoint_right: ht, testpoint_up: i1, tilted_ground_down: p1, tilted_ground_left: a1, tilted_ground_right: wt, tilted_ground_up: D0, triac_horz: G0, triac_vert: s1, tunnel_diode_horz: W0, tunnel_diode_vert: h1, unijunction_transistor_horz: Z0, unijunction_transistor_vert: u1, usbc: w1, var_meter_horz: K0, var_meter_vert: S1, varactor_diode_horz: er, varactor_diode_vert: E1, varistor_horz: or, varistor_vert: V1, varmeter_horz: Xt, varmeter_vert: O1, vcc_down: J1, vcc_left: $1, vcc_right: M1, vcc_up: C1, volt_meter_horz: lr, volt_meter_vert: N1, watt_hour_meter_horz: Lt, watt_hour_meter_vert: D1, wattmeter_horz: Vt, wattmeter_vert: H1, zener_diode_horz: xr, zener_diode_vert: tf };
 var gM = Object.fromEntries(Object.keys(ef).map((t) => [t, t]));
 function doesLineIntersectLine([a12, a22], [b12, b22], {
   lineThickness = 0
@@ -102893,11 +103021,11 @@ var require_react_reconciler_development = __commonJS2({
           fiber = fiber.next, id--;
         return fiber;
       }
-      function copyWithSetImpl(obj, path58, index, value) {
-        if (index >= path58.length)
+      function copyWithSetImpl(obj, path59, index, value) {
+        if (index >= path59.length)
           return value;
-        var key = path58[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        updated[key] = copyWithSetImpl(obj[key], path58, index + 1, value);
+        var key = path59[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        updated[key] = copyWithSetImpl(obj[key], path59, index + 1, value);
         return updated;
       }
       function copyWithRename(obj, oldPath, newPath) {
@@ -102917,11 +103045,11 @@ var require_react_reconciler_development = __commonJS2({
         index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
         return updated;
       }
-      function copyWithDeleteImpl(obj, path58, index) {
-        var key = path58[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        if (index + 1 === path58.length)
+      function copyWithDeleteImpl(obj, path59, index) {
+        var key = path59[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        if (index + 1 === path59.length)
           return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-        updated[key] = copyWithDeleteImpl(obj[key], path58, index + 1);
+        updated[key] = copyWithDeleteImpl(obj[key], path59, index + 1);
         return updated;
       }
       function shouldSuspendImpl() {
@@ -111947,29 +112075,29 @@ Check the top-level render call using <` + componentName2 + ">.");
       var didWarnAboutNestedUpdates = false;
       var didWarnAboutFindNodeInStrictMode = {};
       var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, setErrorHandler = null, setSuspenseHandler = null;
-      overrideHookState = function(fiber, id, path58, value) {
+      overrideHookState = function(fiber, id, path59, value) {
         id = findHook(fiber, id);
-        id !== null && (path58 = copyWithSetImpl(id.memoizedState, path58, 0, value), id.memoizedState = path58, id.baseState = path58, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path58 = enqueueConcurrentRenderForLane(fiber, 2), path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2));
+        id !== null && (path59 = copyWithSetImpl(id.memoizedState, path59, 0, value), id.memoizedState = path59, id.baseState = path59, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path59 = enqueueConcurrentRenderForLane(fiber, 2), path59 !== null && scheduleUpdateOnFiber(path59, fiber, 2));
       };
-      overrideHookStateDeletePath = function(fiber, id, path58) {
+      overrideHookStateDeletePath = function(fiber, id, path59) {
         id = findHook(fiber, id);
-        id !== null && (path58 = copyWithDeleteImpl(id.memoizedState, path58, 0), id.memoizedState = path58, id.baseState = path58, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path58 = enqueueConcurrentRenderForLane(fiber, 2), path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2));
+        id !== null && (path59 = copyWithDeleteImpl(id.memoizedState, path59, 0), id.memoizedState = path59, id.baseState = path59, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path59 = enqueueConcurrentRenderForLane(fiber, 2), path59 !== null && scheduleUpdateOnFiber(path59, fiber, 2));
       };
       overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
         id = findHook(fiber, id);
         id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
       };
-      overrideProps = function(fiber, path58, value) {
-        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path58, 0, value);
+      overrideProps = function(fiber, path59, value) {
+        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path59, 0, value);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path58 = enqueueConcurrentRenderForLane(fiber, 2);
-        path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2);
+        path59 = enqueueConcurrentRenderForLane(fiber, 2);
+        path59 !== null && scheduleUpdateOnFiber(path59, fiber, 2);
       };
-      overridePropsDeletePath = function(fiber, path58) {
-        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path58, 0);
+      overridePropsDeletePath = function(fiber, path59) {
+        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path59, 0);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path58 = enqueueConcurrentRenderForLane(fiber, 2);
-        path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2);
+        path59 = enqueueConcurrentRenderForLane(fiber, 2);
+        path59 !== null && scheduleUpdateOnFiber(path59, fiber, 2);
       };
       overridePropsRenamePath = function(fiber, oldPath, newPath) {
         fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -118272,7 +118400,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 r2 = Number.parseFloat(rotation4);
@@ -118286,7 +118414,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r2) ? 0 : r2,
     label,
     labelColor,
-    path: path58,
+    path: path59,
     arrow
   };
 };
@@ -118726,15 +118854,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 i22 = 0;i22 <= numPoints; i22++) {
     const t3 = i22 / numPoints;
     const angle2 = startAngle + t3 * (endAngle - startAngle);
     const x22 = centerX + radius * Math.cos(angle2);
     const y22 = centerY + radius * Math.sin(angle2);
-    path58.push({ x: x22, y: y22 });
+    path59.push({ x: x22, y: y22 });
   }
-  return path58;
+  return path59;
 }
 var __defProp4 = Object.defineProperty;
 var __export22 = (target, all) => {
@@ -127813,17 +127941,17 @@ var ObstacleList = class {
     return obstacles;
   }
 };
-function removePathLoops(path58) {
-  if (path58.length < 4)
-    return path58;
-  const result = [{ ...path58[0] }];
-  let currentLayer = path58[0].layer;
-  for (let i22 = 1;i22 < path58.length; i22++) {
-    const currentSegment = { start: path58[i22 - 1], end: path58[i22] };
-    const isVia = path58[i22].route_type === "via" || path58[i22 - 1].route_type === "via";
-    if (path58[i22].layer !== currentLayer || isVia) {
-      result.push({ ...path58[i22] });
-      currentLayer = path58[i22].layer;
+function removePathLoops(path59) {
+  if (path59.length < 4)
+    return path59;
+  const result = [{ ...path59[0] }];
+  let currentLayer = path59[0].layer;
+  for (let i22 = 1;i22 < path59.length; i22++) {
+    const currentSegment = { start: path59[i22 - 1], end: path59[i22] };
+    const isVia = path59[i22].route_type === "via" || path59[i22 - 1].route_type === "via";
+    if (path59[i22].layer !== currentLayer || isVia) {
+      result.push({ ...path59[i22] });
+      currentLayer = path59[i22].layer;
       continue;
     }
     let intersectionFound = false;
@@ -127852,8 +127980,8 @@ function removePathLoops(path58) {
       result.push(intersectionPoint);
     }
     const lastPoint = result[result.length - 1];
-    if (lastPoint.x !== path58[i22].x || lastPoint.y !== path58[i22].y) {
-      result.push(path58[i22]);
+    if (lastPoint.x !== path59[i22].x || lastPoint.y !== path59[i22].y) {
+      result.push(path59[i22]);
     }
   }
   return result;
@@ -128342,10 +128470,10 @@ var GeneralizedAstarAutorouter = class {
       });
     }
     if (current2.parent) {
-      const path58 = [];
+      const path59 = [];
       let p22 = current2;
       while (p22) {
-        path58.unshift(p22);
+        path59.unshift(p22);
         p22 = p22.parent;
       }
       debugSolution.push({
@@ -128353,7 +128481,7 @@ var GeneralizedAstarAutorouter = class {
         pcb_component_id: "",
         pcb_fabrication_note_path_id: `note_path_${current2.x}_${current2.y}`,
         layer: "top",
-        route: path58,
+        route: path59,
         stroke_width: 0.01
       });
     }
@@ -136704,7 +136832,7 @@ var ps2 = class extends e3 {
     return t3;
   }
 };
-var fs55 = (t3) => {
+var fs56 = (t3) => {
   const e22 = [], s22 = [], n22 = [], i22 = ht2(t3);
   if (t3.connections)
     for (const e32 of t3.connections)
@@ -139327,7 +139455,7 @@ var Tn2 = class extends e3 {
       const t3 = M22.map((t42) => ({ x: t42.x, y: t42.y }));
       t3.push({ ...t3[0] }), v22.push({ points: t3, strokeColor: "rgba(0, 136, 255, 0.95)" });
     }
-    const S22 = { points: [...this.srj.connections.flatMap((t3) => t3.pointsToConnect.map((e32) => ({ ...e32, label: `${t3.name} ${e32.pcb_port_id ?? ""}` })))], rects: [...(this.srj.obstacles ?? []).map((t3) => ({ ...t3, fill: t3.layers?.includes("top") ? "rgba(255,0,0,0.25)" : t3.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)", label: t3.layers?.join(", ") }))], lines: v22 }, b22 = [S22, e22, s22, n22, i22, o22, a22, r22, h22, c22, d2, l22, u22, p22 ? t(S22, p22) : null, f2, m22, y22, g22, x22, this.solved ? t(S22, fs55(this.getOutputSimpleRouteJson())) : null].filter(Boolean);
+    const S22 = { points: [...this.srj.connections.flatMap((t3) => t3.pointsToConnect.map((e32) => ({ ...e32, label: `${t3.name} ${e32.pcb_port_id ?? ""}` })))], rects: [...(this.srj.obstacles ?? []).map((t3) => ({ ...t3, fill: t3.layers?.includes("top") ? "rgba(255,0,0,0.25)" : t3.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)", label: t3.layers?.join(", ") }))], lines: v22 }, b22 = [S22, e22, s22, n22, i22, o22, a22, r22, h22, c22, d2, l22, u22, p22 ? t(S22, p22) : null, f2, m22, y22, g22, x22, this.solved ? t(S22, fs56(this.getOutputSimpleRouteJson())) : null].filter(Boolean);
     return t(...b22);
   }
   preview() {
@@ -152798,10 +152926,10 @@ var findFirstCollision = (pts, rects, opts = {}) => {
   }
   return null;
 };
-var isPathCollidingWithObstacles = (path58, obstacles) => {
-  for (let i22 = 0;i22 < path58.length - 1; i22++) {
+var isPathCollidingWithObstacles = (path59, obstacles) => {
+  for (let i22 = 0;i22 < path59.length - 1; i22++) {
     for (const obstacle of obstacles) {
-      if (segmentIntersectsRect(path58[i22], path58[i22 + 1], obstacle)) {
+      if (segmentIntersectsRect(path59[i22], path59[i22 + 1], obstacle)) {
         return true;
       }
     }
@@ -152995,36 +153123,36 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
       this.error = "No collision-free path found";
       return;
     }
-    const { path: path58, collisionChipIds } = state;
+    const { path: path59, collisionChipIds } = state;
     const [PA, PB] = this.pins;
-    const collision = findFirstCollision(path58, this.obstacles);
+    const collision = findFirstCollision(path59, this.obstacles);
     if (!collision) {
-      const first = path58[0];
-      const last = path58[path58.length - 1];
+      const first = path59[0];
+      const last = path59[path59.length - 1];
       const EPS42 = 0.000000001;
       const samePoint = (p22, q22) => Math.abs(p22.x - q22.x) < EPS42 && Math.abs(p22.y - q22.y) < EPS42;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
-        this.solvedTracePath = path58;
+        this.solvedTracePath = path59;
         this.solved = true;
       }
       return;
     }
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
-    const isLastSegment = segIndex === path58.length - 2;
+    const isLastSegment = segIndex === path59.length - 2;
     if (isFirstSegment) {
-      if (path58.length < 3) {
+      if (path59.length < 3) {
         return;
       }
       segIndex = 1;
     } else if (isLastSegment) {
-      if (path58.length < 3) {
+      if (path59.length < 3) {
         return;
       }
-      segIndex = path58.length - 3;
+      segIndex = path59.length - 3;
     }
-    const a22 = path58[segIndex];
-    const b22 = path58[segIndex + 1];
+    const a22 = path59[segIndex];
+    const b22 = path59[segIndex + 1];
     const axis = this.axisOfSegment(a22, b22);
     if (!axis) {
       return;
@@ -153042,7 +153170,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
     }
     const newStates = [];
     for (const coord of candidates) {
-      const newPath = shiftSegmentOrth(path58, segIndex, axis, coord);
+      const newPath = shiftSegmentOrth(path59, segIndex, axis, coord);
       if (!newPath)
         continue;
       const key = pathKey(newPath);
@@ -153078,8 +153206,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
       strokeColor: "blue",
       strokeDash: "5 5"
     });
-    for (const { path: path58, collisionChipIds: collisionRectIds } of this.queue) {
-      g22.lines.push({ points: path58, strokeColor: "teal", strokeDash: "2 2" });
+    for (const { path: path59, collisionChipIds: collisionRectIds } of this.queue) {
+      g22.lines.push({ points: path59, strokeColor: "teal", strokeDash: "2 2" });
     }
     if (this.solvedTracePath) {
       g22.lines.push({ points: this.solvedTracePath, strokeColor: "green" });
@@ -153316,9 +153444,9 @@ var TraceOverlapIssueSolver = class extends BaseSolver3 {
         solvedTracePathIndex,
         traceSegmentIndex
       } of group.pathsWithOverlap) {
-        const path58 = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
-        const segStart = path58.tracePath[traceSegmentIndex];
-        const segEnd = path58.tracePath[traceSegmentIndex + 1];
+        const path59 = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+        const segStart = path59.tracePath[traceSegmentIndex];
+        const segEnd = path59.tracePath[traceSegmentIndex + 1];
         graphics.lines.push({
           points: [segStart, segEnd],
           strokeColor: "red"
@@ -153362,11 +153490,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver3 {
   computeTraceNetIslands() {
     const islands = {};
     for (const original of this.inputTracePaths) {
-      const path58 = this.correctedTraceMap[original.mspPairId] ?? original;
-      const key = path58.globalConnNetId;
+      const path59 = this.correctedTraceMap[original.mspPairId] ?? original;
+      const key = path59.globalConnNetId;
       if (!islands[key])
         islands[key] = [];
-      islands[key].push(path58);
+      islands[key].push(path59);
     }
     return islands;
   }
@@ -153614,9 +153742,9 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
   }
   return { hasIntersection: false };
 }
-function lengthOfTrace(path58) {
+function lengthOfTrace(path59) {
   let sum = 0;
-  const pts = path58.tracePath;
+  const pts = path59.tracePath;
   for (let i22 = 0;i22 < pts.length - 1; i22++) {
     sum += Math.abs(pts[i22 + 1].x - pts[i22].x) + Math.abs(pts[i22 + 1].y - pts[i22].y);
   }
@@ -154145,9 +154273,9 @@ var NetLabelPlacementSolver = class extends BaseSolver3 {
         }
         const compTraces = (byGlobal[globalConnNetId] ?? []).filter((t3) => component.has(t3.pins[0].pinId) && component.has(t3.pins[1].pinId));
         if (compTraces.length > 0) {
-          const lengthOf = (path58) => {
+          const lengthOf = (path59) => {
             let sum = 0;
-            const pts = path58.tracePath;
+            const pts = path59.tracePath;
             for (let i22 = 0;i22 < pts.length - 1; i22++) {
               sum += Math.abs(pts[i22 + 1].x - pts[i22].x) + Math.abs(pts[i22 + 1].y - pts[i22].y);
             }
@@ -154292,12 +154420,12 @@ var detectTraceLabelOverlap = (traces, netLabels) => {
   }
   return overlaps;
 };
-var findTraceViolationZone = (path58, labelBounds) => {
+var findTraceViolationZone = (path59, labelBounds) => {
   const isPointInside = (p22) => p22.x > labelBounds.minX && p22.x < labelBounds.maxX && p22.y > labelBounds.minY && p22.y < labelBounds.maxY;
   let firstInsideIndex = -1;
   let lastInsideIndex = -1;
-  for (let i22 = 0;i22 < path58.length; i22++) {
-    if (isPointInside(path58[i22])) {
+  for (let i22 = 0;i22 < path59.length; i22++) {
+    if (isPointInside(path59[i22])) {
       if (firstInsideIndex === -1) {
         firstInsideIndex = i22;
       }
@@ -154306,20 +154434,20 @@ var findTraceViolationZone = (path58, labelBounds) => {
   }
   return { firstInsideIndex, lastInsideIndex };
 };
-var simplifyPath = (path58) => {
-  if (path58.length < 3)
-    return path58;
-  const newPath = [path58[0]];
-  for (let i22 = 1;i22 < path58.length - 1; i22++) {
+var simplifyPath = (path59) => {
+  if (path59.length < 3)
+    return path59;
+  const newPath = [path59[0]];
+  for (let i22 = 1;i22 < path59.length - 1; i22++) {
     const p12 = newPath[newPath.length - 1];
-    const p22 = path58[i22];
-    const p32 = path58[i22 + 1];
+    const p22 = path59[i22];
+    const p32 = path59[i22 + 1];
     if (isVertical(p12, p22) && isVertical(p22, p32) || isHorizontal(p12, p22) && isHorizontal(p22, p32)) {
       continue;
     }
     newPath.push(p22);
   }
-  newPath.push(path58[path58.length - 1]);
+  newPath.push(path59[path59.length - 1]);
   if (newPath.length < 3)
     return newPath;
   const finalPath = [newPath[0]];
@@ -154579,12 +154707,12 @@ var hasCollisionsWithLabels = (pathSegments, labels) => {
   return false;
 };
 var minimizeTurns = ({
-  path: path58,
+  path: path59,
   obstacles,
   labelBounds
 }) => {
-  if (path58.length <= 2) {
-    return path58;
+  if (path59.length <= 2) {
+    return path59;
   }
   const recognizeStairStepPattern = (pathToCheck, startIdx) => {
     if (startIdx >= pathToCheck.length - 3)
@@ -154616,7 +154744,7 @@ var minimizeTurns = ({
     }
     return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
   };
-  let optimizedPath = [...path58];
+  let optimizedPath = [...path59];
   let currentTurns = countTurns(optimizedPath);
   let improved = true;
   while (improved) {
@@ -162221,9 +162349,9 @@ var getFileExtension = (filename) => {
   const extension = lastSegment.split(".").pop();
   return extension?.toLowerCase() ?? null;
 };
-var joinUrlPath = (base, path58) => {
+var joinUrlPath = (base, path59) => {
   const trimmedBase = base.replace(/\/+$/, "");
-  const trimmedPath = path58.replace(/^\/+/, "");
+  const trimmedPath = path59.replace(/^\/+/, "");
   return `${trimmedBase}/${trimmedPath}`;
 };
 var constructAssetUrl = (targetUrl, baseUrl) => {
@@ -163537,7 +163665,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
     for (let i22 = 0;i22 < portsWithPosition.length - 1; i22++) {
       const start = portsWithPosition[i22];
       const end = portsWithPosition[i22 + 1];
-      const path58 = calculateElbow({
+      const path59 = calculateElbow({
         x: start.position.x,
         y: start.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(start.facingDirection)
@@ -163546,8 +163674,8 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         y: end.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(end.facingDirection)
       });
-      for (let j22 = 0;j22 < path58.length - 1; j22++) {
-        elbowEdges.push({ from: path58[j22], to: path58[j22 + 1] });
+      for (let j22 = 0;j22 < path59.length - 1; j22++) {
+        elbowEdges.push({ from: path59[j22], to: path59[j22 + 1] });
       }
     }
     const doesSegmentIntersectRect2 = (edge, rect) => {
@@ -164740,20 +164868,20 @@ var parseLibraryFootprintRef = (s22) => {
 };
 var isStaticAssetPath = (s22) => s22.startsWith("/");
 var resolveStaticFileImportDebug = (0, import_debug92.default)("tscircuit:core:resolveStaticFileImport");
-async function resolveStaticFileImport(path58, platform) {
-  if (!path58)
-    return path58;
+async function resolveStaticFileImport(path59, platform) {
+  if (!path59)
+    return path59;
   const resolver = platform?.resolveProjectStaticFileImportUrl;
-  if (resolver && path58.startsWith("/")) {
+  if (resolver && path59.startsWith("/")) {
     try {
-      const resolved = await resolver(path58);
+      const resolved = await resolver(path59);
       if (resolved)
         return resolved;
     } catch (error) {
       resolveStaticFileImportDebug("failed to resolve static file via platform resolver", error);
     }
   }
-  return constructAssetUrl(path58, platform?.projectBaseUrl);
+  return constructAssetUrl(path59, platform?.projectBaseUrl);
 }
 function NormalComponent_doInitialPcbFootprintStringRender(component, queueAsyncEffect) {
   let { footprint } = component.props;
@@ -169841,7 +169969,7 @@ var Group6 = class extends NormalComponent3 {
       });
     }
     if (debug112.enabled) {
-      const graphicsObject = fs55(simpleRouteJson);
+      const graphicsObject = fs56(simpleRouteJson);
       graphicsObject.title = `autorouting-${this.props.name}`;
       global.debugGraphics?.push(graphicsObject);
     }
@@ -172400,7 +172528,7 @@ var NetLabel = class extends PrimitiveComponent2 {
       }
       const portPos = port._getGlobalSchematicPositionAfterLayout();
       const portFacing = convertFacingDirectionToElbowDirection(port.facingDirection ?? "right") ?? "x+";
-      const path58 = calculateElbow({
+      const path59 = calculateElbow({
         x: portPos.x,
         y: portPos.y,
         facingDirection: portFacing
@@ -172409,13 +172537,13 @@ var NetLabel = class extends PrimitiveComponent2 {
         y: anchorPos.y,
         facingDirection: anchorFacing
       });
-      if (!Array.isArray(path58) || path58.length < 2)
+      if (!Array.isArray(path59) || path59.length < 2)
         continue;
       const edges = [];
-      for (let i22 = 0;i22 < path58.length - 1; i22++) {
+      for (let i22 = 0;i22 < path59.length - 1; i22++) {
         edges.push({
-          from: { x: path58[i22].x, y: path58[i22].y },
-          to: { x: path58[i22 + 1].x, y: path58[i22 + 1].y }
+          from: { x: path59[i22].x, y: path59[i22].y },
+          to: { x: path59[i22 + 1].x, y: path59[i22 + 1].y }
         });
       }
       let source_trace_id;
@@ -174727,8 +174855,8 @@ react/cjs/react-jsx-runtime.development.js:
 */
 
 // lib/import/import-component-from-jlcpcb.ts
-import fs56 from "node:fs/promises";
-import path58 from "node:path";
+import fs57 from "node:fs/promises";
+import path59 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd()) => {
   const component = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const tsx = await convertRawEasyToTsx(component);
@@ -174736,10 +174864,10 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
   if (!fileName) {
     throw new Error("Could not determine file name of converted component");
   }
-  const importsDir = path58.join(projectDir, "imports");
-  await fs56.mkdir(importsDir, { recursive: true });
-  const filePath = path58.join(importsDir, `${fileName}.tsx`);
-  await fs56.writeFile(filePath, tsx);
+  const importsDir = path59.join(projectDir, "imports");
+  await fs57.mkdir(importsDir, { recursive: true });
+  const filePath = path59.join(importsDir, `${fileName}.tsx`);
+  await fs57.writeFile(filePath, tsx);
   return { filePath };
 };
 
@@ -176084,13 +176212,13 @@ var registerImport = (program2) => {
 };
 
 // cli/init/register.ts
-import * as fs58 from "node:fs";
-import * as path61 from "node:path";
+import * as fs59 from "node:fs";
+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/
 
@@ -176125,8 +176253,8 @@ yarn-error.log*
 };
 
 // lib/shared/setup-tscircuit-skill.ts
-import * as fs57 from "node:fs";
-import * as path60 from "node:path";
+import * as fs58 from "node:fs";
+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",
@@ -176149,35 +176277,35 @@ 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 });
+      fs58.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${apiUrl}/${item.name}`, targetPath);
     } else if (item.type === "file" && item.download_url) {
       const content = await fetchFileContent(item.download_url);
-      fs57.writeFileSync(targetPath, content, "utf-8");
+      fs58.writeFileSync(targetPath, content, "utf-8");
     }
   }
 }
 async function downloadSkillRepo(targetDir) {
-  fs57.mkdirSync(targetDir, { recursive: true });
+  fs58.mkdirSync(targetDir, { recursive: true });
   const rootContents = await fetchGitHubContents(SKILL_REPO_API_URL);
   for (const item of rootContents) {
     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 });
+      fs58.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${SKILL_REPO_API_URL}/${item.name}`, targetPath);
     } else if (item.type === "file" && item.download_url) {
       const content = await fetchFileContent(item.download_url);
-      fs57.writeFileSync(targetPath, content, "utf-8");
+      fs58.writeFileSync(targetPath, content, "utf-8");
     }
   }
 }
 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) => !fs58.existsSync(path61.join(projectDir, skillPath, "SKILL.md")));
   if (missingSkillPaths.length === 0) {
     console.log("TSCircuit AI skills already exist, skipping...");
     return true;
@@ -176197,7 +176325,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}`);
     }
@@ -176301,7 +176429,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) {
@@ -176312,7 +176440,7 @@ var registerInit = (program3) => {
         }
       } catch {}
     }
-    const dirName = path61.basename(projectDir);
+    const dirName = path62.basename(projectDir);
     let defaultPackageName = dirName;
     if (tsciHandle) {
       defaultPackageName = `@tsci/${tsciHandle}.${dirName}`;
@@ -176330,8 +176458,8 @@ var registerInit = (program3) => {
         authorName = account.tscircuit_handle;
       }
     }
-    fs58.mkdirSync(projectDir, { recursive: true });
-    writeFileIfNotExists(path61.join(projectDir, "index.circuit.tsx"), `
+    fs59.mkdirSync(projectDir, { recursive: true });
+    writeFileIfNotExists(path62.join(projectDir, "index.circuit.tsx"), `
 export default () => (
   <board>
     <resistor resistance="1k" footprint="0402" name="R1" />
@@ -176343,7 +176471,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");
@@ -176596,14 +176724,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path62 = null;
+  let path63 = null;
   let id = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path62 = createKeyPath(key);
+    path63 = createKeyPath(key);
     id = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -176617,11 +176745,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path62 = createKeyPath(name);
+    path63 = createKeyPath(name);
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path62, id, weight, src, getFn };
+  return { path: path63, id, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -176629,34 +176757,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path62) {
+function get(obj, path63) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path63, index) => {
+  const deepGet = (obj2, path64, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path63[index]) {
+    if (!path64[index]) {
       list.push(obj2);
     } else {
-      let key = path63[index];
+      let key = path64[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path63.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
+      if (index === path64.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
         list.push(toString(value));
       } else if (isArray(value)) {
         arr = true;
         for (let i3 = 0, len = value.length;i3 < len; i3 += 1) {
-          deepGet(value[i3], path63, index + 1);
+          deepGet(value[i3], path64, index + 1);
         }
-      } else if (path63.length) {
-        deepGet(value, path63, index + 1);
+      } else if (path64.length) {
+        deepGet(value, path64, index + 1);
       }
     }
   };
-  deepGet(obj, isString2(path62) ? path62.split(".") : path62, 0);
+  deepGet(obj, isString2(path63) ? path63.split(".") : path63, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -177852,9 +177980,9 @@ var registerSearch = (program3) => {
     }
     if (opts.json) {
       const unifiedResults = [
-        ...kicadResults.map((path62) => ({
+        ...kicadResults.map((path63) => ({
           source: "kicad",
-          path: path62
+          path: path63
         })),
         ...results.packages.map((pkg) => ({
           source: "tscircuit",
@@ -177882,8 +178010,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path62, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path62.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path63, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path63.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (results.packages.length) {
@@ -177907,22 +178035,22 @@ var registerSearch = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs59 from "node:fs";
-import path62 from "node:path";
+import fs60 from "node:fs";
+import path63 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path62.resolve(startDir);
-    while (dir !== path62.parse(dir).root) {
-      if (fs59.existsSync(path62.join(dir, ".git"))) {
+    let dir = path63.resolve(startDir);
+    while (dir !== path63.parse(dir).root) {
+      if (fs60.existsSync(path63.join(dir, ".git"))) {
         return dir;
       }
-      dir = path62.dirname(dir);
+      dir = path63.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path62.join(gitRoot, ".github", "workflows");
-  fs59.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path63.join(gitRoot, ".github", "workflows");
+  fs60.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -177961,8 +178089,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path62.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path62.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path63.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path63.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -178129,21 +178257,21 @@ function applyCameraPreset(preset, cam) {
 }
 
 // lib/shared/snapshot-project.ts
-import path65 from "node:path";
+import path66 from "node:path";
 
 // cli/snapshot/worker-pool.ts
-import fs60 from "node:fs";
-import path63 from "node:path";
+import fs61 from "node:fs";
+import path64 from "node:path";
 var getWorkerEntrypointPath2 = () => {
-  const tsPath = path63.join(import.meta.dir, "snapshot.worker.ts");
-  if (fs60.existsSync(tsPath)) {
+  const tsPath = path64.join(import.meta.dir, "snapshot.worker.ts");
+  if (fs61.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path63.join(import.meta.dir, "snapshot", "snapshot.worker.js");
-  if (fs60.existsSync(jsBundledPath)) {
+  const jsBundledPath = path64.join(import.meta.dir, "snapshot", "snapshot.worker.js");
+  if (fs61.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path63.join(import.meta.dir, "snapshot.worker.js");
+  return path64.join(import.meta.dir, "snapshot.worker.js");
 };
 var snapshotFilesWithWorkerPool = async (options) => {
   const cancellationError = new Error("Snapshot cancelled due to file failure");
@@ -178210,8 +178338,8 @@ var snapshotFilesWithWorkerPool = async (options) => {
 };
 
 // lib/shared/process-snapshot-file.ts
-import fs62 from "node:fs";
-import path64 from "node:path";
+import fs63 from "node:fs";
+import path65 from "node:path";
 import {
   convertCircuitJsonToGltf as convertCircuitJsonToGltf5,
   getBestCameraPosition
@@ -178224,7 +178352,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs61 from "node:fs/promises";
+import fs62 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -178240,7 +178368,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true)
         tolerance: 2
       });
     } else {
-      await fs61.writeFile(diffPath, buffer2);
+      await fs62.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -178260,7 +178388,7 @@ var processSnapshotFile = async ({
   createDiff,
   cameraPreset
 }) => {
-  const relativeFilePath = path64.relative(projectDir, file);
+  const relativeFilePath = path65.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -178270,7 +178398,7 @@ var processSnapshotFile = async ({
   let schSvg;
   try {
     if (isCircuitJsonFile(file)) {
-      const parsed = JSON.parse(fs62.readFileSync(file, "utf-8"));
+      const parsed = JSON.parse(fs63.readFileSync(file, "utf-8"));
       circuitJson = Array.isArray(parsed) ? parsed : [];
     } else {
       const completePlatformConfig = getCompletePlatformConfig(platformConfig2);
@@ -178341,12 +178469,12 @@ 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 = path64.dirname(file);
-        const relativeDir = path64.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path64.join(projectDir, snapshotsDirName, relativeDir) : path64.join(fileDir, "__snapshots__");
-        const base2 = path64.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path64.join(snapDir2, `${base2}-3d.snap.png`);
-        const existing3dSnapshot = fs62.existsSync(snap3dPath);
+        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 existing3dSnapshot = fs63.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
             ok: false,
@@ -178357,7 +178485,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: ${path64.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path65.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -178378,9 +178506,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path64.join(projectDir, snapshotsDirName, path64.relative(projectDir, path64.dirname(file))) : path64.join(path64.dirname(file), "__snapshots__");
-  fs62.mkdirSync(snapDir, { recursive: true });
-  const base = path64.basename(file).replace(/\.[^.]+$/, "");
+  const snapDir = snapshotsDirName ? path65.join(projectDir, snapshotsDirName, path65.relative(projectDir, path65.dirname(file))) : path65.join(path65.dirname(file), "__snapshots__");
+  fs63.mkdirSync(snapDir, { recursive: true });
+  const base = path65.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (pcbOnly || !schematicOnly) {
     snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -178394,31 +178522,31 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path64.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-    const existing = fs62.existsSync(snapPath);
+    const snapPath = path65.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) {
-      fs62.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path64.relative(projectDir, snapPath));
+      fs63.writeFileSync(snapPath, newContentForFile);
+      successPaths.push(path65.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
-    const oldContentBuffer = fs62.readFileSync(snapPath);
+    const oldContentBuffer = fs63.readFileSync(snapPath);
     const diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
     const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath, createDiff);
     if (update) {
       if (!forceUpdate && equal2) {
-        successPaths.push(path64.relative(projectDir, snapPath));
+        successPaths.push(path65.relative(projectDir, snapPath));
       } else {
-        fs62.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path64.relative(projectDir, snapPath));
+        fs63.writeFileSync(snapPath, newContentForFile);
+        successPaths.push(path65.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal2) {
       mismatches.push(createDiff ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path64.relative(projectDir, snapPath));
+      successPaths.push(path65.relative(projectDir, snapPath));
     }
   }
   return {
@@ -178455,7 +178583,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path65.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path66.resolve(projectDir, f2));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -178585,7 +178713,7 @@ var registerSnapshot = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path66 from "node:path";
+import path67 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 {
@@ -178593,7 +178721,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path66.join(projectDir, "dist");
+      const distDir = path67.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];
@@ -178660,6 +178788,7 @@ registerUpgradeCommand(program2);
 registerDoctor(program2);
 registerCheck(program2);
 registerCheckNetlist(program2);
+registerCheckPinSpecification(program2);
 registerCheckPlacement(program2);
 registerCheckRouting(program2);
 registerRegistry(program2);