npm - @tscircuit/cli - Versions diffs - 0.1.1623 → 0.1.1625 - Mend

@tscircuit/cli 0.1.1623 → 0.1.1625

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/cli/main.js CHANGED Viewed

@@ -90028,7 +90028,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
   module2.exports = __toCommonJS2(src_exports);
   var import_glob_promise = __toESM4(require_lib5());
   var import_path2 = __toESM4(__require("path"));
-  var import_promises9 = __toESM4(__require("fs/promises"));
+  var import_promises10 = __toESM4(__require("fs/promises"));
   var import_fs5 = __toESM4(__require("fs"));
   var import_path = __toESM4(__require("path"));
   var writeVfsToDirectory = async (opts) => {
@@ -90074,7 +90074,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
     const filePaths = await getMatchingFilePaths(opts);
     const vfs = {};
     for (const filePath of filePaths) {
-      vfs[filePath] = await import_promises9.default.readFile(import_path2.default.resolve(dirPath, filePath));
+      vfs[filePath] = await import_promises10.default.readFile(import_path2.default.resolve(dirPath, filePath));
       if (contentFormat === "string") {
         vfs[filePath] = vfs[filePath].toString();
       }
@@ -93628,7 +93628,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1622";
+var version = "0.1.1623";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -93640,6 +93640,7 @@ var package_default = {
   devDependencies: {
     "@babel/standalone": "^7.26.9",
     "@biomejs/biome": "^1.9.4",
+    "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.4.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.5",
     "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#b6d5fe675adc26a2fc988aa081e6fb51e6bf696a",
@@ -93666,6 +93667,7 @@ var package_default = {
     "circuit-json": "^0.0.438",
     "circuit-json-to-3d-png": "^0.0.6",
     "circuit-json-to-bom-csv": "^0.0.7",
+    "circuit-json-to-connectivity-map": "^0.0.25",
     "circuit-json-to-gerber": "^0.0.51",
     "circuit-json-to-kicad": "0.0.157",
     "circuit-json-to-pnp-csv": "^0.0.7",
@@ -93674,6 +93676,8 @@ var package_default = {
     "circuit-json-to-step": "^0.0.36",
     "circuit-json-to-tscircuit": "^0.0.40",
     "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
+    "circuit-to-canvas": "^0.0.111",
+    "circuit-to-svg": "^0.0.378",
     commander: "^14.0.0",
     conf: "^13.1.0",
     configstore: "^7.0.0",
@@ -258579,6 +258583,126 @@ var registerCheckSchematicPlacement = (program2) => {
   });
 };
+// cli/check/shorts/register.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import path46 from "node:path";
+var checkShortsPackageName = ["@tscircuit", "check-shorts"].join("/");
+var loadCheckShorts = async () => await import(checkShortsPackageName);
+var parsePixelsPerMm = (value) => {
+  if (!value)
+    return;
+  const parsedValue = Number(value);
+  if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+    throw new Error("--pixels-per-mm must be a positive number");
+  }
+  return parsedValue;
+};
+var parseMode = (mode) => {
+  if (!mode)
+    return "gerber";
+  if (mode === "pcb" || mode === "gerber")
+    return mode;
+  throw new Error("--mode must be either pcb or gerber");
+};
+var parseLayer = (layer) => {
+  if (!layer)
+    return "all";
+  if (layer === "top" || layer === "bottom" || layer === "all")
+    return layer;
+  throw new Error("--layer must be top, bottom, or all");
+};
+var formatLabels = (labels) => labels.length > 0 ? labels.join(", ") : "(unknown)";
+var formatShort = (short, index) => {
+  const center2 = `x=${short.center.x.toFixed(3)}mm y=${short.center.y.toFixed(3)}mm`;
+  return [
+    `${index + 1}. ${short.layer}/${short.mode} short at ${center2}`,
+    `   ${formatLabels(short.firstOwnerLabels)} <-> ${formatLabels(short.secondOwnerLabels)}`,
+    `   pixels=${short.pixelCount}`
+  ].join(`
+`);
+};
+var getShortArtifactOutputPath = () => path46.resolve(process.cwd(), "checks", "check-shorts", "bitmap.png");
+var getShortPcbSnapshotOutputPath = () => path46.resolve(process.cwd(), "checks", "check-shorts", "pcb.svg");
+var checkShorts = async (file, options = {}) => {
+  const resolvedInputFilePath = await resolveCheckInputFilePath(file);
+  const mode = parseMode(options.mode);
+  const layerOption = parseLayer(options.layer);
+  const layers = layerOption === "all" ? ["top", "bottom"] : [layerOption];
+  const pixelsPerMm = parsePixelsPerMm(options.pixelsPerMm);
+  const circuitJson = await getCircuitJsonForCheck({
+    filePath: resolvedInputFilePath,
+    platformConfig: {
+      pcbDisabled: false,
+      routingDisabled: true
+    },
+    allowPrebuiltCircuitJson: true
+  });
+  const {
+    appendBitmapLegend,
+    createShortDebugSvg,
+    encodeRgbaPng,
+    renderBitmapShortDebug
+  } = await loadCheckShorts();
+  const debugRenders = await Promise.all(layers.map((layer) => renderBitmapShortDebug(circuitJson, {
+    mode,
+    layer,
+    pixelsPerMm
+  })));
+  const shorts = debugRenders.flatMap((debugRender) => debugRender.shorts);
+  const filename = path46.basename(resolvedInputFilePath);
+  if (shorts.length === 0) {
+    return {
+      output: `No shorts detected in ${filename}`,
+      shorts
+    };
+  }
+  const debugRenderWithShorts = debugRenders.find((debugRender) => debugRender.shorts.length > 0) ?? debugRenders[0];
+  const debugRenderWithLegend = appendBitmapLegend(debugRenderWithShorts);
+  const artifacts = [
+    {
+      content: encodeRgbaPng(debugRenderWithLegend),
+      contentType: "image/png",
+      defaultOutputPath: getShortArtifactOutputPath()
+    },
+    {
+      content: createShortDebugSvg(circuitJson, shorts),
+      contentType: "image/svg+xml",
+      defaultOutputPath: getShortPcbSnapshotOutputPath()
+    }
+  ];
+  return {
+    output: [
+      `Detected ${shorts.length} short${shorts.length === 1 ? "" : "s"} in ${filename}`,
+      ...shorts.map(formatShort)
+    ].join(`
+`),
+    shorts,
+    artifacts
+  };
+};
+var registerCheckShorts = (program2) => {
+  program2.commands.find((c3) => c3.name() === "check").command("shorts").description("Detect unintended shorts between separate PCB copper groups").argument("[file]", "Path to the entry file or prebuilt circuit JSON").option("--mode <mode>", "Bitmap source to analyze: pcb or gerber", "gerber").option("--layer <layer>", "Layer to analyze: top, bottom, or all", "all").option("--pixels-per-mm <number>", "Bitmap resolution for short detection").action(async (file, options) => {
+    try {
+      const result = await checkShorts(file, options);
+      console.log(result.output);
+      if (result.artifacts) {
+        for (const artifact of result.artifacts) {
+          const outputPath = artifact.defaultOutputPath;
+          await mkdir(path46.dirname(outputPath), { recursive: true });
+          await writeFile(outputPath, artifact.content);
+          console.log(`Short debug artifact written to ${outputPath}`);
+        }
+      }
+      if (result.shorts.length > 0) {
+        process.exit(1);
+      }
+    } catch (error2) {
+      console.error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(1);
+    }
+  });
+};
 // cli/check/trace-length/register.ts
 var loadTraceLengthAnalyzer = async () => {
   const mod = await Promise.resolve().then(() => (init_lib(), exports_lib));
@@ -258614,25 +258738,25 @@ var registerCheckTraceLength = (program2) => {
 // cli/clone/register.ts
 import * as fs45 from "node:fs";
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 // cli/clone/clone-bug-report.ts
 var import_jszip3 = __toESM2(require_lib4(), 1);
 var import_prompts5 = __toESM2(require_prompts3(), 1);
 import * as fs44 from "node:fs";
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 // cli/clone/handle-existing-directory.ts
 var import_prompts4 = __toESM2(require_prompts3(), 1);
 import * as fs43 from "node:fs";
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 var handleExistingDirectory = async (dirPath) => {
   if (!fs43.existsSync(dirPath))
     return;
   const response = await import_prompts4.default({
     type: "select",
     name: "action",
-    message: `Directory "${path46.basename(dirPath)}" already exists. What would you like to do?`,
+    message: `Directory "${path47.basename(dirPath)}" already exists. What would you like to do?`,
     choices: [
       { title: "Merge files into existing directory", value: "merge" },
       {
@@ -258673,12 +258797,12 @@ var getCommonDirectoryPrefix = (paths) => {
   return commonSegments.join("/");
 };
 var sanitizeRelativePath = (relativePath) => {
-  const normalizedPath = path47.normalize(relativePath);
+  const normalizedPath = path48.normalize(relativePath);
   if (!normalizedPath)
     return null;
-  if (path47.isAbsolute(normalizedPath))
+  if (path48.isAbsolute(normalizedPath))
     return null;
-  const segments = normalizedPath.split(path47.sep);
+  const segments = normalizedPath.split(path48.sep);
   if (segments.some((segment2) => segment2 === ".." || segment2 === "")) {
     return null;
   }
@@ -258693,7 +258817,7 @@ var cloneBugReport = async ({
     console.error("Bug report ID must not be empty.");
     process.exit(1);
   }
-  let dirPath = path47.resolve(`bug-report-${trimmedBugReportId}`);
+  let dirPath = path48.resolve(`bug-report-${trimmedBugReportId}`);
   await handleExistingDirectory(dirPath);
   const ky4 = getRegistryApiKy();
   let zipBuffer;
@@ -258723,25 +258847,25 @@ var cloneBugReport = async ({
       console.warn(`Skipping potentially unsafe path: ${fileName}`);
       continue;
     }
-    const fullPath = path47.join(dirPath, sanitizedRelativePath);
-    fs44.mkdirSync(path47.dirname(fullPath), { recursive: true });
+    const fullPath = path48.join(dirPath, sanitizedRelativePath);
+    fs44.mkdirSync(path48.dirname(fullPath), { recursive: true });
     const fileContent = await entry.async("nodebuffer");
     fs44.writeFileSync(fullPath, fileContent);
   }
-  const packageJsonPath = path47.join(dirPath, "package.json");
+  const packageJsonPath = path48.join(dirPath, "package.json");
   if (fs44.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs44.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 = path47.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
+        const suggestedDirPath = path48.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
         if (suggestedDirPath !== dirPath) {
           const response = await import_prompts5.default({
             type: "confirm",
             name: "rename",
             initial: true,
-            message: `Rename the directory to "${path47.basename(suggestedDirPath)}"?`
+            message: `Rename the directory to "${path48.basename(suggestedDirPath)}"?`
           });
           if (response.rename) {
             await handleExistingDirectory(suggestedDirPath);
@@ -258754,9 +258878,9 @@ var cloneBugReport = async ({
       console.warn("Unable to read package name for renaming:", error2);
     }
   }
-  fs44.writeFileSync(path47.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+  fs44.writeFileSync(path48.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
   generateTsConfig(dirPath);
-  const relativeDirPath = path47.relative(originalCwd, dirPath);
+  const relativeDirPath = path48.relative(originalCwd, dirPath);
   console.log(kleur_default.green(`
 Successfully cloned bug report to:`));
   console.log(`  ${dirPath}/
@@ -258795,7 +258919,7 @@ var registerClone = (program2) => {
     const [, author, packageName] = match;
     console.log(`Cloning ${author}/${packageName}...`);
     const userSettingToIncludeAuthor = options.includeAuthor || cliConfig.get("alwaysCloneWithAuthorName");
-    const dirPath = userSettingToIncludeAuthor ? path48.resolve(`${author}.${packageName}`) : path48.resolve(packageName);
+    const dirPath = userSettingToIncludeAuthor ? path49.resolve(`${author}.${packageName}`) : path49.resolve(packageName);
     await handleExistingDirectory(dirPath);
     const ky4 = getRegistryApiKy();
     let packageFileList = {
@@ -258821,8 +258945,8 @@ var registerClone = (program2) => {
       const filePath = fileInfo.file_path.replace(/^\/+/, "");
       if (!filePath)
         continue;
-      const fullPath = path48.join(dirPath, filePath);
-      fs45.mkdirSync(path48.dirname(fullPath), { recursive: true });
+      const fullPath = path49.join(dirPath, filePath);
+      fs45.mkdirSync(path49.dirname(fullPath), { recursive: true });
       try {
         const fileContent = await ky4.get("package_files/get", {
           searchParams: {
@@ -258848,10 +258972,10 @@ var registerClone = (program2) => {
         console.warn(`Skipping ${filePath} due to error:`, error2 instanceof Error ? error2.message : error2);
       }
     }
-    fs45.writeFileSync(path48.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+    fs45.writeFileSync(path49.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
     generateTsConfig(dirPath);
     await setupTsciProject(dirPath);
-    const relativeDirPath = path48.relative(originalCwd, dirPath);
+    const relativeDirPath = path49.relative(originalCwd, dirPath);
     console.log(kleur_default.green(`
 Successfully cloned to:`));
     console.log(`  ${dirPath}/
@@ -258919,7 +259043,7 @@ var registerConfigSet = (program2) => {
 // cli/convert/register.ts
 import fs46 from "node:fs/promises";
-import path49 from "node:path";
+import path50 from "node:path";
 import { KicadFootprintToCircuitJsonConverter } from "kicad-to-circuit-json";
 // node_modules/@tscircuit/mm/dist/index.js
@@ -259609,12 +259733,12 @@ var generateSymbolTsx = (circuitJson) => {
     const isDashed = rect.is_dashed ?? false;
     elementStrings.push(`<schematicrect schX={${center2.x}} schY={${center2.y}} width={${width}} height={${height}} rotation={${rotation11}} strokeWidth={${strokeWidth}} color="${color}" isFilled={${isFilled}} fillColor="${fillColor}" isDashed={${isDashed}} />`);
   }
-  for (const path49 of schematicPaths) {
-    const points = path49.points ?? [];
-    const fillColor = path49.fill_color ?? "red";
-    const isFilled = path49.is_filled ?? false;
-    const dashLength = path49.dash_length;
-    const dashGap = path49.dash_gap;
+  for (const path50 of schematicPaths) {
+    const points = path50.points ?? [];
+    const fillColor = path50.fill_color ?? "red";
+    const isFilled = path50.is_filled ?? false;
+    const dashLength = path50.dash_length;
+    const dashGap = path50.dash_gap;
     const attrs = [
       `points={${JSON.stringify(points)}}`,
       `strokeColor="${fillColor}"`,
@@ -259776,17 +259900,17 @@ 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 = path49.resolve(file);
+      const inputPath = path50.resolve(file);
       const modContent = await fs46.readFile(inputPath, "utf-8");
       const converter = new KicadFootprintToCircuitJsonConverter;
-      converter.addFile(path49.basename(inputPath), modContent);
+      converter.addFile(path50.basename(inputPath), modContent);
       converter.runUntilFinished();
       const circuitJson = converter.getOutput();
-      const componentName = options.name ?? path49.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path50.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path49.resolve(options.output) : path49.join(path49.dirname(inputPath), `${componentName}.tsx`);
+      const outputPath = options.output ? path50.resolve(options.output) : path50.join(path50.dirname(inputPath), `${componentName}.tsx`);
       await fs46.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error2) {
@@ -259799,11 +259923,11 @@ var registerConvert = (program2) => {
 // cli/dev/register.ts
 import * as fs53 from "node:fs";
 import * as net from "node:net";
-import * as path58 from "node:path";
+import * as path59 from "node:path";
 // cli/dev/resolve-dev-target.ts
 import * as fs47 from "node:fs";
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 var findSelectableFiles = (projectDir) => {
   const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs47.existsSync(file)).sort();
   if (boardFiles.length > 0) {
@@ -259813,7 +259937,7 @@ var findSelectableFiles = (projectDir) => {
     cwd: projectDir,
     ignore: DEFAULT_IGNORED_PATTERNS
   });
-  return files.map((file) => path50.resolve(projectDir, file)).filter((file) => fs47.existsSync(file)).sort();
+  return files.map((file) => path51.resolve(projectDir, file)).filter((file) => fs47.existsSync(file)).sort();
 };
 var isValidDevFile = (filePath) => {
   return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
@@ -259821,7 +259945,7 @@ var isValidDevFile = (filePath) => {
 var resolveDevTarget = async (file) => {
   let projectDir = process.cwd();
   if (file) {
-    const resolvedPath = path50.resolve(file);
+    const resolvedPath = path51.resolve(file);
     if (fs47.existsSync(resolvedPath) && fs47.statSync(resolvedPath).isDirectory()) {
       projectDir = resolvedPath;
       const availableFiles2 = findSelectableFiles(projectDir);
@@ -259829,7 +259953,7 @@ var resolveDevTarget = async (file) => {
         console.log(`No .tsx, .ts, or .circuit.json files found in ${projectDir}. Run 'tsci init' to bootstrap a basic project.`);
         return null;
       }
-      console.log("Selected file:", path50.relative(projectDir, availableFiles2[0]));
+      console.log("Selected file:", path51.relative(projectDir, availableFiles2[0]));
       return { absolutePath: availableFiles2[0], projectDir };
     }
     if (!fs47.existsSync(resolvedPath)) {
@@ -259852,13 +259976,13 @@ 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:", path50.relative(projectDir, availableFiles[0]));
+  console.log("Selected file:", path51.relative(projectDir, availableFiles[0]));
   return { absolutePath: availableFiles[0], projectDir };
 };
 // lib/dev/DevServer.ts
 import fs52 from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -259937,7 +260061,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path51) => statMethod(path51, { bigint: true });
+      this._stat = (path52) => statMethod(path52, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -259962,8 +260086,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path51, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path51));
+          const { path: path52, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path52));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -260003,20 +260127,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path51, depth) {
+  async _exploreDir(path52, depth) {
     let files;
     try {
-      files = await readdir(path51, this._rdOptions);
+      files = await readdir(path52, this._rdOptions);
     } catch (error2) {
       this._onError(error2);
     }
-    return { files, depth, path: path51 };
+    return { files, depth, path: path52 };
   }
-  async _formatEntry(dirent, path51) {
+  async _formatEntry(dirent, path52) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path51, basename4));
+      const fullPath = presolve(pjoin(path52, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -260414,16 +260538,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path51, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path52, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path51);
-    emitRaw(rawEvent, evPath, { watchedPath: path51 });
-    if (evPath && path51 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path51, evPath), KEY_LISTENERS, sysPath.join(path51, evPath));
+    listener(path52);
+    emitRaw(rawEvent, evPath, { watchedPath: path52 });
+    if (evPath && path52 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path52, evPath), KEY_LISTENERS, sysPath.join(path52, evPath));
     }
   };
   try {
-    return fs_watch(path51, {
+    return fs_watch(path52, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error2) {
@@ -260439,12 +260563,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path51, fullPath, options, handlers) => {
+var setFsWatchListener = (path52, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path51, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path52, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -260454,7 +260578,7 @@ var setFsWatchListener = (path51, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path51, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path52, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error2) => {
@@ -260463,7 +260587,7 @@ var setFsWatchListener = (path51, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error2.code === "EPERM") {
         try {
-          const fd3 = await open(path51, "r");
+          const fd3 = await open(path52, "r");
           await fd3.close();
           broadcastErr(error2);
         } catch (err) {}
@@ -260493,7 +260617,7 @@ var setFsWatchListener = (path51, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path51, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path52, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -260515,7 +260639,7 @@ var setFsWatchFileListener = (path51, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path51, curr));
+          foreach(cont.listeners, (listener2) => listener2(path52, curr));
         }
       })
     };
@@ -260538,13 +260662,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error2) => fsW._handleError(error2);
   }
-  _watchWithNodeFs(path51, listener) {
+  _watchWithNodeFs(path52, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path51);
-    const basename5 = sysPath.basename(path51);
+    const directory = sysPath.dirname(path52);
+    const basename5 = sysPath.basename(path52);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sysPath.resolve(path51);
+    const absolutePath = sysPath.resolve(path52);
     const options = {
       persistent: opts.persistent
     };
@@ -260554,12 +260678,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path51, absolutePath, options, {
+      closer = setFsWatchFileListener(path52, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path51, absolutePath, options, {
+      closer = setFsWatchListener(path52, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -260577,7 +260701,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path51, newStats) => {
+    const listener = async (path52, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -260591,11 +260715,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path51);
+            this.fsw._closeFile(path52);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path51, closer2);
+              this.fsw._addPathCloser(path52, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -260619,7 +260743,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path51, item) {
+  async _handleSymlink(entry, directory, path52, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -260629,7 +260753,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path51);
+        linkPath = await fsrealpath(path52);
       } catch (e4) {
         this.fsw._emitReady();
         return true;
@@ -260639,12 +260763,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, path51, entry.stats);
+          this.fsw._emit(EV.CHANGE, path52, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path51, entry.stats);
+        this.fsw._emit(EV.ADD, path52, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -260673,9 +260797,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path51 = sysPath.join(directory, item);
+      let path52 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path51, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path52, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -260684,8 +260808,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path51 = sysPath.join(dir, sysPath.relative(dir, path51));
-        this._addToNodeFs(path51, initialAdd, wh3, depth + 1);
+        path52 = sysPath.join(dir, sysPath.relative(dir, path52));
+        this._addToNodeFs(path52, initialAdd, wh3, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -260734,13 +260858,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path51, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path52, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path51) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path52) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh3 = this.fsw._getWatchHelpers(path51);
+    const wh3 = this.fsw._getWatchHelpers(path52);
     if (priorWh) {
       wh3.filterPath = (entry) => priorWh.filterPath(entry);
       wh3.filterDir = (entry) => priorWh.filterDir(entry);
@@ -260756,8 +260880,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path51);
-        const targetPath = follow ? await fsrealpath(path51) : path51;
+        const absPath = sysPath.resolve(path52);
+        const targetPath = follow ? await fsrealpath(path52) : path52;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh3.watchPath, stats, initialAdd, depth, target, wh3, targetPath);
@@ -260767,29 +260891,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path51) : path51;
+        const targetPath = follow ? await fsrealpath(path52) : path52;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh3.watchPath);
         this.fsw._getWatchedDir(parent).add(wh3.watchPath);
         this.fsw._emit(EV.ADD, wh3.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path51, wh3, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path52, wh3, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path51), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path52), targetPath);
         }
       } else {
         closer = this._handleFile(wh3.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path51, closer);
+        this.fsw._addPathCloser(path52, closer);
       return false;
     } catch (error2) {
       if (this.fsw._handleError(error2)) {
         ready();
-        return path51;
+        return path52;
       }
     }
   }
@@ -260832,26 +260956,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path51) {
-  if (typeof path51 !== "string")
+function normalizePath2(path52) {
+  if (typeof path52 !== "string")
     throw new Error("string expected");
-  path51 = sysPath2.normalize(path51);
-  path51 = path51.replace(/\\/g, "/");
+  path52 = sysPath2.normalize(path52);
+  path52 = path52.replace(/\\/g, "/");
   let prepend2 = false;
-  if (path51.startsWith("//"))
+  if (path52.startsWith("//"))
     prepend2 = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path51.match(DOUBLE_SLASH_RE2))
-    path51 = path51.replace(DOUBLE_SLASH_RE2, "/");
+  while (path52.match(DOUBLE_SLASH_RE2))
+    path52 = path52.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend2)
-    path51 = "/" + path51;
-  return path51;
+    path52 = "/" + path52;
+  return path52;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path51 = normalizePath2(testString);
+  const path52 = normalizePath2(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path51, stats)) {
+    if (pattern(path52, stats)) {
       return true;
     }
   }
@@ -260891,19 +261015,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path51) => toUnix(sysPath2.normalize(toUnix(path51)));
-var normalizeIgnored = (cwd = "") => (path51) => {
-  if (typeof path51 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path51) ? path51 : sysPath2.join(cwd, path51));
+var normalizePathToUnix = (path52) => toUnix(sysPath2.normalize(toUnix(path52)));
+var normalizeIgnored = (cwd = "") => (path52) => {
+  if (typeof path52 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path52) ? path52 : sysPath2.join(cwd, path52));
   } else {
-    return path51;
+    return path52;
   }
 };
-var getAbsolutePath = (path51, cwd) => {
-  if (sysPath2.isAbsolute(path51)) {
-    return path51;
+var getAbsolutePath = (path52, cwd) => {
+  if (sysPath2.isAbsolute(path52)) {
+    return path52;
   }
-  return sysPath2.join(cwd, path51);
+  return sysPath2.join(cwd, path52);
 };
 var EMPTY_SET = Object.freeze(new Set);
@@ -260960,10 +261084,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 class WatchHelper {
-  constructor(path51, follow, fsw) {
+  constructor(path52, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path51;
-    this.path = path51 = path51.replace(REPLACER_RE, "");
+    const watchPath = path52;
+    this.path = path52 = path52.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -261076,20 +261200,20 @@ class FSWatcher extends EventEmitter {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path51) => {
-        const absPath = getAbsolutePath(path51, cwd);
+      paths = paths.map((path52) => {
+        const absPath = getAbsolutePath(path52, cwd);
         return absPath;
       });
     }
-    paths.forEach((path51) => {
-      this._removeIgnoredPath(path51);
+    paths.forEach((path52) => {
+      this._removeIgnoredPath(path52);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path51) => {
-      const res2 = await this._nodeFsHandler._addToNodeFs(path51, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path52) => {
+      const res2 = await this._nodeFsHandler._addToNodeFs(path52, !_internal, undefined, 0, _origAdd);
       if (res2)
         this._emitReady();
       return res2;
@@ -261108,17 +261232,17 @@ class FSWatcher extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path51) => {
-      if (!sysPath2.isAbsolute(path51) && !this._closers.has(path51)) {
+    paths.forEach((path52) => {
+      if (!sysPath2.isAbsolute(path52) && !this._closers.has(path52)) {
         if (cwd)
-          path51 = sysPath2.join(cwd, path51);
-        path51 = sysPath2.resolve(path51);
+          path52 = sysPath2.join(cwd, path52);
+        path52 = sysPath2.resolve(path52);
       }
-      this._closePath(path51);
-      this._addIgnoredPath(path51);
-      if (this._watched.has(path51)) {
+      this._closePath(path52);
+      this._addIgnoredPath(path52);
+      if (this._watched.has(path52)) {
         this._addIgnoredPath({
-          path: path51,
+          path: path52,
           recursive: true
         });
       }
@@ -261167,38 +261291,38 @@ class FSWatcher extends EventEmitter {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, ...args);
   }
-  async _emit(event, path51, stats) {
+  async _emit(event, path52, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path51 = sysPath2.normalize(path51);
+      path52 = sysPath2.normalize(path52);
     if (opts.cwd)
-      path51 = sysPath2.relative(opts.cwd, path51);
-    const args = [event, path51];
+      path52 = sysPath2.relative(opts.cwd, path52);
+    const args = [event, path52];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw2;
-    if (awf && (pw2 = this._pendingWrites.get(path51))) {
+    if (awf && (pw2 = this._pendingWrites.get(path52))) {
       pw2.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path51, args);
+        this._pendingUnlinks.set(path52, args);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path52) => {
+          this._pendingUnlinks.forEach((entry, path53) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path52);
+            this._pendingUnlinks.delete(path53);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path51)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path52)) {
         event = args[0] = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path51);
+        this._pendingUnlinks.delete(path52);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -261216,16 +261340,16 @@ class FSWatcher extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path51, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path52, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path51, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path52, 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, path51) : path51;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path52) : path52;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -261244,23 +261368,23 @@ class FSWatcher extends EventEmitter {
     }
     return error2 || this.closed;
   }
-  _throttle(actionType, path51, timeout2) {
+  _throttle(actionType, path52, 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(path51);
+    const actionPath = action.get(path52);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path51);
+      const item = action.get(path52);
       const count = item ? item.count : 0;
-      action.delete(path51);
+      action.delete(path52);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -261268,50 +261392,50 @@ class FSWatcher extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout2);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path51, thr);
+    action.set(path52, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path51, threshold, event, awfEmit) {
+  _awaitWriteFinish(path52, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path51;
-    if (this.options.cwd && !sysPath2.isAbsolute(path51)) {
-      fullPath = sysPath2.join(this.options.cwd, path51);
+    let fullPath = path52;
+    if (this.options.cwd && !sysPath2.isAbsolute(path52)) {
+      fullPath = sysPath2.join(this.options.cwd, path52);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path51)) {
+        if (err || !writes.has(path52)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path51).lastChange = now2;
+          writes.get(path52).lastChange = now2;
         }
-        const pw2 = writes.get(path51);
+        const pw2 = writes.get(path52);
         const df3 = now2 - pw2.lastChange;
         if (df3 >= threshold) {
-          writes.delete(path51);
+          writes.delete(path52);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path51)) {
-      writes.set(path51, {
+    if (!writes.has(path52)) {
+      writes.set(path52, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path51);
+          writes.delete(path52);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -261319,8 +261443,8 @@ class FSWatcher extends EventEmitter {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path51, stats) {
-    if (this.options.atomic && DOT_RE.test(path51))
+  _isIgnored(path52, stats) {
+    if (this.options.atomic && DOT_RE.test(path52))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -261330,13 +261454,13 @@ class FSWatcher extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path51, stats);
+    return this._userIgnored(path52, stats);
   }
-  _isntIgnored(path51, stat4) {
-    return !this._isIgnored(path51, stat4);
+  _isntIgnored(path52, stat4) {
+    return !this._isIgnored(path52, stat4);
   }
-  _getWatchHelpers(path51) {
-    return new WatchHelper(path51, this.options.followSymlinks, this);
+  _getWatchHelpers(path52) {
+    return new WatchHelper(path52, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -261350,57 +261474,57 @@ class FSWatcher extends EventEmitter {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory2) {
-    const path51 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path51);
-    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path51) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path51, 100))
+    const path52 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path52);
+    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path52) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path52, 100))
       return;
     if (!isDirectory2 && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp2 = this._getWatchedDir(path51);
+    const wp2 = this._getWatchedDir(path52);
     const nestedDirectoryChildren = wp2.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path51, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path52, 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 = path51;
+    let relPath = path52;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path51);
+      relPath = sysPath2.relative(this.options.cwd, path52);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path51);
+    this._watched.delete(path52);
     this._watched.delete(fullPath);
     const eventName = isDirectory2 ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path51))
-      this._emit(eventName, path51);
-    this._closePath(path51);
+    if (wasTracked && !this._isIgnored(path52))
+      this._emit(eventName, path52);
+    this._closePath(path52);
   }
-  _closePath(path51) {
-    this._closeFile(path51);
-    const dir = sysPath2.dirname(path51);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path51));
+  _closePath(path52) {
+    this._closeFile(path52);
+    const dir = sysPath2.dirname(path52);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path52));
   }
-  _closeFile(path51) {
-    const closers = this._closers.get(path51);
+  _closeFile(path52) {
+    const closers = this._closers.get(path52);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path51);
+    this._closers.delete(path52);
   }
-  _addPathCloser(path51, closer) {
+  _addPathCloser(path52, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path51);
+    let list = this._closers.get(path52);
     if (!list) {
       list = [];
-      this._closers.set(path51, list);
+      this._closers.set(path52, list);
     }
     list.push(closer);
   }
@@ -261433,10 +261557,10 @@ import Debug3 from "debug";
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts3 from "typescript";
-import * as path51 from "path";
+import * as path52 from "path";
 import * as fs48 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path51.join(projectDir, "package.json");
+  const packageJsonPath = path52.join(projectDir, "package.json");
   const allPackages = new Set;
   if (!fs48.existsSync(packageJsonPath)) {
     return allPackages;
@@ -261457,7 +261581,7 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path51.resolve(filePath);
+  const absolutePath = path52.resolve(filePath);
   if (!fs48.existsSync(absolutePath)) {
     return [];
   }
@@ -261511,17 +261635,17 @@ function resolveNodeModuleImport({
 }) {
   const packageName = getPackageNameFromImport(importPath);
   const searchPaths = [
-    path51.join(projectDir, "node_modules", packageName)
+    path52.join(projectDir, "node_modules", packageName)
   ];
   if (searchFromDir) {
-    let currentDir = path51.dirname(searchFromDir);
-    const projectDirNormalized = path51.normalize(projectDir);
+    let currentDir = path52.dirname(searchFromDir);
+    const projectDirNormalized = path52.normalize(projectDir);
     while (currentDir.startsWith(projectDirNormalized)) {
-      const candidatePath = path51.join(currentDir, "node_modules", packageName);
+      const candidatePath = path52.join(currentDir, "node_modules", packageName);
       if (!searchPaths.includes(candidatePath)) {
         searchPaths.push(candidatePath);
       }
-      const parentDir = path51.dirname(currentDir);
+      const parentDir = path52.dirname(currentDir);
       if (parentDir === currentDir)
         break;
       currentDir = parentDir;
@@ -261537,22 +261661,22 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path51.join(packageDir, "package.json");
+  const packageJsonPath = path52.join(packageDir, "package.json");
   const hasPackageJson = fs48.existsSync(packageJsonPath);
   const packageJson = hasPackageJson ? JSON.parse(fs48.readFileSync(packageJsonPath, "utf-8")) : null;
   const resolvedFiles = [];
   if (importPath !== packageName) {
     const subpath = importPath.slice(packageName.length + 1);
     const possiblePaths = [
-      path51.join(packageDir, subpath),
-      path51.join(packageDir, `${subpath}.js`),
-      path51.join(packageDir, `${subpath}.mjs`),
-      path51.join(packageDir, `${subpath}.ts`),
-      path51.join(packageDir, `${subpath}.tsx`),
-      path51.join(packageDir, subpath, "index.js"),
-      path51.join(packageDir, subpath, "index.mjs"),
-      path51.join(packageDir, subpath, "index.ts"),
-      path51.join(packageDir, subpath, "index.tsx")
+      path52.join(packageDir, subpath),
+      path52.join(packageDir, `${subpath}.js`),
+      path52.join(packageDir, `${subpath}.mjs`),
+      path52.join(packageDir, `${subpath}.ts`),
+      path52.join(packageDir, `${subpath}.tsx`),
+      path52.join(packageDir, subpath, "index.js"),
+      path52.join(packageDir, subpath, "index.mjs"),
+      path52.join(packageDir, subpath, "index.ts"),
+      path52.join(packageDir, subpath, "index.tsx")
     ];
     for (const p3 of possiblePaths) {
       if (fs48.existsSync(p3) && fs48.statSync(p3).isFile()) {
@@ -261587,22 +261711,22 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path51.join(packageDir, entry);
+    const entryPath = path52.join(packageDir, entry);
     if (fs48.existsSync(entryPath) && fs48.statSync(entryPath).isFile()) {
       resolvedFiles.push(entryPath);
     }
   }
   if (resolvedFiles.length === 0) {
     const fallbackPaths = [
-      path51.join(packageDir, "index.js"),
-      path51.join(packageDir, "index.mjs"),
-      path51.join(packageDir, "index.ts"),
-      path51.join(packageDir, "index.tsx"),
-      path51.join(packageDir, "dist", "index.js"),
-      path51.join(packageDir, "dist", "index.mjs"),
-      path51.join(packageDir, "lib", "index.js"),
-      path51.join(packageDir, "src", "index.ts"),
-      path51.join(packageDir, "src", "index.tsx")
+      path52.join(packageDir, "index.js"),
+      path52.join(packageDir, "index.mjs"),
+      path52.join(packageDir, "index.ts"),
+      path52.join(packageDir, "index.tsx"),
+      path52.join(packageDir, "dist", "index.js"),
+      path52.join(packageDir, "dist", "index.mjs"),
+      path52.join(packageDir, "lib", "index.js"),
+      path52.join(packageDir, "src", "index.ts"),
+      path52.join(packageDir, "src", "index.tsx")
     ];
     for (const p3 of fallbackPaths) {
       if (fs48.existsSync(p3) && fs48.statSync(p3).isFile()) {
@@ -261643,8 +261767,8 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path51.resolve(filePath);
-    const baseDir = path51.dirname(absolutePath);
+    const absolutePath = path52.resolve(filePath);
+    const baseDir = path52.dirname(absolutePath);
     if (!fs48.existsSync(absolutePath)) {
       return [];
     }
@@ -261670,7 +261794,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path51.resolve(baseDir, importPath);
+    const resolvedPath = path52.resolve(baseDir, importPath);
     if (fs48.existsSync(resolvedPath) && fs48.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
@@ -261682,7 +261806,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
     if (fs48.existsSync(resolvedPath) && fs48.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path51.join(resolvedPath, `index${ext}`);
+        const indexPath = path52.join(resolvedPath, `index${ext}`);
         if (fs48.existsSync(indexPath)) {
           return indexPath;
         }
@@ -261708,11 +261832,11 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path51.join(packageDir, dirName);
+    const dirPath = path52.join(packageDir, dirName);
     if (fs48.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path51.join(packageDir, "package.json");
+        const packageJsonPath = path52.join(packageDir, "package.json");
         if (fs48.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
@@ -261728,7 +261852,7 @@ function walkDirectory(dir, excludedDirs) {
     return files;
   const entries = fs48.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path51.join(dir, entry.name);
+    const fullPath = path52.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirs.has(entry.name)) {
         continue;
@@ -261789,10 +261913,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
       processedPackages.add(packageName);
       if (resolvedFiles.length > 0) {
         const firstResolvedFile = resolvedFiles[0];
-        let packageDir = path51.dirname(firstResolvedFile);
+        let packageDir = path52.dirname(firstResolvedFile);
         let hasPackageJson = false;
         while (packageDir.includes("node_modules")) {
-          const packageJsonPath = path51.join(packageDir, "package.json");
+          const packageJsonPath = path52.join(packageDir, "package.json");
           if (fs48.existsSync(packageJsonPath)) {
             try {
               const pkgJson = JSON.parse(fs48.readFileSync(packageJsonPath, "utf-8"));
@@ -261803,10 +261927,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
             } catch {}
           }
           const expectedPackagePath = packageName.startsWith("@") ? `node_modules/${packageName}` : `node_modules/${packageName}`;
-          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path51.sep))) {
+          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path52.sep))) {
             break;
           }
-          const parentDir = path51.dirname(packageDir);
+          const parentDir = path52.dirname(packageDir);
           if (parentDir === packageDir)
             break;
           packageDir = parentDir;
@@ -261880,7 +262004,7 @@ class EventsWatcher extends EventEmitter2 {
 import * as fs50 from "node:fs";
 import * as http from "node:http";
 import { createRequire as createRequire4 } from "node:module";
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 // node_modules/winterspec/dist/edge/transform-to-node.js
 var import_node_utils = __toESM2(require_dist5(), 1);
@@ -262582,10 +262706,10 @@ var databaseSchema = z7.object({
   files: z7.array(fileSchema).default([]),
   events: z7.array(eventSchema).default([])
 });
-function normalizePath3(path52) {
-  if (!path52 || path52 === "/")
+function normalizePath3(path53) {
+  if (!path53 || path53 === "/")
     return "";
-  let normalized = path52.replace(/\\+/g, "/").replace(/\/\/+/, "/");
+  let normalized = path53.replace(/\\+/g, "/").replace(/\/\/+/, "/");
   if (normalized.startsWith("/")) {
     normalized = normalized.slice(1);
   }
@@ -263443,13 +263567,13 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 // lib/server/kicad-pcm-proxy.ts
 import * as fs49 from "node:fs";
-import * as path52 from "node:path";
+import * as path53 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 = fs49.statSync(path52.join(projectDir, file));
+      const stat4 = fs49.statSync(path53.join(projectDir, file));
       checksum += `${file}:${stat4.mtimeMs};`;
     } catch {}
   }
@@ -263469,9 +263593,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url2, res2) => {
     const requestedFile = url2.pathname.replace(/^\/pcm\/?/, "") || "repository.json";
-    const distDir = path52.join(projectDir, "dist");
-    const pcmDir = path52.join(distDir, "pcm");
-    const filePath = path52.join(pcmDir, requestedFile);
+    const distDir = path53.join(projectDir, "dist");
+    const pcmDir = path53.join(distDir, "pcm");
+    const filePath = path53.join(pcmDir, requestedFile);
     const currentChecksum = getSourceFilesChecksum(projectDir);
     const needsRebuild = currentChecksum !== pcmState.lastFileChecksum;
     if (needsRebuild) {
@@ -263521,7 +263645,7 @@ Rebuilding KiCad PCM assets...`));
       res2.end(`PCM file not found: ${requestedFile}`);
       return;
     }
-    const ext = path52.extname(filePath).toLowerCase();
+    const ext = path53.extname(filePath).toLowerCase();
     let contentType = "application/octet-stream";
     if (ext === ".json") {
       contentType = "application/json";
@@ -263545,8 +263669,8 @@ var resolveLocalTscircuitStandalonePath = (projectDir) => {
   if (!projectDir)
     return;
   try {
-    const projectRequire = createRequire4(path53.join(projectDir, "package.json"));
-    const browserBundlePath = path53.join(path53.dirname(projectRequire.resolve("tscircuit/package.json")), "dist", "browser.min.js");
+    const projectRequire = createRequire4(path54.join(projectDir, "package.json"));
+    const browserBundlePath = path54.join(path54.dirname(projectRequire.resolve("tscircuit/package.json")), "dist", "browser.min.js");
     if (fs50.existsSync(browserBundlePath))
       return browserBundlePath;
   } catch {}
@@ -263686,7 +263810,7 @@ var createHttpServer = async ({
 // lib/shared/push-snippet.ts
 var import_semver6 = __toESM2(require_semver2(), 1);
 import * as fs51 from "node:fs";
-import * as path56 from "node:path";
+import * as path57 from "node:path";
 import Debug2 from "debug";
 // lib/utils/validate-package-name.ts
@@ -263704,7 +263828,7 @@ var validatePackageName = (name) => {
 };
 // lib/dev/get-package-file-paths.ts
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 var getPackageFilePaths = (projectDir, ignored = []) => {
   const ignorePatterns = [
     ...DEFAULT_IGNORED_PATTERNS,
@@ -263715,7 +263839,7 @@ var getPackageFilePaths = (projectDir, ignored = []) => {
     ignore: ignorePatterns
   });
   fileNames.sort();
-  return fileNames.map((fileName) => path54.join(projectDir, fileName));
+  return fileNames.map((fileName) => path55.join(projectDir, fileName));
 };
 // lib/utils/check-org-access.ts
@@ -263731,7 +263855,7 @@ var checkOrgAccess = async (ky4, orgTscircuitHandle) => {
 };
 // lib/shared/is-binary-file.ts
-import * as path55 from "node:path";
+import * as path56 from "node:path";
 var BINARY_FILE_EXTENSIONS = new Set([
   ".glb",
   ".gltf",
@@ -263747,7 +263871,7 @@ var BINARY_FILE_EXTENSIONS = new Set([
   ".tar"
 ]);
 var isBinaryFile = (filePath) => {
-  const ext = path55.extname(filePath).toLowerCase();
+  const ext = path56.extname(filePath).toLowerCase();
   return BINARY_FILE_EXTENSIONS.has(ext);
 };
@@ -263784,14 +263908,14 @@ var findPushProject = async ({
       return null;
     }
     const packageJsonPath2 = [
-      path56.resolve(path56.join(path56.dirname(snippetFilePath2), "package.json")),
-      path56.resolve(path56.join(process.cwd(), "package.json"))
+      path57.resolve(path57.join(path57.dirname(snippetFilePath2), "package.json")),
+      path57.resolve(path57.join(process.cwd(), "package.json"))
     ].find((candidatePath) => fs51.existsSync(candidatePath));
-    const projectDir2 = packageJsonPath2 ? path56.dirname(packageJsonPath2) : path56.dirname(snippetFilePath2);
+    const projectDir2 = packageJsonPath2 ? path57.dirname(packageJsonPath2) : path57.dirname(snippetFilePath2);
     return { snippetFilePath: snippetFilePath2, packageJsonPath: packageJsonPath2, projectDir: projectDir2 };
   }
   const projectDir = process.cwd();
-  const packageJsonPath = path56.resolve(path56.join(projectDir, "package.json"));
+  const packageJsonPath = path57.resolve(path57.join(projectDir, "package.json"));
   if (!fs51.existsSync(packageJsonPath)) {
     return { projectDir };
   }
@@ -263805,7 +263929,7 @@ var findPushProject = async ({
 var getArchivePayload = async (filePaths, projectDir, packageNameWithVersion) => {
   const zip = new import_jszip4.default;
   for (const fullFilePath of filePaths) {
-    const relativeFilePath = path56.relative(projectDir, fullFilePath);
+    const relativeFilePath = path57.relative(projectDir, fullFilePath);
     zip.file(relativeFilePath, fs51.readFileSync(fullFilePath));
   }
   const archive = await zip.generateAsync({
@@ -264036,7 +264160,7 @@ var pushSnippet = async ({
         json: archivePayload
       });
       for (const fullFilePath of filePaths) {
-        const relativeFilePath = path56.relative(projectDir, fullFilePath);
+        const relativeFilePath = path57.relative(projectDir, fullFilePath);
         uploadResults.succeeded.push(relativeFilePath);
       }
       log(kleur_default.gray(`\uD83D\uDCE6 Uploaded archive with ${filePaths.length} files`));
@@ -264046,7 +264170,7 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path56.relative(projectDir, fullFilePath);
+      const relativeFilePath = path57.relative(projectDir, fullFilePath);
       const fileBuffer = fs51.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
@@ -264137,7 +264261,7 @@ class DevServer {
   }) {
     this.port = port;
     this.componentFilePath = componentFilePath;
-    this.projectDir = projectDir ?? path57.dirname(componentFilePath);
+    this.projectDir = projectDir ?? path58.dirname(componentFilePath);
     this.kicadPcm = kicadPcm ?? false;
     const projectConfig2 = loadProjectConfig(this.projectDir);
     this.ignoredFiles = projectConfig2?.ignoredFiles ?? [];
@@ -264148,7 +264272,7 @@ class DevServer {
   async start() {
     const { server } = await createHttpServer({
       port: this.port,
-      defaultMainComponentPath: path57.relative(this.projectDir, this.componentFilePath),
+      defaultMainComponentPath: path58.relative(this.projectDir, this.componentFilePath),
       kicadPcm: this.kicadPcm,
       projectDir: this.projectDir,
       entryFile: this.componentFilePath
@@ -264164,7 +264288,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p3) => shouldIgnorePath(path57.relative(this.projectDir, p3), this.ignoredFiles)
+      ignored: (p3) => shouldIgnorePath(path58.relative(this.projectDir, p3), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -264179,8 +264303,8 @@ class DevServer {
     const { file } = await this.fsKy.get("api/files/get", {
       searchParams: { file_path: ev2.file_path }
     }).json();
-    const fullPath = path57.join(this.projectDir, ev2.file_path);
-    const dirPath = path57.dirname(fullPath);
+    const fullPath = path58.join(this.projectDir, ev2.file_path);
+    const dirPath = path58.dirname(fullPath);
     if (!fs52.existsSync(dirPath)) {
       fs52.mkdirSync(dirPath, { recursive: true });
     }
@@ -264192,14 +264316,14 @@ class DevServer {
     }
   }
   async handleFileDeletedEventFromServer(ev2) {
-    const fullPath = path57.join(this.projectDir, ev2.file_path);
+    const fullPath = path58.join(this.projectDir, ev2.file_path);
     if (fs52.existsSync(fullPath)) {
       debug13(`Deleting file ${ev2.file_path} from filesystem`);
       fs52.unlinkSync(fullPath);
     }
   }
   async handleFileChangedOnFilesystem(absoluteFilePath) {
-    const relativeFilePath = path57.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path58.relative(this.projectDir, absoluteFilePath);
     if (relativeFilePath.includes("manual-edits.json"))
       return;
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
@@ -264214,14 +264338,14 @@ class DevServer {
     await this.checkAndUploadNewNodeModules(absoluteFilePath);
   }
   async checkAndUploadNewNodeModules(filePath) {
-    const ext = path57.extname(filePath).toLowerCase();
+    const ext = path58.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 = path57.relative(this.projectDir, file);
+        const relativePath = path58.relative(this.projectDir, file);
         return !this.uploadedNodeModules.has(relativePath);
       });
       if (newFiles.length === 0)
@@ -264234,7 +264358,7 @@ class DevServer {
     }
   }
   async handleFileRemovedFromFilesystem(absoluteFilePath) {
-    const relativeFilePath = path57.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path58.relative(this.projectDir, absoluteFilePath);
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
       return;
     if (!relativeFilePath || relativeFilePath.trim() === "") {
@@ -264272,8 +264396,8 @@ class DevServer {
     debug13(`Successfully deleted file ${relativeFilePath} from server`);
   }
   async handleFileRename(oldPath, newPath) {
-    const oldRelativePath = path57.relative(this.projectDir, oldPath);
-    const newRelativePath = path57.relative(this.projectDir, newPath);
+    const oldRelativePath = path58.relative(this.projectDir, oldPath);
+    const newRelativePath = path58.relative(this.projectDir, newPath);
     if (shouldIgnorePath(oldRelativePath, this.ignoredFiles) || shouldIgnorePath(newRelativePath, this.ignoredFiles))
       return;
     await this.handleFileRemovedFromFilesystem(oldPath);
@@ -264291,7 +264415,7 @@ class DevServer {
     });
     const filePaths = getPackageFilePaths(this.projectDir, this.ignoredFiles);
     for (const filePath of filePaths) {
-      const relativeFilePath = path57.relative(this.projectDir, filePath);
+      const relativeFilePath = path58.relative(this.projectDir, filePath);
       const filePayload = this.createFileUploadPayload(filePath, relativeFilePath);
       await this.postFileUpsert({
         filePath: relativeFilePath,
@@ -264323,7 +264447,7 @@ class DevServer {
   }
   async uploadNodeModuleFiles(files) {
     for (const nodeModuleFile of files) {
-      const relativeFilePath = path57.relative(this.projectDir, nodeModuleFile);
+      const relativeFilePath = path58.relative(this.projectDir, nodeModuleFile);
       this.uploadedNodeModules.add(relativeFilePath);
       const filePayload = this.createFileUploadPayload(nodeModuleFile, relativeFilePath);
       await this.postFileUpsert({
@@ -264362,7 +264486,7 @@ class DevServer {
   getInitialNodeModuleDependencyEntryFiles() {
     const entryFiles = [this.componentFilePath];
     for (const configFileName of CONFIG_MODULE_FILENAMES2) {
-      const configPath = path57.join(this.projectDir, configFileName);
+      const configPath = path58.join(this.projectDir, configFileName);
       if (fs52.existsSync(configPath)) {
         entryFiles.push(configPath);
       }
@@ -264378,7 +264502,7 @@ class DevServer {
     formData.set("file_path", filePath);
     formData.set("initiator", initiator);
     const binaryBytes = Uint8Array.from(binaryContent);
-    formData.set("binary_file", new Blob([binaryBytes]), path57.basename(filePath));
+    formData.set("binary_file", new Blob([binaryBytes]), path58.basename(filePath));
     const response = await fetch(`http://localhost:${this.port}/api/files/upsert-multipart`, {
       method: "POST",
       body: formData
@@ -264418,7 +264542,7 @@ class DevServer {
     await this.filesystemWatcher?.close();
   }
   createFileUploadPayload(absoluteFilePath, relativeFilePath) {
-    const ext = path57.extname(relativeFilePath).toLowerCase();
+    const ext = path58.extname(relativeFilePath).toLowerCase();
     if (BINARY_FILE_EXTENSIONS2.has(ext)) {
       const fileBuffer = fs52.readFileSync(absoluteFilePath);
       return { binary_content: fileBuffer };
@@ -264464,7 +264588,7 @@ var isPortAvailable = (port) => {
   });
 };
 var warnIfTsconfigMissingTscircuitType = (projectDir) => {
-  const tsconfigPath = path58.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path59.join(projectDir, "tsconfig.json");
   if (!fs53.existsSync(tsconfigPath)) {
     return;
   }
@@ -264501,7 +264625,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(path58.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(path59.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
 `);
     console.log(kleur_default.gray(`Watching ${kleur_default.underline(server.projectDir.split("/").slice(-2).join("/"))} for changes...`));
@@ -264531,13 +264655,13 @@ var checkLoggedIn = () => {
 import { spawnSync as spawnSync2 } from "node:child_process";
 import fs54 from "node:fs";
 import os7 from "node:os";
-import path59 from "node:path";
+import path60 from "node:path";
 var hasBunInstalled = () => {
   const result = spawnSync2("bun", ["--version"], { stdio: "ignore" });
   return result.status === 0;
 };
 var createTempProject = (tempDir) => {
-  const packageJsonPath = path59.join(tempDir, "package.json");
+  const packageJsonPath = path60.join(tempDir, "package.json");
   const packageJson = {
     name: "tsci-doctor-check",
     version: "0.0.0",
@@ -264557,7 +264681,7 @@ var checkGlobalNpmrcRegistry = async () => {
       details: "Bun is required to verify registry settings. Install Bun and rerun `tsci doctor`."
     };
   }
-  const tempDir = fs54.mkdtempSync(path59.join(os7.tmpdir(), "tsci-doctor-"));
+  const tempDir = fs54.mkdtempSync(path60.join(os7.tmpdir(), "tsci-doctor-"));
   try {
     createTempProject(tempDir);
     const result = spawnSync2("bun", ["install"], {
@@ -264629,7 +264753,7 @@ var registerDoctor = (program2) => {
 // lib/shared/export-snippet.ts
 import fs55 from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf4 } from "circuit-json-to-gltf";
 import {
@@ -265762,9 +265886,9 @@ var stringifyDsnJson = (dsnJson) => {
   const stringifyCoordinates = (coordinates) => {
     return coordinates.join(" ");
   };
-  const stringifyPath = (path60, level) => {
+  const stringifyPath = (path61, level) => {
     const padding = indent.repeat(level);
-    return `${padding}(path ${path60.layer} ${path60.width}  ${stringifyCoordinates(path60.coordinates)})`;
+    return `${padding}(path ${path61.layer} ${path61.width}  ${stringifyCoordinates(path61.coordinates)})`;
   };
   result += `(pcb ${dsnJson.filename ? dsnJson.filename : "./converted_dsn.dsn"}
 `;
@@ -267443,11 +267567,11 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
         continue;
       }
       const letterPaths = lineAlphabet2[char] || [];
-      for (const path60 of letterPaths) {
-        const x12 = anchoredX + path60.x1 * fontSize;
-        const y12 = anchoredY + path60.y1 * fontSize;
-        const x22 = anchoredX + path60.x2 * fontSize;
-        const y22 = anchoredY + path60.y2 * fontSize;
+      for (const path61 of letterPaths) {
+        const x12 = anchoredX + path61.x1 * fontSize;
+        const y12 = anchoredY + path61.y1 * fontSize;
+        const x22 = anchoredX + path61.x2 * fontSize;
+        const y22 = anchoredY + path61.y2 * fontSize;
         const p12 = applyTransform({ x: x12, y: y12 });
         const p23 = applyTransform({ x: x22, y: y22 });
         gerber.add("move_operation", { x: p12.x, y: mfy(p12.y) });
@@ -268212,7 +268336,7 @@ var exportSnippet = async ({
   outputPath,
   platformConfig: platformConfig2,
   pcbSnapshotSettings,
-  writeFile = true,
+  writeFile: writeFile2 = true,
   onExit = (code) => process.exit(code),
   onError = (message) => console.error(message),
   onSuccess = (result) => console.log(result)
@@ -268221,10 +268345,10 @@ var exportSnippet = async ({
     onError(`Invalid format: ${format}`);
     return onExit(1);
   }
-  const projectDir = path60.dirname(filePath);
-  const outputBaseName = path60.basename(filePath).replace(/\.[^.]+$/, "");
+  const projectDir = path61.dirname(filePath);
+  const outputBaseName = path61.basename(filePath).replace(/\.[^.]+$/, "");
   const outputFileName = `${outputBaseName}${OUTPUT_EXTENSIONS[format]}`;
-  const outputDestination = path60.join(projectDir, outputPath ?? outputFileName);
+  const outputDestination = path61.join(projectDir, outputPath ?? outputFileName);
   if (format === "kicad-library") {
     try {
       const result = await convertToKicadLibrary({
@@ -268232,7 +268356,7 @@ var exportSnippet = async ({
         libraryName: outputBaseName,
         outputDir: outputDestination
       });
-      if (writeFile) {
+      if (writeFile2) {
         onSuccess({ outputDestination: result.outputDir, outputContent: "" });
       }
       return onExit(0);
@@ -268336,7 +268460,7 @@ var exportSnippet = async ({
         model3dSourcePaths: pcbConverter.getModel3dSourcePaths(),
         projectName: outputBaseName,
         fetch: platformConfig2?.platformFetch ?? globalThis.fetch,
-        readFile: (modelPath) => fs55.promises.readFile(path60.resolve(projectDir, modelPath)),
+        readFile: (modelPath) => fs55.promises.readFile(path61.resolve(projectDir, modelPath)),
         onModelFile: ({ outputPath: outputPath2, content }) => {
           zip.file(outputPath2, content);
         },
@@ -268393,7 +268517,7 @@ var exportSnippet = async ({
     default:
       outputContent = JSON.stringify(circuitJson, null, 2);
   }
-  if (writeFile) {
+  if (writeFile2) {
     await writeFileAsync(outputDestination, outputContent).catch((err) => {
       onError(`Error writing file: ${err}`);
       return onExit(1);
@@ -268518,11 +268642,11 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 // lib/eecircuit-engine/run-simulation.ts
 import { promises as fs56, existsSync as existsSync15 } from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 import os8 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path61.join(os8.tmpdir(), `tscircuit-eecircuit-engine-1.7.4.mjs`);
+  const tempFilePath = path62.join(os8.tmpdir(), `tscircuit-eecircuit-engine-1.7.4.mjs`);
   if (!existsSync15(tempFilePath)) {
     const url2 = `https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.4/dist/eecircuit-engine.mjs`;
     const response = await fetch(url2);
@@ -268619,7 +268743,7 @@ var resultToCsv = (result) => {
 };
 // cli/export/register.ts
-import path62 from "node:path";
+import path63 from "node:path";
 import { promises as fs57 } from "node:fs";
 var registerExport = (program2) => {
   program2.command("export").description("Export tscircuit code to various formats").argument("<file>", "Path to the package file").option("-f, --format <format>", `Output format (${ALLOWED_EXPORT_FORMATS.join(", ")})`).option("-o, --output <path>", "Output file path").option("--disable-parts-engine", "Disable the parts engine").option("--show-courtyards", "Show courtyard outlines in PCB SVG output").action(async (file, options) => {
@@ -268634,7 +268758,7 @@ var registerExport = (program2) => {
       });
       if (circuitJson) {
         const spiceString = getSpiceWithPaddedSim(circuitJson);
-        const outputSpicePath = options.output ?? path62.join(path62.dirname(file), `${path62.basename(file, path62.extname(file))}.spice.cir`);
+        const outputSpicePath = options.output ?? path63.join(path63.dirname(file), `${path63.basename(file, path63.extname(file))}.spice.cir`);
         await fs57.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
@@ -269361,8 +269485,8 @@ function getErrorMap2() {
   return overrideErrorMap2;
 }
 var makeIssue2 = (params2) => {
-  const { data, path: path63, errorMaps, issueData } = params2;
-  const fullPath = [...path63, ...issueData.path || []];
+  const { data, path: path64, errorMaps, issueData } = params2;
+  const fullPath = [...path64, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -269470,11 +269594,11 @@ var errorUtil2;
   errorUtil22.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil2 || (errorUtil2 = {}));
 var ParseInputLazyPath2 = class {
-  constructor(parent, value, path63, key) {
+  constructor(parent, value, path64, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path63;
+    this._path = path64;
     this._key = key;
   }
   get path() {
@@ -277143,15 +277267,15 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path63 = [];
+  const path64 = [];
   for (let i3 = 0;i3 <= numPoints; i3++) {
     const t50 = i3 / numPoints;
     const angle2 = startAngle + t50 * (endAngle - startAngle);
     const x4 = centerX + radius * Math.cos(angle2);
     const y4 = centerY + radius * Math.sin(angle2);
-    path63.push({ x: x4, y: y4 });
+    path64.push({ x: x4, y: y4 });
   }
-  return path63;
+  return path64;
 }
 var mil10ToMm = (value) => value * 10 * 0.0254;
 var getBoundsCenter = (bounds) => ({
@@ -278322,7 +278446,7 @@ var parsePin = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path63 = pathMatch ? pathMatch[1] : "";
+  const path64 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r4 = Number.parseFloat(rotation23);
@@ -278336,7 +278460,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r4) ? 0 : r4,
     label,
     labelColor,
-    path: path63,
+    path: path64,
     arrow
   };
 };
@@ -283926,15 +284050,15 @@ function generateArcFromSweep2(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path63 = [];
+  const path64 = [];
   for (let i3 = 0;i3 <= numPoints; i3++) {
     const t50 = i3 / numPoints;
     const angle2 = startAngle + t50 * (endAngle - startAngle);
     const x4 = centerX + radius * Math.cos(angle2);
     const y4 = centerY + radius * Math.sin(angle2);
-    path63.push({ x: x4, y: y4 });
+    path64.push({ x: x4, y: y4 });
   }
-  return path63;
+  return path64;
 }
 var mil10ToMm2 = (value) => value * 10 * 0.0254;
 var getBoundsCenter2 = (bounds) => ({
@@ -285091,7 +285215,7 @@ var parsePin2 = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path63 = pathMatch ? pathMatch[1] : "";
+  const path64 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r4 = Number.parseFloat(rotation23);
@@ -285105,7 +285229,7 @@ var parsePin2 = (pinString) => {
     rotation: Number.isNaN(r4) ? 0 : r4,
     label,
     labelColor,
-    path: path63,
+    path: path64,
     arrow
   };
 };
@@ -285428,14 +285552,14 @@ function normalizeManufacturerPartNumber2(partNumber) {
 // lib/import/import-component-from-jlcpcb.ts
 import fs58 from "node:fs/promises";
-import path63 from "node:path";
+import path64 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd(), options = {}) => {
   const rawEasy = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const betterEasy = EasyEdaJsonSchema2.parse(rawEasy);
   const rawPn = betterEasy.dataStr.head.c_para["Manufacturer Part"];
   const componentName = rawPn ? normalizeManufacturerPartNumber2(rawPn) : jlcpcbPartNumber;
   let tsx = await convertRawEasyToTsx({ rawEasy });
-  const componentDir = options.download ? path63.join(projectDir, "imports", componentName) : path63.join(projectDir, "imports");
+  const componentDir = options.download ? path64.join(projectDir, "imports", componentName) : path64.join(projectDir, "imports");
   await fs58.mkdir(componentDir, { recursive: true });
   if (options.download) {
     const platformConfig2 = getPlatformConfigWithCliDefaults();
@@ -285447,7 +285571,7 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
     if (cadComponent?.model_step_url) {
       const stepFileName = `${componentName}.step`;
       const stepResp = await platformFetch2(cadComponent.model_step_url);
-      await fs58.writeFile(path63.join(componentDir, stepFileName), Buffer.from(await stepResp.arrayBuffer()));
+      await fs58.writeFile(path64.join(componentDir, stepFileName), Buffer.from(await stepResp.arrayBuffer()));
       tsx = `import stepPath from "./${stepFileName}"
 ` + tsx;
       tsx = tsx.replace(`"${cadComponent.model_step_url}"`, "stepPath");
@@ -285455,13 +285579,13 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
     if (cadComponent?.model_obj_url) {
       const objFileName = `${componentName}.obj`;
       const objResp = await platformFetch2(cadComponent.model_obj_url);
-      await fs58.writeFile(path63.join(componentDir, objFileName), Buffer.from(await objResp.arrayBuffer()));
+      await fs58.writeFile(path64.join(componentDir, objFileName), Buffer.from(await objResp.arrayBuffer()));
       tsx = `import objPath from "./${objFileName}"
 ` + tsx;
       tsx = tsx.replace(`"${cadComponent.model_obj_url}"`, "objPath");
     }
   }
-  const filePath = path63.join(componentDir, `${componentName}.tsx`);
+  const filePath = path64.join(componentDir, `${componentName}.tsx`);
   await fs58.writeFile(filePath, tsx);
   return { filePath };
 };
@@ -286904,12 +287028,12 @@ var registerImport = (program2) => {
 // cli/init/register.ts
 import * as fs60 from "node:fs";
-import * as path66 from "node:path";
+import * as path67 from "node:path";
 // lib/shared/generate-gitignore-file.ts
-import path64 from "node:path";
+import path65 from "node:path";
 var generateGitIgnoreFile = (dir) => {
-  const gitignorePath = path64.join(dir, ".gitignore");
+  const gitignorePath = path65.join(dir, ".gitignore");
   const gitignoreContent = `# Dependencies
 node_modules/
@@ -286945,7 +287069,7 @@ yarn-error.log*
 // lib/shared/setup-tscircuit-skill.ts
 import * as fs59 from "node:fs";
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 var SKILL_REPO_API_URL = "https://api.github.com/repos/tscircuit/skill/contents";
 var SKILL_INSTALL_PATHS = [
   ".claude/skills/tscircuit",
@@ -286968,7 +287092,7 @@ async function fetchFileContent(downloadUrl) {
 async function downloadDirectory(apiUrl, targetDir) {
   const contents = await fetchGitHubContents(apiUrl);
   for (const item of contents) {
-    const targetPath = path65.join(targetDir, item.name);
+    const targetPath = path66.join(targetDir, item.name);
     if (item.type === "dir") {
       fs59.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${apiUrl}/${item.name}`, targetPath);
@@ -286985,7 +287109,7 @@ async function downloadSkillRepo(targetDir) {
     if (item.name === ".git" || item.name === ".github") {
       continue;
     }
-    const targetPath = path65.join(targetDir, item.name);
+    const targetPath = path66.join(targetDir, item.name);
     if (item.type === "dir") {
       fs59.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${SKILL_REPO_API_URL}/${item.name}`, targetPath);
@@ -286996,7 +287120,7 @@ async function downloadSkillRepo(targetDir) {
   }
 }
 async function setupTscircuitSkill(projectDir, skipPrompt = false) {
-  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs59.existsSync(path65.join(projectDir, skillPath, "SKILL.md")));
+  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs59.existsSync(path66.join(projectDir, skillPath, "SKILL.md")));
   if (missingSkillPaths.length === 0) {
     console.log("TSCircuit AI skills already exist, skipping...");
     return true;
@@ -287016,7 +287140,7 @@ async function setupTscircuitSkill(projectDir, skipPrompt = false) {
   console.info("Setting up tscircuit AI skills...");
   try {
     for (const skillPath of missingSkillPaths) {
-      const targetDir = path65.join(projectDir, skillPath);
+      const targetDir = path66.join(projectDir, skillPath);
       await downloadSkillRepo(targetDir);
       console.info(`tscircuit skill installed at ${skillPath}`);
     }
@@ -287087,7 +287211,7 @@ var POSTHOG_HOST = "https://us.i.posthog.com";
 var TSCI_POSTHOG_PROJECT_API_KEY = "phc_htd8AQjSfVEsFCLQMAiUooG4Q0DKBCjqYuQglc9V3Wo";
 var POSTHOG_CAPTURE_PATH = "/capture";
 var isTruthy4 = (value) => value ? ["1", "true", "yes", "on"].includes(value.toLowerCase()) : false;
-var joinUrl = (host, path66) => `${host.replace(/\/$/, "")}${path66}`;
+var joinUrl = (host, path67) => `${host.replace(/\/$/, "")}${path67}`;
 var getTelemetryConfigFromEnv = (env3 = process.env) => {
   if (isTruthy4(env3.TSCI_TELEMETRY_DISABLED)) {
     return { enabled: false };
@@ -287155,7 +287279,7 @@ var registerInit = (program3) => {
         }
       }
     }
-    const projectDir = directory ? path66.resolve(process.cwd(), directory) : process.cwd();
+    const projectDir = directory ? path67.resolve(process.cwd(), directory) : process.cwd();
     let tsciHandle = null;
     const token = getSessionToken();
     if (token) {
@@ -287166,7 +287290,7 @@ var registerInit = (program3) => {
         }
       } catch {}
     }
-    const dirName = path66.basename(projectDir);
+    const dirName = path67.basename(projectDir);
     let defaultPackageName = dirName;
     if (tsciHandle) {
       defaultPackageName = `@tsci/${tsciHandle}.${dirName}`;
@@ -287185,7 +287309,7 @@ var registerInit = (program3) => {
       }
     }
     fs60.mkdirSync(projectDir, { recursive: true });
-    writeFileIfNotExists(path66.join(projectDir, "index.circuit.tsx"), `
+    writeFileIfNotExists(path67.join(projectDir, "index.circuit.tsx"), `
 export default () => (
   <board>
     <resistor resistance="1k" footprint="0402" name="R1" />
@@ -287197,7 +287321,7 @@ export default () => (
     if (saveProjectConfig(null, projectDir)) {
       console.log("Created tscircuit.config.json with schema");
     }
-    writeFileIfNotExists(path66.join(projectDir, ".npmrc"), `
+    writeFileIfNotExists(path67.join(projectDir, ".npmrc"), `
 @tsci:registry=https://npm.tscircuit.com
 `);
     console.log("Generating package.json");
@@ -287336,9 +287460,9 @@ var registerRegistryPackagesCreate = (program3) => {
 // cli/registry/packages/update/register.ts
 import fs61 from "node:fs";
-import path67 from "node:path";
+import path68 from "node:path";
 var getCurrentDirectoryPackageName = () => {
-  const packageJsonPath = path67.join(process.cwd(), "package.json");
+  const packageJsonPath = path68.join(process.cwd(), "package.json");
   if (!fs61.existsSync(packageJsonPath))
     return;
   try {
@@ -287479,14 +287603,14 @@ var KeyStore = class {
   }
 };
 function createKey(key) {
-  let path68 = null;
+  let path69 = null;
   let id2 = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path68 = createKeyPath(key);
+    path69 = createKeyPath(key);
     id2 = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name"))
@@ -287498,12 +287622,12 @@ function createKey(key) {
       if (weight <= 0)
         throw new Error(INVALID_KEY_WEIGHT_VALUE(createKeyId(name)));
     }
-    path68 = createKeyPath(name);
+    path69 = createKeyPath(name);
     id2 = createKeyId(name);
     getFn = key.getFn ?? null;
   }
   return {
-    path: path68,
+    path: path69,
     id: id2,
     weight,
     src,
@@ -287516,22 +287640,22 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path68) {
+function get(obj, path69) {
   const list = [];
   let arr = false;
-  const deepGet = (obj2, path69, index, arrayIndex) => {
+  const deepGet = (obj2, path70, index, arrayIndex) => {
     if (!isDefined(obj2))
       return;
-    if (!path69[index])
+    if (!path70[index])
       list.push(arrayIndex !== undefined ? {
         v: obj2,
         i: arrayIndex
       } : obj2);
     else {
-      const value = obj2[path69[index]];
+      const value = obj2[path70[index]];
       if (!isDefined(value))
         return;
-      if (index === path69.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value) || typeof value === "bigint"))
+      if (index === path70.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value) || typeof value === "bigint"))
         list.push(arrayIndex !== undefined ? {
           v: toString2(value),
           i: arrayIndex
@@ -287539,12 +287663,12 @@ function get(obj, path68) {
       else if (isArray(value)) {
         arr = true;
         for (let i3 = 0, len = value.length;i3 < len; i3 += 1)
-          deepGet(value[i3], path69, index + 1, i3);
-      } else if (path69.length)
-        deepGet(value, path69, index + 1, arrayIndex);
+          deepGet(value[i3], path70, index + 1, i3);
+      } else if (path70.length)
+        deepGet(value, path70, index + 1, arrayIndex);
     }
   };
-  deepGet(obj, isString2(path68) ? path68.split(".") : path68, 0);
+  deepGet(obj, isString2(path69) ? path69.split(".") : path69, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -289122,9 +289246,9 @@ var registerSearch = (program3) => {
     }
     if (opts.json) {
       const unifiedResults = [
-        ...kicadResults.map((path68) => ({
+        ...kicadResults.map((path69) => ({
           source: "kicad",
-          path: path68
+          path: path69
         })),
         ...results.packages.map((pkg) => ({
           source: "tscircuit",
@@ -289152,8 +289276,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path68, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path68.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path69, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path69.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (results.packages.length) {
@@ -289178,20 +289302,20 @@ var registerSearch = (program3) => {
 // lib/shared/setup-github-actions.ts
 import fs62 from "node:fs";
-import path68 from "node:path";
+import path69 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path68.resolve(startDir);
-    while (dir !== path68.parse(dir).root) {
-      if (fs62.existsSync(path68.join(dir, ".git"))) {
+    let dir = path69.resolve(startDir);
+    while (dir !== path69.parse(dir).root) {
+      if (fs62.existsSync(path69.join(dir, ".git"))) {
         return dir;
       }
-      dir = path68.dirname(dir);
+      dir = path69.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path68.join(gitRoot, ".github", "workflows");
+  const workflowsDir = path69.join(gitRoot, ".github", "workflows");
   fs62.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
@@ -289231,8 +289355,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path68.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path68.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path69.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path69.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 // cli/setup/register.ts
@@ -289347,21 +289471,21 @@ var registerSimulate = (program3) => {
 // lib/shared/snapshot-project.ts
 import fs66 from "node:fs";
-import path71 from "node:path";
+import path72 from "node:path";
 // cli/snapshot/worker-pool.ts
 import fs63 from "node:fs";
-import path69 from "node:path";
+import path70 from "node:path";
 var getWorkerEntrypointPath2 = () => {
-  const tsPath = path69.join(import.meta.dir, "snapshot.worker.ts");
+  const tsPath = path70.join(import.meta.dir, "snapshot.worker.ts");
   if (fs63.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path69.join(import.meta.dir, "snapshot", "snapshot.worker.js");
+  const jsBundledPath = path70.join(import.meta.dir, "snapshot", "snapshot.worker.js");
   if (fs63.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path69.join(import.meta.dir, "snapshot.worker.js");
+  return path70.join(import.meta.dir, "snapshot.worker.js");
 };
 var snapshotFilesWithWorkerPool = async (options) => {
   const cancellationError = new Error("Snapshot cancelled due to file failure");
@@ -289432,7 +289556,7 @@ var snapshotFilesWithWorkerPool = async (options) => {
 // lib/shared/process-snapshot-file.ts
 import fs65 from "node:fs";
-import path70 from "node:path";
+import path71 from "node:path";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg5,
   convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg5
@@ -289481,7 +289605,7 @@ var processSnapshotFile = async ({
   cameraPreset,
   pcbLayer
 }) => {
-  const relativeFilePath = path70.relative(projectDir, file);
+  const relativeFilePath = path71.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -289576,11 +289700,11 @@ var processSnapshotFile = async ({
     } catch (error2) {
       const errorMessage = error2 instanceof Error ? error2.message : String(error2);
       if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-        const fileDir = path70.dirname(file);
-        const relativeDir = path70.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path70.join(projectDir, snapshotsDirName, relativeDir) : path70.join(fileDir, "__snapshots__");
-        const base2 = path70.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path70.join(snapDir2, `${base2}-3d.snap.png`);
+        const fileDir = path71.dirname(file);
+        const relativeDir = path71.relative(projectDir, fileDir);
+        const snapDir2 = snapshotsDirName ? path71.join(projectDir, snapshotsDirName, relativeDir) : path71.join(fileDir, "__snapshots__");
+        const base2 = path71.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path71.join(snapDir2, `${base2}-3d.snap.png`);
         const existing3dSnapshot = fs65.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
@@ -289592,7 +289716,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: ${path70.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path71.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -289613,9 +289737,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path70.join(projectDir, snapshotsDirName, path70.relative(projectDir, path70.dirname(file))) : path70.join(path70.dirname(file), "__snapshots__");
+  const snapDir = snapshotsDirName ? path71.join(projectDir, snapshotsDirName, path71.relative(projectDir, path71.dirname(file))) : path71.join(path71.dirname(file), "__snapshots__");
   fs65.mkdirSync(snapDir, { recursive: true });
-  const base = path70.basename(file).replace(/\.[^.]+$/, "");
+  const base = path71.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (!simulationOnly && (pcbOnly || !schematicOnly)) {
     let pcbSnapshotType = "pcb";
@@ -289649,13 +289773,13 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path70.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const snapPath = path71.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
     const existing = fs65.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
       fs65.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path70.relative(projectDir, snapPath));
+      successPaths.push(path71.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
@@ -289671,16 +289795,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal2) {
-        successPaths.push(path70.relative(projectDir, snapPath));
+        successPaths.push(path71.relative(projectDir, snapPath));
       } else {
         fs65.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path70.relative(projectDir, snapPath));
+        successPaths.push(path71.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal2) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path70.relative(projectDir, snapPath));
+      successPaths.push(path71.relative(projectDir, snapPath));
     }
   }
   return {
@@ -289725,7 +289849,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f3) => path71.resolve(projectDir, f3));
+  const resolvedPaths = filePaths.map((f3) => path72.resolve(projectDir, f3));
   const explicitDirectoryTarget = resolvedPaths.find((resolvedPath) => {
     if (!fs66.existsSync(resolvedPath)) {
       return false;
@@ -289739,7 +289863,7 @@ var snapshotProject = async ({
   });
   if (boardFiles.length === 0) {
     if (explicitDirectoryTarget) {
-      const relativeDirectory = path71.relative(projectDir, explicitDirectoryTarget) || ".";
+      const relativeDirectory = path72.relative(projectDir, explicitDirectoryTarget) || ".";
       const runtimeIncludeBoardFilePatterns = projectConfig2?.includeBoardFiles?.filter((pattern) => pattern.trim()) ?? [];
       const includeBoardFilePatterns = runtimeIncludeBoardFilePatterns.length > 0 ? runtimeIncludeBoardFilePatterns : getBoardFilePatterns(projectDir);
       const patternSourceMessage = hasConfiguredIncludeBoardFiles(projectConfig2) ? "Searched using tscircuit.config.json includeBoardFiles" : "Searched using default includeBoardFiles";
@@ -289903,7 +290027,7 @@ var registerSnapshot = (program3) => {
 };
 // cli/transpile/register.ts
-import path72 from "node:path";
+import path73 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 {
@@ -289911,7 +290035,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path72.join(projectDir, "dist");
+      const distDir = path73.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];
@@ -289949,12 +290073,12 @@ function registerUpgradeCommand(program3) {
 }
 // lib/shared/update-package.ts
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 import * as fs67 from "node:fs";
 async function updatePackage(packageSpec, projectDir = process.cwd()) {
   const packageManager = getPackageManager();
   if (!packageSpec) {
-    const pkgJsonPath = path73.join(projectDir, "package.json");
+    const pkgJsonPath = path74.join(projectDir, "package.json");
     if (!fs67.existsSync(pkgJsonPath)) {
       console.log(kleur_default.yellow("No package.json found. Cannot update all packages."));
       return;
@@ -290042,6 +290166,7 @@ registerCheckPinSpecification(program2);
 registerCheckPlacement(program2);
 registerCheckRoutingDifficulty(program2);
 registerCheckSchematicPlacement(program2);
+registerCheckShorts(program2);
 registerCheckTraceLength(program2);
 registerRegistry(program2);
 registerRegistryPackages(program2);