@tscircuit/cli 0.1.1053 → 0.1.1055

package/dist/cli/main.js

@@ -68605,18 +68605,18 @@ globstar while`, file, fr, pattern, pr, swallowee);
           abs = abs.replace(/\\/g, "/");
         return abs;
       }
-      function isIgnored(self2, path46) {
+      function isIgnored(self2, path47) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return item.matcher.match(path46) || !!(item.gmatcher && item.gmatcher.match(path46));
+          return item.matcher.match(path47) || !!(item.gmatcher && item.gmatcher.match(path47));
         });
       }
-      function childrenIgnored(self2, path46) {
+      function childrenIgnored(self2, path47) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return !!(item.gmatcher && item.gmatcher.match(path46));
+          return !!(item.gmatcher && item.gmatcher.match(path47));
         });
       }
     }
@@ -71664,7 +71664,7 @@ var registerStaticAssetLoaders = () => {
 // cli/main.ts
 var import_perfect_cli = __toESM2(require_dist2(), 1);
 // package.json
-var version = "0.1.1052";
+var version = "0.1.1054";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -82554,16 +82554,293 @@ var registerBuild = (program2) => {
   });
 };
 
+// node_modules/circuit-json-to-readable-netlist/dist/index.js
+import { su as su3 } from "@tscircuit/circuit-json-util";
+import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+import { su as su2 } from "@tscircuit/circuit-json-util";
+import { su } from "@tscircuit/circuit-json-util";
+var wordQualityScore = {
+  MISO: 1.2,
+  MOSI: 1.2,
+  SCLK: 1.2,
+  SDA: 1.2,
+  SCL: 1.2,
+  RX: 1.15,
+  TX: 1.15,
+  GPIO: 1.1,
+  cathode: 0.5,
+  anode: 0.5,
+  GND: 1.1,
+  VDD: 1.1,
+  AGND: 1.1,
+  V5: 1.1,
+  V3: 1.1,
+  V1: 1.1,
+  neg: 0.9,
+  pos: 0.9,
+  pin: 0.5,
+  left: 0.3,
+  right: 0.3
+};
+var wordQualityScoreEntries = Object.entries(wordQualityScore).sort((a, b) => b[1] - a[1]);
+var scorePhrase = (phrase) => {
+  if (phrase.match(/\d+/)) {
+    return 0.5;
+  }
+  for (const [word, score] of wordQualityScoreEntries) {
+    if (phrase.includes(word)) {
+      return score;
+    }
+  }
+  return 1;
+};
+var getReadableNameForPin = ({
+  circuitJson,
+  source_port_id
+}) => {
+  const source_ports = su(circuitJson).source_port.list();
+  const source_components = su(circuitJson).source_component.list();
+  const port = source_ports.find((p) => p.source_port_id === source_port_id);
+  if (!port)
+    return "";
+  const component = source_components.find((c) => c.source_component_id === port.source_component_id);
+  if (!component)
+    return "";
+  const isPositive = port.port_hints?.some((hint) => ["anode", "pos", "positive"].includes(hint.toLowerCase()));
+  const isNegative = port.port_hints?.some((hint) => ["cathode", "neg", "negative"].includes(hint.toLowerCase()));
+  const mainPinName = port.name ? port.name : `Pin${port.pin_number}`;
+  const additionalPinLabels = [];
+  if (isPositive && component.ftype !== "simple_resistor") {
+    additionalPinLabels.push("+");
+  } else if (isNegative && component.ftype !== "simple_resistor") {
+    additionalPinLabels.push("-");
+  }
+  for (const port_hint of port.port_hints ?? []) {
+    if (port_hint === mainPinName)
+      continue;
+    const score = scorePhrase(port_hint);
+    if (score > 1) {
+      additionalPinLabels.push(port_hint);
+    }
+  }
+  const displayValue = component.display_value ? ` (${component.display_value})` : "";
+  return `${component.name} ${mainPinName}${additionalPinLabels.length > 0 ? ` (${additionalPinLabels.join(",")})` : ""}${displayValue}`;
+};
+var scoreComponentOrder = (component) => {
+  if (!("ftype" in component))
+    return 0;
+  if (component.ftype === "simple_resistor")
+    return 0;
+  if (component.ftype === "simple_capacitor")
+    return 1;
+  return 2;
+};
+var generateNetName = ({
+  circuitJson,
+  connectedIds
+}) => {
+  const all_source_components = su2(circuitJson).source_component.list();
+  const sourceComponentIdToScore = /* @__PURE__ */ new Map;
+  for (const component of all_source_components) {
+    sourceComponentIdToScore.set(component.source_component_id, scoreComponentOrder(component));
+  }
+  all_source_components.sort((a, b) => sourceComponentIdToScore.get(b.source_component_id) - sourceComponentIdToScore.get(a.source_component_id));
+  const all_source_ports = su2(circuitJson).source_port.list().sort((a, b) => sourceComponentIdToScore.get(b.source_component_id) - sourceComponentIdToScore.get(a.source_component_id));
+  const all_source_nets = su2(circuitJson).source_net.list();
+  const all_source_traces = su2(circuitJson).source_trace.list();
+  const ports = all_source_ports.filter((p) => connectedIds.includes(p.source_port_id));
+  const nets = all_source_nets.filter((n) => connectedIds.includes(n.source_net_id));
+  const traces = all_source_traces.filter((t) => connectedIds.includes(t.source_trace_id));
+  const possibleNames = ports.flatMap((p) => Array.from(/* @__PURE__ */ new Set([...p.name ? [p.name] : [], ...p.port_hints ?? []]))).concat(nets.map((n) => n.name));
+  const phrases = possibleNames.map((name) => ({
+    name,
+    score: scorePhrase(name)
+  }));
+  const bestPortName = phrases.sort((a, b) => b.score - a.score)[0].name;
+  const bestPort = ports.find((p) => p.name === bestPortName || p.port_hints?.includes(bestPortName));
+  const componentWithBestPort = all_source_components.find((c) => c.source_component_id === bestPort?.source_component_id);
+  return [componentWithBestPort?.name, bestPortName].filter(Boolean).join("_");
+};
+var convertCircuitJsonToReadableNetlist = (circuitJson) => {
+  const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson.filter((e) => e.type.startsWith("source_")));
+  const netMap = connectivityMap.netMap;
+  const source_ports = su3(circuitJson).source_port.list();
+  const source_components = su3(circuitJson).source_component.list();
+  const source_nets = su3(circuitJson).source_net.list();
+  const source_traces = su3(circuitJson).source_trace.list();
+  const netlist = [];
+  netlist.push("COMPONENTS:");
+  for (const component of source_components) {
+    let componentDescription = "";
+    const cadComponent = su3(circuitJson).cad_component.getWhere({
+      source_component_id: component.source_component_id
+    });
+    const footprint = cadComponent?.footprinter_string;
+    if (component.ftype === "simple_resistor") {
+      componentDescription = `${component.display_resistance}${footprint ? ` ${footprint}` : ""} resistor`;
+    } else if (component.ftype === "simple_capacitor") {
+      componentDescription = `${component.display_capacitance}${footprint ? ` ${footprint}` : ""} capacitor`;
+    } else if (component.ftype === "simple_chip") {
+      const manufacturerPartNumber = component.manufacturer_part_number;
+      componentDescription = [manufacturerPartNumber, footprint].filter(Boolean).join(", ");
+    } else {
+      componentDescription = [component.name, component.type].filter(Boolean).join(", ");
+    }
+    netlist.push(` - ${component.name}: ${componentDescription}`);
+  }
+  netlist.push("");
+  for (const [netId, connectedIds] of Object.entries(netMap)) {
+    const net = source_nets.find((n) => connectedIds.includes(n.source_net_id));
+    let netName = net?.name;
+    if (!netName) {
+      netName = generateNetName({ circuitJson, connectedIds });
+    }
+    const connectedPortCount = connectedIds.filter((id) => id.startsWith("source_port")).length;
+    if (connectedPortCount <= 1)
+      continue;
+    netlist.push(`NET: ${netName}`);
+    for (const id of connectedIds) {
+      const pinName = getReadableNameForPin({
+        circuitJson,
+        source_port_id: id
+      });
+      if (pinName) {
+        netlist.push(`  - ${pinName}`);
+      }
+    }
+    netlist.push("");
+  }
+  let hasEmptyNets = false;
+  for (const [netId, connectedIds] of Object.entries(netMap)) {
+    const connectedPortCount = connectedIds.filter((id) => id.startsWith("source_port")).length;
+    if (connectedPortCount === 1) {
+      if (!hasEmptyNets) {
+        netlist.push("");
+        netlist.push("EMPTY NET PINS:");
+        hasEmptyNets = true;
+      }
+      const source_port_id = netMap[netId].find((id) => id.startsWith("source_port"));
+      const pinName = getReadableNameForPin({
+        circuitJson,
+        source_port_id
+      });
+      if (pinName) {
+        netlist.push(`  - ${pinName}`);
+      }
+    }
+  }
+  const portIdToNetNames = {};
+  for (const [netId, connectedIds] of Object.entries(netMap)) {
+    const portIds = connectedIds.filter((id) => id.startsWith("source_port"));
+    if (portIds.length === 0)
+      continue;
+    const net = source_nets.find((n) => connectedIds.includes(n.source_net_id));
+    let netName = net?.name;
+    if (!netName) {
+      netName = generateNetName({ circuitJson, connectedIds });
+    }
+    for (const portId of portIds) {
+      if (!portIdToNetNames[portId])
+        portIdToNetNames[portId] = [];
+      portIdToNetNames[portId].push(netName);
+    }
+  }
+  if (source_components.length > 0) {
+    netlist.push("");
+    netlist.push("COMPONENT_PINS:");
+    for (const component of source_components) {
+      const cadComponent = su3(circuitJson).cad_component.getWhere({
+        source_component_id: component.source_component_id
+      });
+      const footprint = cadComponent?.footprinter_string;
+      let header = component.name;
+      if (component.ftype === "simple_resistor") {
+        header = `${component.name} (${component.display_resistance} ${footprint})`;
+      } else if (component.ftype === "simple_capacitor") {
+        header = `${component.name} (${component.display_capacitance} ${footprint})`;
+      } else if (component.manufacturer_part_number) {
+        header = `${component.name} (${component.manufacturer_part_number})`;
+      }
+      netlist.push(header);
+      const ports = source_ports.filter((p) => p.source_component_id === component.source_component_id).sort((a, b) => (a.pin_number ?? 0) - (b.pin_number ?? 0));
+      for (const port of ports) {
+        const mainPin = port.pin_number !== undefined ? `pin${port.pin_number}` : port.name;
+        const aliases = [];
+        if (port.name && port.name !== mainPin)
+          aliases.push(port.name);
+        for (const hint of port.port_hints ?? []) {
+          if (hint === String(port.pin_number))
+            continue;
+          if (hint !== mainPin && hint !== port.name)
+            aliases.push(hint);
+        }
+        const aliasPart = aliases.length > 0 ? `(${Array.from(new Set(aliases)).join(", ")})` : "";
+        const nets = portIdToNetNames[port.source_port_id] ?? [];
+        const netsPart = nets.length > 0 ? `NETS(${nets.join(", ")})` : "NOT_CONNECTED";
+        netlist.push(`- ${mainPin}${aliasPart}: ${netsPart}`);
+      }
+      netlist.push("");
+    }
+  }
+  return netlist.join(`
+`);
+};
+
 // cli/check/netlist/register.ts
+import path40 from "node:path";
+var resolveInputFilePath = async (file) => {
+  if (file) {
+    return path40.isAbsolute(file) ? file : path40.resolve(process.cwd(), file);
+  }
+  const entrypoint = await getEntrypoint({
+    projectDir: process.cwd()
+  });
+  if (!entrypoint) {
+    throw new Error("No input file provided and no entrypoint found");
+  }
+  return entrypoint;
+};
+var checkNetlist = async (file) => {
+  const resolvedInputFilePath = await resolveInputFilePath(file);
+  const completePlatformConfig = getCompletePlatformConfig({
+    routingDrcChecksDisabled: true,
+    placementDrcChecksDisabled: true
+  });
+  const { circuitJson } = await generateCircuitJson({
+    filePath: resolvedInputFilePath,
+    platformConfig: completePlatformConfig
+  });
+  const typedCircuitJson = circuitJson;
+  const diagnostics = analyzeCircuitJson(typedCircuitJson);
+  const readableNetlist = convertCircuitJsonToReadableNetlist(typedCircuitJson);
+  const diagnosticsLines = [
+    `Errors: ${diagnostics.errors.length}`,
+    `Warnings: ${diagnostics.warnings.length}`
+  ];
+  if (diagnostics.errors.length > 0) {
+    diagnosticsLines.push(...diagnostics.errors.map((err) => `- ${err.type}: ${err.message ?? ""}`));
+  }
+  return `${diagnosticsLines.join(`
+`)}
+
+Readable Netlist:
+${readableNetlist}`;
+};
 var registerCheckNetlist = (program2) => {
-  program2.commands.find((c) => c.name() === "check").command("netlist").description("Partially build and validate the netlist").argument("[refdeses]", "Optional refdeses to scope the check").action(() => {
-    throw new Error("Not implemented");
+  program2.commands.find((c) => c.name() === "check").command("netlist").description("Partially build and validate the netlist").argument("[file]", "Path to the entry file").action(async (file) => {
+    try {
+      const output = await checkNetlist(file);
+      console.log(output);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
   });
 };
 
 // cli/check/placement/register.ts
 import fs38 from "node:fs";
-import path40 from "node:path";
+import path41 from "node:path";
 
 // node_modules/@tscircuit/circuit-json-placement-analysis/dist/index.js
 var CENTER_ANCHOR = "center";
@@ -82878,9 +83155,9 @@ var isPrebuiltCircuitJsonFile = (filePath) => {
   const normalizedInputPath = filePath.toLowerCase().replaceAll("\\", "/");
   return normalizedInputPath.endsWith(".circuit.json") || normalizedInputPath.endsWith("/circuit.json");
 };
-var resolveInputFilePath = async (file) => {
+var resolveInputFilePath2 = async (file) => {
   if (file) {
-    return path40.isAbsolute(file) ? file : path40.resolve(process.cwd(), file);
+    return path41.isAbsolute(file) ? file : path41.resolve(process.cwd(), file);
   }
   const entrypoint = await getEntrypoint({
     projectDir: process.cwd()
@@ -82906,7 +83183,7 @@ var getCircuitJsonForPlacementCheck = async (filePath) => {
   return circuitJson;
 };
 var checkPlacement = async (file, refdes) => {
-  const resolvedInputFilePath = await resolveInputFilePath(file);
+  const resolvedInputFilePath = await resolveInputFilePath2(file);
   const circuitJson = await getCircuitJsonForPlacementCheck(resolvedInputFilePath);
   const analysis = refdes ? analyzeComponentPlacement(circuitJson, refdes) : analyzeAllPlacements(circuitJson);
   return analysis.getString();
@@ -82937,25 +83214,25 @@ var registerCheckRouting = (program2) => {
 
 // cli/clone/register.ts
 import * as fs41 from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 
 // cli/clone/clone-bug-report.ts
 var import_jszip2 = __toESM2(require_lib4(), 1);
 var import_prompts4 = __toESM2(require_prompts3(), 1);
 import * as fs40 from "node:fs";
-import * as path42 from "node:path";
+import * as path43 from "node:path";
 
 // cli/clone/handle-existing-directory.ts
 var import_prompts3 = __toESM2(require_prompts3(), 1);
 import * as fs39 from "node:fs";
-import * as path41 from "node:path";
+import * as path42 from "node:path";
 var handleExistingDirectory = async (dirPath) => {
   if (!fs39.existsSync(dirPath))
     return;
   const response = await import_prompts3.default({
     type: "select",
     name: "action",
-    message: `Directory "${path41.basename(dirPath)}" already exists. What would you like to do?`,
+    message: `Directory "${path42.basename(dirPath)}" already exists. What would you like to do?`,
     choices: [
       { title: "Merge files into existing directory", value: "merge" },
       {
@@ -82996,12 +83273,12 @@ var getCommonDirectoryPrefix = (paths) => {
   return commonSegments.join("/");
 };
 var sanitizeRelativePath = (relativePath) => {
-  const normalizedPath = path42.normalize(relativePath);
+  const normalizedPath = path43.normalize(relativePath);
   if (!normalizedPath)
     return null;
-  if (path42.isAbsolute(normalizedPath))
+  if (path43.isAbsolute(normalizedPath))
     return null;
-  const segments = normalizedPath.split(path42.sep);
+  const segments = normalizedPath.split(path43.sep);
   if (segments.some((segment) => segment === ".." || segment === "")) {
     return null;
   }
@@ -83016,7 +83293,7 @@ var cloneBugReport = async ({
     console.error("Bug report ID must not be empty.");
     process.exit(1);
   }
-  let dirPath = path42.resolve(`bug-report-${trimmedBugReportId}`);
+  let dirPath = path43.resolve(`bug-report-${trimmedBugReportId}`);
   await handleExistingDirectory(dirPath);
   const ky2 = getRegistryApiKy();
   let zipBuffer;
@@ -83046,25 +83323,25 @@ var cloneBugReport = async ({
       console.warn(`Skipping potentially unsafe path: ${fileName}`);
       continue;
     }
-    const fullPath = path42.join(dirPath, sanitizedRelativePath);
-    fs40.mkdirSync(path42.dirname(fullPath), { recursive: true });
+    const fullPath = path43.join(dirPath, sanitizedRelativePath);
+    fs40.mkdirSync(path43.dirname(fullPath), { recursive: true });
     const fileContent = await entry.async("nodebuffer");
     fs40.writeFileSync(fullPath, fileContent);
   }
-  const packageJsonPath = path42.join(dirPath, "package.json");
+  const packageJsonPath = path43.join(dirPath, "package.json");
   if (fs40.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs40.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 = path42.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
+        const suggestedDirPath = path43.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
         if (suggestedDirPath !== dirPath) {
           const response = await import_prompts4.default({
             type: "confirm",
             name: "rename",
             initial: true,
-            message: `Rename the directory to "${path42.basename(suggestedDirPath)}"?`
+            message: `Rename the directory to "${path43.basename(suggestedDirPath)}"?`
           });
           if (response.rename) {
             await handleExistingDirectory(suggestedDirPath);
@@ -83077,9 +83354,9 @@ var cloneBugReport = async ({
       console.warn("Unable to read package name for renaming:", error);
     }
   }
-  fs40.writeFileSync(path42.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+  fs40.writeFileSync(path43.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
   generateTsConfig(dirPath);
-  const relativeDirPath = path42.relative(originalCwd, dirPath);
+  const relativeDirPath = path43.relative(originalCwd, dirPath);
   console.log(kleur_default.green(`
 Successfully cloned bug report to:`));
   console.log(`  ${dirPath}/
@@ -83118,7 +83395,7 @@ var registerClone = (program2) => {
     const [, author, packageName] = match;
     console.log(`Cloning ${author}/${packageName}...`);
     const userSettingToIncludeAuthor = options.includeAuthor || cliConfig.get("alwaysCloneWithAuthorName");
-    const dirPath = userSettingToIncludeAuthor ? path43.resolve(`${author}.${packageName}`) : path43.resolve(packageName);
+    const dirPath = userSettingToIncludeAuthor ? path44.resolve(`${author}.${packageName}`) : path44.resolve(packageName);
     await handleExistingDirectory(dirPath);
     const ky2 = getRegistryApiKy();
     let packageFileList = {
@@ -83144,8 +83421,8 @@ var registerClone = (program2) => {
       const filePath = fileInfo.file_path.replace(/^\/+/, "");
       if (!filePath)
         continue;
-      const fullPath = path43.join(dirPath, filePath);
-      fs41.mkdirSync(path43.dirname(fullPath), { recursive: true });
+      const fullPath = path44.join(dirPath, filePath);
+      fs41.mkdirSync(path44.dirname(fullPath), { recursive: true });
       try {
         const fileContent = await ky2.get("package_files/get", {
           searchParams: {
@@ -83171,10 +83448,10 @@ var registerClone = (program2) => {
         console.warn(`Skipping ${filePath} due to error:`, error instanceof Error ? error.message : error);
       }
     }
-    fs41.writeFileSync(path43.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+    fs41.writeFileSync(path44.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
     generateTsConfig(dirPath);
     await setupTsciProject(dirPath);
-    const relativeDirPath = path43.relative(originalCwd, dirPath);
+    const relativeDirPath = path44.relative(originalCwd, dirPath);
     console.log(kleur_default.green(`
 Successfully cloned to:`));
     console.log(`  ${dirPath}/
@@ -83242,7 +83519,7 @@ var registerConfigSet = (program2) => {
 
 // cli/convert/register.ts
 import fs42 from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -83271,14 +83548,14 @@ var mmStr = (n) => {
 };
 
 // node_modules/circuit-json-to-tscircuit/dist/chunk-EX2F3BMQ.js
-import { su } from "@tscircuit/soup-util";
+import { su as su4 } from "@tscircuit/soup-util";
 var generateFootprintTsx = (circuitJson) => {
-  const holes = su(circuitJson).pcb_hole.list();
-  const platedHoles = su(circuitJson).pcb_plated_hole.list();
-  const smtPads = su(circuitJson).pcb_smtpad.list();
-  const silkscreenPaths = su(circuitJson).pcb_silkscreen_path.list();
-  const fabricationNotePaths = su(circuitJson).pcb_fabrication_note_path.list();
-  const silkscreenTexts = su(circuitJson).pcb_silkscreen_text.list();
+  const holes = su4(circuitJson).pcb_hole.list();
+  const platedHoles = su4(circuitJson).pcb_plated_hole.list();
+  const smtPads = su4(circuitJson).pcb_smtpad.list();
+  const silkscreenPaths = su4(circuitJson).pcb_silkscreen_path.list();
+  const fabricationNotePaths = su4(circuitJson).pcb_fabrication_note_path.list();
+  const silkscreenTexts = su4(circuitJson).pcb_silkscreen_text.list();
   const elementStrings = [];
   for (const hole of holes) {
     if (hole.hole_shape === "circle") {
@@ -83363,14 +83640,14 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program2) => {
   program2.command("convert").description("Convert a .kicad_mod footprint to a tscircuit component").argument("<file>", "Path to the .kicad_mod file").option("-o, --output <path>", "Output TSX file path").option("-n, --name <component>", "Component name for export").action(async (file, options) => {
     try {
-      const inputPath = path44.resolve(file);
+      const inputPath = path45.resolve(file);
       const modContent = await fs42.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path44.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path45.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path44.resolve(options.output) : path44.join(path44.dirname(inputPath), `${componentName}.tsx`);
+      const outputPath = options.output ? path45.resolve(options.output) : path45.join(path45.dirname(inputPath), `${componentName}.tsx`);
       await fs42.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
@@ -83383,11 +83660,11 @@ var registerConvert = (program2) => {
 // cli/dev/register.ts
 import * as fs49 from "node:fs";
 import * as net from "node:net";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 
 // cli/dev/DevServer.ts
 import fs47 from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -83466,7 +83743,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path45) => statMethod(path45, { bigint: true });
+      this._stat = (path46) => statMethod(path46, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -83491,8 +83768,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path45, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path45));
+          const { path: path46, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path46));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -83532,20 +83809,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path45, depth) {
+  async _exploreDir(path46, depth) {
     let files;
     try {
-      files = await readdir(path45, this._rdOptions);
+      files = await readdir(path46, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path45 };
+    return { files, depth, path: path46 };
   }
-  async _formatEntry(dirent, path45) {
+  async _formatEntry(dirent, path46) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path45, basename4));
+      const fullPath = presolve(pjoin(path46, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -83943,16 +84220,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path45, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path46, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path45);
-    emitRaw(rawEvent, evPath, { watchedPath: path45 });
-    if (evPath && path45 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path45, evPath), KEY_LISTENERS, sysPath.join(path45, evPath));
+    listener(path46);
+    emitRaw(rawEvent, evPath, { watchedPath: path46 });
+    if (evPath && path46 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path46, evPath), KEY_LISTENERS, sysPath.join(path46, evPath));
     }
   };
   try {
-    return fs_watch(path45, {
+    return fs_watch(path46, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -83968,12 +84245,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path45, fullPath, options, handlers) => {
+var setFsWatchListener = (path46, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path45, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path46, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -83983,7 +84260,7 @@ var setFsWatchListener = (path45, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path45, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path46, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -83992,7 +84269,7 @@ var setFsWatchListener = (path45, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path45, "r");
+          const fd = await open(path46, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -84022,7 +84299,7 @@ var setFsWatchListener = (path45, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path45, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path46, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -84044,7 +84321,7 @@ var setFsWatchFileListener = (path45, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path45, curr));
+          foreach(cont.listeners, (listener2) => listener2(path46, curr));
         }
       })
     };
@@ -84067,13 +84344,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path45, listener) {
+  _watchWithNodeFs(path46, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path45);
-    const basename5 = sysPath.basename(path45);
+    const directory = sysPath.dirname(path46);
+    const basename5 = sysPath.basename(path46);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sysPath.resolve(path45);
+    const absolutePath = sysPath.resolve(path46);
     const options = {
       persistent: opts.persistent
     };
@@ -84083,12 +84360,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path45, absolutePath, options, {
+      closer = setFsWatchFileListener(path46, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path45, absolutePath, options, {
+      closer = setFsWatchListener(path46, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -84106,7 +84383,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path45, newStats) => {
+    const listener = async (path46, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -84120,11 +84397,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path45);
+            this.fsw._closeFile(path46);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path45, closer2);
+              this.fsw._addPathCloser(path46, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -84148,7 +84425,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path45, item) {
+  async _handleSymlink(entry, directory, path46, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -84158,7 +84435,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path45);
+        linkPath = await fsrealpath(path46);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -84168,12 +84445,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, path45, entry.stats);
+          this.fsw._emit(EV.CHANGE, path46, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path45, entry.stats);
+        this.fsw._emit(EV.ADD, path46, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -84202,9 +84479,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path45 = sysPath.join(directory, item);
+      let path46 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path45, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path46, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -84213,8 +84490,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path45 = sysPath.join(dir, sysPath.relative(dir, path45));
-        this._addToNodeFs(path45, initialAdd, wh, depth + 1);
+        path46 = sysPath.join(dir, sysPath.relative(dir, path46));
+        this._addToNodeFs(path46, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve7, reject) => {
@@ -84263,13 +84540,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path45, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path46, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path45) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path46) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path45);
+    const wh = this.fsw._getWatchHelpers(path46);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -84285,8 +84562,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path45);
-        const targetPath = follow ? await fsrealpath(path45) : path45;
+        const absPath = sysPath.resolve(path46);
+        const targetPath = follow ? await fsrealpath(path46) : path46;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -84296,29 +84573,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path45) : path45;
+        const targetPath = follow ? await fsrealpath(path46) : path46;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path45, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path46, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path45), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path46), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path45, closer);
+        this.fsw._addPathCloser(path46, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path45;
+        return path46;
       }
     }
   }
@@ -84361,26 +84638,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path45) {
-  if (typeof path45 !== "string")
+function normalizePath(path46) {
+  if (typeof path46 !== "string")
     throw new Error("string expected");
-  path45 = sysPath2.normalize(path45);
-  path45 = path45.replace(/\\/g, "/");
+  path46 = sysPath2.normalize(path46);
+  path46 = path46.replace(/\\/g, "/");
   let prepend = false;
-  if (path45.startsWith("//"))
+  if (path46.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path45.match(DOUBLE_SLASH_RE2))
-    path45 = path45.replace(DOUBLE_SLASH_RE2, "/");
+  while (path46.match(DOUBLE_SLASH_RE2))
+    path46 = path46.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path45 = "/" + path45;
-  return path45;
+    path46 = "/" + path46;
+  return path46;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path45 = normalizePath(testString);
+  const path46 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path45, stats)) {
+    if (pattern(path46, stats)) {
       return true;
     }
   }
@@ -84420,19 +84697,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path45) => toUnix(sysPath2.normalize(toUnix(path45)));
-var normalizeIgnored = (cwd = "") => (path45) => {
-  if (typeof path45 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path45) ? path45 : sysPath2.join(cwd, path45));
+var normalizePathToUnix = (path46) => toUnix(sysPath2.normalize(toUnix(path46)));
+var normalizeIgnored = (cwd = "") => (path46) => {
+  if (typeof path46 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path46) ? path46 : sysPath2.join(cwd, path46));
   } else {
-    return path45;
+    return path46;
   }
 };
-var getAbsolutePath = (path45, cwd) => {
-  if (sysPath2.isAbsolute(path45)) {
-    return path45;
+var getAbsolutePath = (path46, cwd) => {
+  if (sysPath2.isAbsolute(path46)) {
+    return path46;
   }
-  return sysPath2.join(cwd, path45);
+  return sysPath2.join(cwd, path46);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -84489,10 +84766,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path45, follow, fsw) {
+  constructor(path46, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path45;
-    this.path = path45 = path45.replace(REPLACER_RE, "");
+    const watchPath = path46;
+    this.path = path46 = path46.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -84605,20 +84882,20 @@ class FSWatcher extends EventEmitter {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path45) => {
-        const absPath = getAbsolutePath(path45, cwd);
+      paths = paths.map((path46) => {
+        const absPath = getAbsolutePath(path46, cwd);
         return absPath;
       });
     }
-    paths.forEach((path45) => {
-      this._removeIgnoredPath(path45);
+    paths.forEach((path46) => {
+      this._removeIgnoredPath(path46);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path45) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path45, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path46) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path46, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -84637,17 +84914,17 @@ class FSWatcher extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path45) => {
-      if (!sysPath2.isAbsolute(path45) && !this._closers.has(path45)) {
+    paths.forEach((path46) => {
+      if (!sysPath2.isAbsolute(path46) && !this._closers.has(path46)) {
         if (cwd)
-          path45 = sysPath2.join(cwd, path45);
-        path45 = sysPath2.resolve(path45);
+          path46 = sysPath2.join(cwd, path46);
+        path46 = sysPath2.resolve(path46);
       }
-      this._closePath(path45);
-      this._addIgnoredPath(path45);
-      if (this._watched.has(path45)) {
+      this._closePath(path46);
+      this._addIgnoredPath(path46);
+      if (this._watched.has(path46)) {
         this._addIgnoredPath({
-          path: path45,
+          path: path46,
           recursive: true
         });
       }
@@ -84696,38 +84973,38 @@ class FSWatcher extends EventEmitter {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, ...args);
   }
-  async _emit(event, path45, stats) {
+  async _emit(event, path46, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path45 = sysPath2.normalize(path45);
+      path46 = sysPath2.normalize(path46);
     if (opts.cwd)
-      path45 = sysPath2.relative(opts.cwd, path45);
-    const args = [event, path45];
+      path46 = sysPath2.relative(opts.cwd, path46);
+    const args = [event, path46];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path45))) {
+    if (awf && (pw = this._pendingWrites.get(path46))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path45, args);
+        this._pendingUnlinks.set(path46, args);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path46) => {
+          this._pendingUnlinks.forEach((entry, path47) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path46);
+            this._pendingUnlinks.delete(path47);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path45)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path46)) {
         event = args[0] = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path45);
+        this._pendingUnlinks.delete(path46);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -84745,16 +85022,16 @@ class FSWatcher extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path45, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path46, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path45, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path46, 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, path45) : path45;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path46) : path46;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -84773,23 +85050,23 @@ class FSWatcher extends EventEmitter {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path45, timeout2) {
+  _throttle(actionType, path46, 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(path45);
+    const actionPath = action.get(path46);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path45);
+      const item = action.get(path46);
       const count = item ? item.count : 0;
-      action.delete(path45);
+      action.delete(path46);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -84797,50 +85074,50 @@ class FSWatcher extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout2);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path45, thr);
+    action.set(path46, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path45, threshold, event, awfEmit) {
+  _awaitWriteFinish(path46, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path45;
-    if (this.options.cwd && !sysPath2.isAbsolute(path45)) {
-      fullPath = sysPath2.join(this.options.cwd, path45);
+    let fullPath = path46;
+    if (this.options.cwd && !sysPath2.isAbsolute(path46)) {
+      fullPath = sysPath2.join(this.options.cwd, path46);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path45)) {
+        if (err || !writes.has(path46)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path45).lastChange = now2;
+          writes.get(path46).lastChange = now2;
         }
-        const pw = writes.get(path45);
+        const pw = writes.get(path46);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path45);
+          writes.delete(path46);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path45)) {
-      writes.set(path45, {
+    if (!writes.has(path46)) {
+      writes.set(path46, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path45);
+          writes.delete(path46);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -84848,8 +85125,8 @@ class FSWatcher extends EventEmitter {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path45, stats) {
-    if (this.options.atomic && DOT_RE.test(path45))
+  _isIgnored(path46, stats) {
+    if (this.options.atomic && DOT_RE.test(path46))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -84859,13 +85136,13 @@ class FSWatcher extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path45, stats);
+    return this._userIgnored(path46, stats);
   }
-  _isntIgnored(path45, stat4) {
-    return !this._isIgnored(path45, stat4);
+  _isntIgnored(path46, stat4) {
+    return !this._isIgnored(path46, stat4);
   }
-  _getWatchHelpers(path45) {
-    return new WatchHelper(path45, this.options.followSymlinks, this);
+  _getWatchHelpers(path46) {
+    return new WatchHelper(path46, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -84879,57 +85156,57 @@ class FSWatcher extends EventEmitter {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory2) {
-    const path45 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path45);
-    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path45) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path45, 100))
+    const path46 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path46);
+    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path46) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path46, 100))
       return;
     if (!isDirectory2 && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path45);
+    const wp = this._getWatchedDir(path46);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path45, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path46, 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 = path45;
+    let relPath = path46;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path45);
+      relPath = sysPath2.relative(this.options.cwd, path46);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path45);
+    this._watched.delete(path46);
     this._watched.delete(fullPath);
     const eventName = isDirectory2 ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path45))
-      this._emit(eventName, path45);
-    this._closePath(path45);
+    if (wasTracked && !this._isIgnored(path46))
+      this._emit(eventName, path46);
+    this._closePath(path46);
   }
-  _closePath(path45) {
-    this._closeFile(path45);
-    const dir = sysPath2.dirname(path45);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path45));
+  _closePath(path46) {
+    this._closeFile(path46);
+    const dir = sysPath2.dirname(path46);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path46));
   }
-  _closeFile(path45) {
-    const closers = this._closers.get(path45);
+  _closeFile(path46) {
+    const closers = this._closers.get(path46);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path45);
+    this._closers.delete(path46);
   }
-  _addPathCloser(path45, closer) {
+  _addPathCloser(path46, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path45);
+    let list = this._closers.get(path46);
     if (!list) {
       list = [];
-      this._closers.set(path45, list);
+      this._closers.set(path46, list);
     }
     list.push(closer);
   }
@@ -84962,10 +85239,10 @@ import Debug3 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts from "typescript";
-import * as path45 from "path";
+import * as path46 from "path";
 import * as fs43 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path45.join(projectDir, "package.json");
+  const packageJsonPath = path46.join(projectDir, "package.json");
   const allPackages = new Set;
   if (!fs43.existsSync(packageJsonPath)) {
     return allPackages;
@@ -84986,7 +85263,7 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path45.resolve(filePath);
+  const absolutePath = path46.resolve(filePath);
   if (!fs43.existsSync(absolutePath)) {
     return [];
   }
@@ -85040,17 +85317,17 @@ function resolveNodeModuleImport({
 }) {
   const packageName = getPackageNameFromImport(importPath);
   const searchPaths = [
-    path45.join(projectDir, "node_modules", packageName)
+    path46.join(projectDir, "node_modules", packageName)
   ];
   if (searchFromDir) {
-    let currentDir = path45.dirname(searchFromDir);
-    const projectDirNormalized = path45.normalize(projectDir);
+    let currentDir = path46.dirname(searchFromDir);
+    const projectDirNormalized = path46.normalize(projectDir);
     while (currentDir.startsWith(projectDirNormalized)) {
-      const candidatePath = path45.join(currentDir, "node_modules", packageName);
+      const candidatePath = path46.join(currentDir, "node_modules", packageName);
       if (!searchPaths.includes(candidatePath)) {
         searchPaths.push(candidatePath);
       }
-      const parentDir = path45.dirname(currentDir);
+      const parentDir = path46.dirname(currentDir);
       if (parentDir === currentDir)
         break;
       currentDir = parentDir;
@@ -85066,22 +85343,22 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path45.join(packageDir, "package.json");
+  const packageJsonPath = path46.join(packageDir, "package.json");
   const hasPackageJson = fs43.existsSync(packageJsonPath);
   const packageJson = hasPackageJson ? JSON.parse(fs43.readFileSync(packageJsonPath, "utf-8")) : null;
   const resolvedFiles = [];
   if (importPath !== packageName) {
     const subpath = importPath.slice(packageName.length + 1);
     const possiblePaths = [
-      path45.join(packageDir, subpath),
-      path45.join(packageDir, `${subpath}.js`),
-      path45.join(packageDir, `${subpath}.mjs`),
-      path45.join(packageDir, `${subpath}.ts`),
-      path45.join(packageDir, `${subpath}.tsx`),
-      path45.join(packageDir, subpath, "index.js"),
-      path45.join(packageDir, subpath, "index.mjs"),
-      path45.join(packageDir, subpath, "index.ts"),
-      path45.join(packageDir, subpath, "index.tsx")
+      path46.join(packageDir, subpath),
+      path46.join(packageDir, `${subpath}.js`),
+      path46.join(packageDir, `${subpath}.mjs`),
+      path46.join(packageDir, `${subpath}.ts`),
+      path46.join(packageDir, `${subpath}.tsx`),
+      path46.join(packageDir, subpath, "index.js"),
+      path46.join(packageDir, subpath, "index.mjs"),
+      path46.join(packageDir, subpath, "index.ts"),
+      path46.join(packageDir, subpath, "index.tsx")
     ];
     for (const p of possiblePaths) {
       if (fs43.existsSync(p) && fs43.statSync(p).isFile()) {
@@ -85116,22 +85393,22 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path45.join(packageDir, entry);
+    const entryPath = path46.join(packageDir, entry);
     if (fs43.existsSync(entryPath) && fs43.statSync(entryPath).isFile()) {
       resolvedFiles.push(entryPath);
     }
   }
   if (resolvedFiles.length === 0) {
     const fallbackPaths = [
-      path45.join(packageDir, "index.js"),
-      path45.join(packageDir, "index.mjs"),
-      path45.join(packageDir, "index.ts"),
-      path45.join(packageDir, "index.tsx"),
-      path45.join(packageDir, "dist", "index.js"),
-      path45.join(packageDir, "dist", "index.mjs"),
-      path45.join(packageDir, "lib", "index.js"),
-      path45.join(packageDir, "src", "index.ts"),
-      path45.join(packageDir, "src", "index.tsx")
+      path46.join(packageDir, "index.js"),
+      path46.join(packageDir, "index.mjs"),
+      path46.join(packageDir, "index.ts"),
+      path46.join(packageDir, "index.tsx"),
+      path46.join(packageDir, "dist", "index.js"),
+      path46.join(packageDir, "dist", "index.mjs"),
+      path46.join(packageDir, "lib", "index.js"),
+      path46.join(packageDir, "src", "index.ts"),
+      path46.join(packageDir, "src", "index.tsx")
     ];
     for (const p of fallbackPaths) {
       if (fs43.existsSync(p) && fs43.statSync(p).isFile()) {
@@ -85172,8 +85449,8 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path45.resolve(filePath);
-    const baseDir = path45.dirname(absolutePath);
+    const absolutePath = path46.resolve(filePath);
+    const baseDir = path46.dirname(absolutePath);
     if (!fs43.existsSync(absolutePath)) {
       return [];
     }
@@ -85199,7 +85476,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path45.resolve(baseDir, importPath);
+    const resolvedPath = path46.resolve(baseDir, importPath);
     if (fs43.existsSync(resolvedPath) && fs43.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
@@ -85211,7 +85488,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
     if (fs43.existsSync(resolvedPath) && fs43.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path45.join(resolvedPath, `index${ext}`);
+        const indexPath = path46.join(resolvedPath, `index${ext}`);
         if (fs43.existsSync(indexPath)) {
           return indexPath;
         }
@@ -85237,11 +85514,11 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path45.join(packageDir, dirName);
+    const dirPath = path46.join(packageDir, dirName);
     if (fs43.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path45.join(packageDir, "package.json");
+        const packageJsonPath = path46.join(packageDir, "package.json");
         if (fs43.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
@@ -85257,7 +85534,7 @@ function walkDirectory(dir, excludedDirs) {
     return files;
   const entries = fs43.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path45.join(dir, entry.name);
+    const fullPath = path46.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirs.has(entry.name)) {
         continue;
@@ -85318,10 +85595,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
       processedPackages.add(packageName);
       if (resolvedFiles.length > 0) {
         const firstResolvedFile = resolvedFiles[0];
-        let packageDir = path45.dirname(firstResolvedFile);
+        let packageDir = path46.dirname(firstResolvedFile);
         let hasPackageJson = false;
         while (packageDir.includes("node_modules")) {
-          const packageJsonPath = path45.join(packageDir, "package.json");
+          const packageJsonPath = path46.join(packageDir, "package.json");
           if (fs43.existsSync(packageJsonPath)) {
             try {
               const pkgJson = JSON.parse(fs43.readFileSync(packageJsonPath, "utf-8"));
@@ -85332,10 +85609,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, path45.sep))) {
+          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path46.sep))) {
             break;
           }
-          const parentDir = path45.dirname(packageDir);
+          const parentDir = path46.dirname(packageDir);
           if (parentDir === packageDir)
             break;
           packageDir = parentDir;
@@ -86109,10 +86386,10 @@ var databaseSchema = z5.object({
   files: z5.array(fileSchema).default([]),
   events: z5.array(eventSchema).default([])
 });
-function normalizePath2(path46) {
-  if (!path46 || path46 === "/")
+function normalizePath2(path47) {
+  if (!path47 || path47 === "/")
     return "";
-  let normalized = path46.replace(/\\+/g, "/").replace(/\/\/+/, "/");
+  let normalized = path47.replace(/\\+/g, "/").replace(/\/\/+/, "/");
   if (normalized.startsWith("/")) {
     normalized = normalized.slice(1);
   }
@@ -86970,13 +87247,13 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 
 // lib/server/kicad-pcm-proxy.ts
 import * as fs44 from "node:fs";
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 var getSourceFilesChecksum = (projectDir) => {
   const sourceFiles = globbySync(["**/*.tsx", "**/*.ts", "**/*.json", "!node_modules/**", "!dist/**"], { cwd: projectDir });
   let checksum = "";
   for (const file of sourceFiles) {
     try {
-      const stat4 = fs44.statSync(path46.join(projectDir, file));
+      const stat4 = fs44.statSync(path47.join(projectDir, file));
       checksum += `${file}:${stat4.mtimeMs};`;
     } catch {}
   }
@@ -86996,9 +87273,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url, res) => {
     const requestedFile = url.pathname.replace(/^\/pcm\/?/, "") || "repository.json";
-    const distDir = path46.join(projectDir, "dist");
-    const pcmDir = path46.join(distDir, "pcm");
-    const filePath = path46.join(pcmDir, requestedFile);
+    const distDir = path47.join(projectDir, "dist");
+    const pcmDir = path47.join(distDir, "pcm");
+    const filePath = path47.join(pcmDir, requestedFile);
     const currentChecksum = getSourceFilesChecksum(projectDir);
     const needsRebuild = currentChecksum !== pcmState.lastFileChecksum;
     if (needsRebuild) {
@@ -87048,7 +87325,7 @@ Rebuilding KiCad PCM assets...`));
       res.end(`PCM file not found: ${requestedFile}`);
       return;
     }
-    const ext = path46.extname(filePath).toLowerCase();
+    const ext = path47.extname(filePath).toLowerCase();
     let contentType = "application/octet-stream";
     if (ext === ".json") {
       contentType = "application/json";
@@ -87180,7 +87457,7 @@ var createHttpServer = async ({
 // lib/shared/push-snippet.ts
 var import_semver3 = __toESM2(require_semver2(), 1);
 import * as fs46 from "node:fs";
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 import Debug2 from "debug";
 
 // lib/utils/validate-package-name.ts
@@ -87198,7 +87475,7 @@ var validatePackageName = (name) => {
 };
 
 // cli/dev/get-package-file-paths.ts
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 var getPackageFilePaths = (projectDir, ignored = []) => {
   const ignorePatterns = [
     ...DEFAULT_IGNORED_PATTERNS,
@@ -87209,7 +87486,7 @@ var getPackageFilePaths = (projectDir, ignored = []) => {
     ignore: ignorePatterns
   });
   fileNames.sort();
-  return fileNames.map((fileName) => path47.join(projectDir, fileName));
+  return fileNames.map((fileName) => path48.join(projectDir, fileName));
 };
 
 // lib/utils/check-org-access.ts
@@ -87225,7 +87502,7 @@ var checkOrgAccess = async (ky2, orgTscircuitHandle) => {
 };
 
 // lib/shared/is-binary-file.ts
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 var BINARY_FILE_EXTENSIONS = new Set([
   ".glb",
   ".gltf",
@@ -87241,7 +87518,7 @@ var BINARY_FILE_EXTENSIONS = new Set([
   ".tar"
 ]);
 var isBinaryFile = (filePath) => {
-  const ext = path48.extname(filePath).toLowerCase();
+  const ext = path49.extname(filePath).toLowerCase();
   return BINARY_FILE_EXTENSIONS.has(ext);
 };
 
@@ -87267,7 +87544,7 @@ var debug2 = Debug2("tsci:push-snippet");
 var getArchivePayload = async (filePaths, projectDir, packageNameWithVersion) => {
   const zip = new import_jszip3.default;
   for (const fullFilePath of filePaths) {
-    const relativeFilePath = path49.relative(projectDir, fullFilePath);
+    const relativeFilePath = path50.relative(projectDir, fullFilePath);
     zip.file(relativeFilePath, fs46.readFileSync(fullFilePath));
   }
   const archive = await zip.generateAsync({
@@ -87305,10 +87582,10 @@ var pushSnippet = async ({
     return onExit(1);
   }
   const packageJsonPath = [
-    path49.resolve(path49.join(path49.dirname(snippetFilePath), "package.json")),
-    path49.resolve(path49.join(process.cwd(), "package.json"))
-  ].find((path50) => fs46.existsSync(path50));
-  const projectDir = packageJsonPath ? path49.dirname(packageJsonPath) : path49.dirname(snippetFilePath);
+    path50.resolve(path50.join(path50.dirname(snippetFilePath), "package.json")),
+    path50.resolve(path50.join(process.cwd(), "package.json"))
+  ].find((path51) => fs46.existsSync(path51));
+  const projectDir = packageJsonPath ? path50.dirname(packageJsonPath) : path50.dirname(snippetFilePath);
   if (!packageJsonPath) {
     onError("No package.json found, try running 'tsci init' to bootstrap the project");
     return onExit(1);
@@ -87502,7 +87779,7 @@ var pushSnippet = async ({
         json: archivePayload
       });
       for (const fullFilePath of filePaths) {
-        const relativeFilePath = path49.relative(projectDir, fullFilePath);
+        const relativeFilePath = path50.relative(projectDir, fullFilePath);
         uploadResults.succeeded.push(relativeFilePath);
       }
       log(kleur_default.gray(`\uD83D\uDCE6 Uploaded archive with ${filePaths.length} files`));
@@ -87512,7 +87789,7 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path49.relative(projectDir, fullFilePath);
+      const relativeFilePath = path50.relative(projectDir, fullFilePath);
       const fileBuffer = fs46.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
@@ -87602,7 +87879,7 @@ class DevServer {
   }) {
     this.port = port;
     this.componentFilePath = componentFilePath;
-    this.projectDir = projectDir ?? path50.dirname(componentFilePath);
+    this.projectDir = projectDir ?? path51.dirname(componentFilePath);
     this.kicadPcm = kicadPcm ?? false;
     const projectConfig = loadProjectConfig(this.projectDir);
     this.ignoredFiles = projectConfig?.ignoredFiles ?? [];
@@ -87613,7 +87890,7 @@ class DevServer {
   async start() {
     const { server } = await createHttpServer({
       port: this.port,
-      defaultMainComponentPath: path50.relative(this.projectDir, this.componentFilePath),
+      defaultMainComponentPath: path51.relative(this.projectDir, this.componentFilePath),
       kicadPcm: this.kicadPcm,
       projectDir: this.projectDir,
       entryFile: this.componentFilePath
@@ -87629,7 +87906,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p) => shouldIgnorePath(path50.relative(this.projectDir, p), this.ignoredFiles)
+      ignored: (p) => shouldIgnorePath(path51.relative(this.projectDir, p), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -87644,8 +87921,8 @@ class DevServer {
     const { file } = await this.fsKy.get("api/files/get", {
       searchParams: { file_path: ev.file_path }
     }).json();
-    const fullPath = path50.join(this.projectDir, ev.file_path);
-    const dirPath = path50.dirname(fullPath);
+    const fullPath = path51.join(this.projectDir, ev.file_path);
+    const dirPath = path51.dirname(fullPath);
     if (!fs47.existsSync(dirPath)) {
       fs47.mkdirSync(dirPath, { recursive: true });
     }
@@ -87657,14 +87934,14 @@ class DevServer {
     }
   }
   async handleFileDeletedEventFromServer(ev) {
-    const fullPath = path50.join(this.projectDir, ev.file_path);
+    const fullPath = path51.join(this.projectDir, ev.file_path);
     if (fs47.existsSync(fullPath)) {
       debug3(`Deleting file ${ev.file_path} from filesystem`);
       fs47.unlinkSync(fullPath);
     }
   }
   async handleFileChangedOnFilesystem(absoluteFilePath) {
-    const relativeFilePath = path50.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path51.relative(this.projectDir, absoluteFilePath);
     if (relativeFilePath.includes("manual-edits.json"))
       return;
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
@@ -87679,14 +87956,14 @@ class DevServer {
     await this.checkAndUploadNewNodeModules(absoluteFilePath);
   }
   async checkAndUploadNewNodeModules(filePath) {
-    const ext = path50.extname(filePath).toLowerCase();
+    const ext = path51.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 = path50.relative(this.projectDir, file);
+        const relativePath = path51.relative(this.projectDir, file);
         return !this.uploadedNodeModules.has(relativePath);
       });
       if (newFiles.length === 0)
@@ -87699,7 +87976,7 @@ class DevServer {
     }
   }
   async handleFileRemovedFromFilesystem(absoluteFilePath) {
-    const relativeFilePath = path50.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path51.relative(this.projectDir, absoluteFilePath);
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
       return;
     if (!relativeFilePath || relativeFilePath.trim() === "") {
@@ -87737,8 +88014,8 @@ class DevServer {
     debug3(`Successfully deleted file ${relativeFilePath} from server`);
   }
   async handleFileRename(oldPath, newPath) {
-    const oldRelativePath = path50.relative(this.projectDir, oldPath);
-    const newRelativePath = path50.relative(this.projectDir, newPath);
+    const oldRelativePath = path51.relative(this.projectDir, oldPath);
+    const newRelativePath = path51.relative(this.projectDir, newPath);
     if (shouldIgnorePath(oldRelativePath, this.ignoredFiles) || shouldIgnorePath(newRelativePath, this.ignoredFiles))
       return;
     await this.handleFileRemovedFromFilesystem(oldPath);
@@ -87756,7 +88033,7 @@ class DevServer {
     });
     const filePaths = getPackageFilePaths(this.projectDir, this.ignoredFiles);
     for (const filePath of filePaths) {
-      const relativeFilePath = path50.relative(this.projectDir, filePath);
+      const relativeFilePath = path51.relative(this.projectDir, filePath);
       const filePayload = this.createFileUploadPayload(filePath, relativeFilePath);
       await this.postFileUpsert({
         filePath: relativeFilePath,
@@ -87788,7 +88065,7 @@ class DevServer {
   }
   async uploadNodeModuleFiles(files) {
     for (const nodeModuleFile of files) {
-      const relativeFilePath = path50.relative(this.projectDir, nodeModuleFile);
+      const relativeFilePath = path51.relative(this.projectDir, nodeModuleFile);
       this.uploadedNodeModules.add(relativeFilePath);
       const filePayload = this.createFileUploadPayload(nodeModuleFile, relativeFilePath);
       await this.postFileUpsert({
@@ -87833,7 +88110,7 @@ class DevServer {
     formData.set("file_path", filePath);
     formData.set("initiator", initiator);
     const binaryBytes = Uint8Array.from(binaryContent);
-    formData.set("binary_file", new Blob([binaryBytes]), path50.basename(filePath));
+    formData.set("binary_file", new Blob([binaryBytes]), path51.basename(filePath));
     const response = await fetch(`http://localhost:${this.port}/api/files/upsert-multipart`, {
       method: "POST",
       body: formData
@@ -87873,7 +88150,7 @@ class DevServer {
     await this.filesystemWatcher?.close();
   }
   createFileUploadPayload(absoluteFilePath, relativeFilePath) {
-    const ext = path50.extname(relativeFilePath).toLowerCase();
+    const ext = path51.extname(relativeFilePath).toLowerCase();
     if (BINARY_FILE_EXTENSIONS2.has(ext)) {
       const fileBuffer = fs47.readFileSync(absoluteFilePath);
       return { binary_content: fileBuffer };
@@ -87909,7 +88186,7 @@ class DevServer {
 
 // cli/dev/resolve-dev-target.ts
 import * as fs48 from "node:fs";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 var findSelectableFiles = (projectDir) => {
   const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs48.existsSync(file)).sort();
   if (boardFiles.length > 0) {
@@ -87919,7 +88196,7 @@ var findSelectableFiles = (projectDir) => {
     cwd: projectDir,
     ignore: DEFAULT_IGNORED_PATTERNS
   });
-  return files.map((file) => path51.resolve(projectDir, file)).filter((file) => fs48.existsSync(file)).sort();
+  return files.map((file) => path52.resolve(projectDir, file)).filter((file) => fs48.existsSync(file)).sort();
 };
 var isValidDevFile = (filePath) => {
   return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
@@ -87927,7 +88204,7 @@ var isValidDevFile = (filePath) => {
 var resolveDevTarget = async (file) => {
   let projectDir = process.cwd();
   if (file) {
-    const resolvedPath = path51.resolve(file);
+    const resolvedPath = path52.resolve(file);
     if (fs48.existsSync(resolvedPath) && fs48.statSync(resolvedPath).isDirectory()) {
       projectDir = resolvedPath;
       const availableFiles2 = findSelectableFiles(projectDir);
@@ -87935,7 +88212,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:", path51.relative(projectDir, availableFiles2[0]));
+      console.log("Selected file:", path52.relative(projectDir, availableFiles2[0]));
       return { absolutePath: availableFiles2[0], projectDir };
     }
     if (!fs48.existsSync(resolvedPath)) {
@@ -87958,7 +88235,7 @@ var resolveDevTarget = async (file) => {
     console.log("No .tsx, .ts, or .circuit.json files found in the project. Run 'tsci init' to bootstrap a basic project.");
     return null;
   }
-  console.log("Selected file:", path51.relative(projectDir, availableFiles[0]));
+  console.log("Selected file:", path52.relative(projectDir, availableFiles[0]));
   return { absolutePath: availableFiles[0], projectDir };
 };
 
@@ -87974,7 +88251,7 @@ var isPortAvailable = (port) => {
   });
 };
 var warnIfTsconfigMissingTscircuitType = (projectDir) => {
-  const tsconfigPath = path52.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path53.join(projectDir, "tsconfig.json");
   if (!fs49.existsSync(tsconfigPath)) {
     return;
   }
@@ -88011,7 +88288,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(path52.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(path53.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
 
 `);
     console.log(kleur_default.gray(`Watching ${kleur_default.underline(server.projectDir.split("/").slice(-2).join("/"))} for changes...`));
@@ -88041,13 +88318,13 @@ var checkLoggedIn = () => {
 import { spawnSync } from "node:child_process";
 import fs50 from "node:fs";
 import os5 from "node:os";
-import path53 from "node:path";
+import path54 from "node:path";
 var hasBunInstalled = () => {
   const result = spawnSync("bun", ["--version"], { stdio: "ignore" });
   return result.status === 0;
 };
 var createTempProject = (tempDir) => {
-  const packageJsonPath = path53.join(tempDir, "package.json");
+  const packageJsonPath = path54.join(tempDir, "package.json");
   const packageJson = {
     name: "tsci-doctor-check",
     version: "0.0.0",
@@ -88067,7 +88344,7 @@ var checkGlobalNpmrcRegistry = async () => {
       details: "Bun is required to verify registry settings. Install Bun and rerun `tsci doctor`."
     };
   }
-  const tempDir = fs50.mkdtempSync(path53.join(os5.tmpdir(), "tsci-doctor-"));
+  const tempDir = fs50.mkdtempSync(path54.join(os5.tmpdir(), "tsci-doctor-"));
   try {
     createTempProject(tempDir);
     const result = spawnSync("bun", ["install"], {
@@ -88139,243 +88416,9 @@ var registerDoctor = (program2) => {
 
 // lib/shared/export-snippet.ts
 import fs51 from "node:fs";
-import path54 from "node:path";
+import path55 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf4 } from "circuit-json-to-gltf";
-
-// node_modules/circuit-json-to-readable-netlist/dist/index.js
-import { su as su3 } from "@tscircuit/circuit-json-util";
-import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
-import { su as su2 } from "@tscircuit/circuit-json-util";
-import { su as su4 } from "@tscircuit/circuit-json-util";
-var wordQualityScore = {
-  MISO: 1.2,
-  MOSI: 1.2,
-  SCLK: 1.2,
-  SDA: 1.2,
-  SCL: 1.2,
-  RX: 1.15,
-  TX: 1.15,
-  GPIO: 1.1,
-  cathode: 0.5,
-  anode: 0.5,
-  GND: 1.1,
-  VDD: 1.1,
-  AGND: 1.1,
-  V5: 1.1,
-  V3: 1.1,
-  V1: 1.1,
-  neg: 0.9,
-  pos: 0.9,
-  pin: 0.5,
-  left: 0.3,
-  right: 0.3
-};
-var wordQualityScoreEntries = Object.entries(wordQualityScore).sort((a, b) => b[1] - a[1]);
-var scorePhrase = (phrase) => {
-  if (phrase.match(/\d+/)) {
-    return 0.5;
-  }
-  for (const [word, score] of wordQualityScoreEntries) {
-    if (phrase.includes(word)) {
-      return score;
-    }
-  }
-  return 1;
-};
-var getReadableNameForPin = ({
-  circuitJson,
-  source_port_id
-}) => {
-  const source_ports = su4(circuitJson).source_port.list();
-  const source_components = su4(circuitJson).source_component.list();
-  const port = source_ports.find((p) => p.source_port_id === source_port_id);
-  if (!port)
-    return "";
-  const component = source_components.find((c) => c.source_component_id === port.source_component_id);
-  if (!component)
-    return "";
-  const isPositive = port.port_hints?.some((hint) => ["anode", "pos", "positive"].includes(hint.toLowerCase()));
-  const isNegative = port.port_hints?.some((hint) => ["cathode", "neg", "negative"].includes(hint.toLowerCase()));
-  const mainPinName = port.name ? port.name : `Pin${port.pin_number}`;
-  const additionalPinLabels = [];
-  if (isPositive && component.ftype !== "simple_resistor") {
-    additionalPinLabels.push("+");
-  } else if (isNegative && component.ftype !== "simple_resistor") {
-    additionalPinLabels.push("-");
-  }
-  for (const port_hint of port.port_hints ?? []) {
-    if (port_hint === mainPinName)
-      continue;
-    const score = scorePhrase(port_hint);
-    if (score > 1) {
-      additionalPinLabels.push(port_hint);
-    }
-  }
-  const displayValue = component.display_value ? ` (${component.display_value})` : "";
-  return `${component.name} ${mainPinName}${additionalPinLabels.length > 0 ? ` (${additionalPinLabels.join(",")})` : ""}${displayValue}`;
-};
-var scoreComponentOrder = (component) => {
-  if (!("ftype" in component))
-    return 0;
-  if (component.ftype === "simple_resistor")
-    return 0;
-  if (component.ftype === "simple_capacitor")
-    return 1;
-  return 2;
-};
-var generateNetName = ({
-  circuitJson,
-  connectedIds
-}) => {
-  const all_source_components = su2(circuitJson).source_component.list();
-  const sourceComponentIdToScore = /* @__PURE__ */ new Map;
-  for (const component of all_source_components) {
-    sourceComponentIdToScore.set(component.source_component_id, scoreComponentOrder(component));
-  }
-  all_source_components.sort((a, b) => sourceComponentIdToScore.get(b.source_component_id) - sourceComponentIdToScore.get(a.source_component_id));
-  const all_source_ports = su2(circuitJson).source_port.list().sort((a, b) => sourceComponentIdToScore.get(b.source_component_id) - sourceComponentIdToScore.get(a.source_component_id));
-  const all_source_nets = su2(circuitJson).source_net.list();
-  const all_source_traces = su2(circuitJson).source_trace.list();
-  const ports = all_source_ports.filter((p) => connectedIds.includes(p.source_port_id));
-  const nets = all_source_nets.filter((n) => connectedIds.includes(n.source_net_id));
-  const traces = all_source_traces.filter((t) => connectedIds.includes(t.source_trace_id));
-  const possibleNames = ports.flatMap((p) => Array.from(/* @__PURE__ */ new Set([...p.name ? [p.name] : [], ...p.port_hints ?? []]))).concat(nets.map((n) => n.name));
-  const phrases = possibleNames.map((name) => ({
-    name,
-    score: scorePhrase(name)
-  }));
-  const bestPortName = phrases.sort((a, b) => b.score - a.score)[0].name;
-  const bestPort = ports.find((p) => p.name === bestPortName || p.port_hints?.includes(bestPortName));
-  const componentWithBestPort = all_source_components.find((c) => c.source_component_id === bestPort?.source_component_id);
-  return [componentWithBestPort?.name, bestPortName].filter(Boolean).join("_");
-};
-var convertCircuitJsonToReadableNetlist = (circuitJson) => {
-  const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson.filter((e) => e.type.startsWith("source_")));
-  const netMap = connectivityMap.netMap;
-  const source_ports = su3(circuitJson).source_port.list();
-  const source_components = su3(circuitJson).source_component.list();
-  const source_nets = su3(circuitJson).source_net.list();
-  const source_traces = su3(circuitJson).source_trace.list();
-  const netlist = [];
-  netlist.push("COMPONENTS:");
-  for (const component of source_components) {
-    let componentDescription = "";
-    const cadComponent = su3(circuitJson).cad_component.getWhere({
-      source_component_id: component.source_component_id
-    });
-    const footprint = cadComponent?.footprinter_string;
-    if (component.ftype === "simple_resistor") {
-      componentDescription = `${component.display_resistance}${footprint ? ` ${footprint}` : ""} resistor`;
-    } else if (component.ftype === "simple_capacitor") {
-      componentDescription = `${component.display_capacitance}${footprint ? ` ${footprint}` : ""} capacitor`;
-    } else if (component.ftype === "simple_chip") {
-      const manufacturerPartNumber = component.manufacturer_part_number;
-      componentDescription = [manufacturerPartNumber, footprint].filter(Boolean).join(", ");
-    } else {
-      componentDescription = [component.name, component.type].filter(Boolean).join(", ");
-    }
-    netlist.push(` - ${component.name}: ${componentDescription}`);
-  }
-  netlist.push("");
-  for (const [netId, connectedIds] of Object.entries(netMap)) {
-    const net2 = source_nets.find((n) => connectedIds.includes(n.source_net_id));
-    let netName = net2?.name;
-    if (!netName) {
-      netName = generateNetName({ circuitJson, connectedIds });
-    }
-    const connectedPortCount = connectedIds.filter((id) => id.startsWith("source_port")).length;
-    if (connectedPortCount <= 1)
-      continue;
-    netlist.push(`NET: ${netName}`);
-    for (const id of connectedIds) {
-      const pinName = getReadableNameForPin({
-        circuitJson,
-        source_port_id: id
-      });
-      if (pinName) {
-        netlist.push(`  - ${pinName}`);
-      }
-    }
-    netlist.push("");
-  }
-  let hasEmptyNets = false;
-  for (const [netId, connectedIds] of Object.entries(netMap)) {
-    const connectedPortCount = connectedIds.filter((id) => id.startsWith("source_port")).length;
-    if (connectedPortCount === 1) {
-      if (!hasEmptyNets) {
-        netlist.push("");
-        netlist.push("EMPTY NET PINS:");
-        hasEmptyNets = true;
-      }
-      const source_port_id = netMap[netId].find((id) => id.startsWith("source_port"));
-      const pinName = getReadableNameForPin({
-        circuitJson,
-        source_port_id
-      });
-      if (pinName) {
-        netlist.push(`  - ${pinName}`);
-      }
-    }
-  }
-  const portIdToNetNames = {};
-  for (const [netId, connectedIds] of Object.entries(netMap)) {
-    const portIds = connectedIds.filter((id) => id.startsWith("source_port"));
-    if (portIds.length === 0)
-      continue;
-    const net2 = source_nets.find((n) => connectedIds.includes(n.source_net_id));
-    let netName = net2?.name;
-    if (!netName) {
-      netName = generateNetName({ circuitJson, connectedIds });
-    }
-    for (const portId of portIds) {
-      if (!portIdToNetNames[portId])
-        portIdToNetNames[portId] = [];
-      portIdToNetNames[portId].push(netName);
-    }
-  }
-  if (source_components.length > 0) {
-    netlist.push("");
-    netlist.push("COMPONENT_PINS:");
-    for (const component of source_components) {
-      const cadComponent = su3(circuitJson).cad_component.getWhere({
-        source_component_id: component.source_component_id
-      });
-      const footprint = cadComponent?.footprinter_string;
-      let header = component.name;
-      if (component.ftype === "simple_resistor") {
-        header = `${component.name} (${component.display_resistance} ${footprint})`;
-      } else if (component.ftype === "simple_capacitor") {
-        header = `${component.name} (${component.display_capacitance} ${footprint})`;
-      } else if (component.manufacturer_part_number) {
-        header = `${component.name} (${component.manufacturer_part_number})`;
-      }
-      netlist.push(header);
-      const ports = source_ports.filter((p) => p.source_component_id === component.source_component_id).sort((a, b) => (a.pin_number ?? 0) - (b.pin_number ?? 0));
-      for (const port of ports) {
-        const mainPin = port.pin_number !== undefined ? `pin${port.pin_number}` : port.name;
-        const aliases = [];
-        if (port.name && port.name !== mainPin)
-          aliases.push(port.name);
-        for (const hint of port.port_hints ?? []) {
-          if (hint === String(port.pin_number))
-            continue;
-          if (hint !== mainPin && hint !== port.name)
-            aliases.push(hint);
-        }
-        const aliasPart = aliases.length > 0 ? `(${Array.from(new Set(aliases)).join(", ")})` : "";
-        const nets = portIdToNetNames[port.source_port_id] ?? [];
-        const netsPart = nets.length > 0 ? `NETS(${nets.join(", ")})` : "NOT_CONNECTED";
-        netlist.push(`- ${mainPin}${aliasPart}: ${netsPart}`);
-      }
-      netlist.push("");
-    }
-  }
-  return netlist.join(`
-`);
-};
-
-// lib/shared/export-snippet.ts
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg2,
   convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg2
@@ -89212,9 +89255,9 @@ var stringifyDsnJson = (dsnJson) => {
   const stringifyCoordinates = (coordinates) => {
     return coordinates.join(" ");
   };
-  const stringifyPath = (path54, level) => {
+  const stringifyPath = (path55, level) => {
     const padding = indent.repeat(level);
-    return `${padding}(path ${path54.layer} ${path54.width}  ${stringifyCoordinates(path54.coordinates)})`;
+    return `${padding}(path ${path55.layer} ${path55.width}  ${stringifyCoordinates(path55.coordinates)})`;
   };
   result += `(pcb ${dsnJson.filename ? dsnJson.filename : "./converted_dsn.dsn"}
 `;
@@ -89441,10 +89484,10 @@ var exportSnippet = async ({
     onError(`Invalid format: ${format}`);
     return onExit(1);
   }
-  const projectDir = path54.dirname(filePath);
-  const outputBaseName = path54.basename(filePath).replace(/\.[^.]+$/, "");
+  const projectDir = path55.dirname(filePath);
+  const outputBaseName = path55.basename(filePath).replace(/\.[^.]+$/, "");
   const outputFileName = `${outputBaseName}${OUTPUT_EXTENSIONS[format]}`;
-  const outputDestination = path54.join(projectDir, outputPath ?? outputFileName);
+  const outputDestination = path55.join(projectDir, outputPath ?? outputFileName);
   if (format === "kicad-library") {
     try {
       const result = await convertToKicadLibrary({
@@ -89642,11 +89685,11 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 
 // lib/eecircuit-engine/run-simulation.ts
 import { promises as fs52, existsSync as existsSync13 } from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 import os6 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path55.join(os6.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  const tempFilePath = path56.join(os6.tmpdir(), "eecircuit-engine-1.5.2.mjs");
   if (!existsSync13(tempFilePath)) {
     const url = "https://cdn.jsdelivr.net/npm/eecircuit-engine@1.5.2/+esm";
     const response = await fetch(url);
@@ -89743,7 +89786,7 @@ var resultToCsv = (result) => {
 };
 
 // cli/export/register.ts
-import path56 from "node:path";
+import path57 from "node:path";
 import { promises as fs53 } from "node:fs";
 var registerExport = (program2) => {
   program2.command("export").description("Export tscircuit code to various formats").argument("<file>", "Path to the package file").option("-f, --format <format>", `Output format (${ALLOWED_EXPORT_FORMATS.join(", ")})`).option("-o, --output <path>", "Output file path").option("--disable-parts-engine", "Disable the parts engine").action(async (file, options) => {
@@ -89756,7 +89799,7 @@ var registerExport = (program2) => {
       });
       if (circuitJson) {
         const spiceString = getSpiceWithPaddedSim(circuitJson);
-        const outputSpicePath = options.output ?? path56.join(path56.dirname(file), `${path56.basename(file, path56.extname(file))}.spice.cir`);
+        const outputSpicePath = options.output ?? path57.join(path57.dirname(file), `${path57.basename(file, path57.extname(file))}.spice.cir`);
         await fs53.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
@@ -91229,8 +91272,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params2) => {
-  const { data, path: path57, errorMaps, issueData } = params2;
-  const fullPath = [...path57, ...issueData.path || []];
+  const { data, path: path58, errorMaps, issueData } = params2;
+  const fullPath = [...path58, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -91338,11 +91381,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path57, key) {
+  constructor(parent, value, path58, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path57;
+    this._path = path58;
     this._key = key;
   }
   get path() {
@@ -102440,11 +102483,11 @@ var require_react_reconciler_development = __commonJS2({
           fiber = fiber.next, id--;
         return fiber;
       }
-      function copyWithSetImpl(obj, path57, index, value) {
-        if (index >= path57.length)
+      function copyWithSetImpl(obj, path58, index, value) {
+        if (index >= path58.length)
           return value;
-        var key = path57[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        updated[key] = copyWithSetImpl(obj[key], path57, index + 1, value);
+        var key = path58[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        updated[key] = copyWithSetImpl(obj[key], path58, index + 1, value);
         return updated;
       }
       function copyWithRename(obj, oldPath, newPath) {
@@ -102464,11 +102507,11 @@ var require_react_reconciler_development = __commonJS2({
         index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
         return updated;
       }
-      function copyWithDeleteImpl(obj, path57, index) {
-        var key = path57[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        if (index + 1 === path57.length)
+      function copyWithDeleteImpl(obj, path58, index) {
+        var key = path58[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        if (index + 1 === path58.length)
           return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-        updated[key] = copyWithDeleteImpl(obj[key], path57, index + 1);
+        updated[key] = copyWithDeleteImpl(obj[key], path58, index + 1);
         return updated;
       }
       function shouldSuspendImpl() {
@@ -111494,29 +111537,29 @@ Check the top-level render call using <` + componentName2 + ">.");
       var didWarnAboutNestedUpdates = false;
       var didWarnAboutFindNodeInStrictMode = {};
       var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, setErrorHandler = null, setSuspenseHandler = null;
-      overrideHookState = function(fiber, id, path57, value) {
+      overrideHookState = function(fiber, id, path58, value) {
         id = findHook(fiber, id);
-        id !== null && (path57 = copyWithSetImpl(id.memoizedState, path57, 0, value), id.memoizedState = path57, id.baseState = path57, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path57 = enqueueConcurrentRenderForLane(fiber, 2), path57 !== null && scheduleUpdateOnFiber(path57, fiber, 2));
+        id !== null && (path58 = copyWithSetImpl(id.memoizedState, path58, 0, value), id.memoizedState = path58, id.baseState = path58, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path58 = enqueueConcurrentRenderForLane(fiber, 2), path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2));
       };
-      overrideHookStateDeletePath = function(fiber, id, path57) {
+      overrideHookStateDeletePath = function(fiber, id, path58) {
         id = findHook(fiber, id);
-        id !== null && (path57 = copyWithDeleteImpl(id.memoizedState, path57, 0), id.memoizedState = path57, id.baseState = path57, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path57 = enqueueConcurrentRenderForLane(fiber, 2), path57 !== null && scheduleUpdateOnFiber(path57, fiber, 2));
+        id !== null && (path58 = copyWithDeleteImpl(id.memoizedState, path58, 0), id.memoizedState = path58, id.baseState = path58, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path58 = enqueueConcurrentRenderForLane(fiber, 2), path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2));
       };
       overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
         id = findHook(fiber, id);
         id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
       };
-      overrideProps = function(fiber, path57, value) {
-        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path57, 0, value);
+      overrideProps = function(fiber, path58, value) {
+        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path58, 0, value);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path57 = enqueueConcurrentRenderForLane(fiber, 2);
-        path57 !== null && scheduleUpdateOnFiber(path57, fiber, 2);
+        path58 = enqueueConcurrentRenderForLane(fiber, 2);
+        path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2);
       };
-      overridePropsDeletePath = function(fiber, path57) {
-        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path57, 0);
+      overridePropsDeletePath = function(fiber, path58) {
+        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path58, 0);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path57 = enqueueConcurrentRenderForLane(fiber, 2);
-        path57 !== null && scheduleUpdateOnFiber(path57, fiber, 2);
+        path58 = enqueueConcurrentRenderForLane(fiber, 2);
+        path58 !== null && scheduleUpdateOnFiber(path58, fiber, 2);
       };
       overridePropsRenamePath = function(fiber, oldPath, newPath) {
         fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -117819,7 +117862,7 @@ var parsePin = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path57 = pathMatch ? pathMatch[1] : "";
+  const path58 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r2 = Number.parseFloat(rotation4);
@@ -117833,7 +117876,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r2) ? 0 : r2,
     label,
     labelColor,
-    path: path57,
+    path: path58,
     arrow
   };
 };
@@ -118273,15 +118316,15 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path57 = [];
+  const path58 = [];
   for (let i22 = 0;i22 <= numPoints; i22++) {
     const t3 = i22 / numPoints;
     const angle2 = startAngle + t3 * (endAngle - startAngle);
     const x22 = centerX + radius * Math.cos(angle2);
     const y22 = centerY + radius * Math.sin(angle2);
-    path57.push({ x: x22, y: y22 });
+    path58.push({ x: x22, y: y22 });
   }
-  return path57;
+  return path58;
 }
 var __defProp4 = Object.defineProperty;
 var __export22 = (target, all) => {
@@ -127360,17 +127403,17 @@ var ObstacleList = class {
     return obstacles;
   }
 };
-function removePathLoops(path57) {
-  if (path57.length < 4)
-    return path57;
-  const result = [{ ...path57[0] }];
-  let currentLayer = path57[0].layer;
-  for (let i22 = 1;i22 < path57.length; i22++) {
-    const currentSegment = { start: path57[i22 - 1], end: path57[i22] };
-    const isVia = path57[i22].route_type === "via" || path57[i22 - 1].route_type === "via";
-    if (path57[i22].layer !== currentLayer || isVia) {
-      result.push({ ...path57[i22] });
-      currentLayer = path57[i22].layer;
+function removePathLoops(path58) {
+  if (path58.length < 4)
+    return path58;
+  const result = [{ ...path58[0] }];
+  let currentLayer = path58[0].layer;
+  for (let i22 = 1;i22 < path58.length; i22++) {
+    const currentSegment = { start: path58[i22 - 1], end: path58[i22] };
+    const isVia = path58[i22].route_type === "via" || path58[i22 - 1].route_type === "via";
+    if (path58[i22].layer !== currentLayer || isVia) {
+      result.push({ ...path58[i22] });
+      currentLayer = path58[i22].layer;
       continue;
     }
     let intersectionFound = false;
@@ -127399,8 +127442,8 @@ function removePathLoops(path57) {
       result.push(intersectionPoint);
     }
     const lastPoint = result[result.length - 1];
-    if (lastPoint.x !== path57[i22].x || lastPoint.y !== path57[i22].y) {
-      result.push(path57[i22]);
+    if (lastPoint.x !== path58[i22].x || lastPoint.y !== path58[i22].y) {
+      result.push(path58[i22]);
     }
   }
   return result;
@@ -127889,10 +127932,10 @@ var GeneralizedAstarAutorouter = class {
       });
     }
     if (current2.parent) {
-      const path57 = [];
+      const path58 = [];
       let p22 = current2;
       while (p22) {
-        path57.unshift(p22);
+        path58.unshift(p22);
         p22 = p22.parent;
       }
       debugSolution.push({
@@ -127900,7 +127943,7 @@ var GeneralizedAstarAutorouter = class {
         pcb_component_id: "",
         pcb_fabrication_note_path_id: `note_path_${current2.x}_${current2.y}`,
         layer: "top",
-        route: path57,
+        route: path58,
         stroke_width: 0.01
       });
     }
@@ -152345,10 +152388,10 @@ var findFirstCollision = (pts, rects, opts = {}) => {
   }
   return null;
 };
-var isPathCollidingWithObstacles = (path57, obstacles) => {
-  for (let i22 = 0;i22 < path57.length - 1; i22++) {
+var isPathCollidingWithObstacles = (path58, obstacles) => {
+  for (let i22 = 0;i22 < path58.length - 1; i22++) {
     for (const obstacle of obstacles) {
-      if (segmentIntersectsRect(path57[i22], path57[i22 + 1], obstacle)) {
+      if (segmentIntersectsRect(path58[i22], path58[i22 + 1], obstacle)) {
         return true;
       }
     }
@@ -152542,36 +152585,36 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
       this.error = "No collision-free path found";
       return;
     }
-    const { path: path57, collisionChipIds } = state;
+    const { path: path58, collisionChipIds } = state;
     const [PA, PB] = this.pins;
-    const collision = findFirstCollision(path57, this.obstacles);
+    const collision = findFirstCollision(path58, this.obstacles);
     if (!collision) {
-      const first = path57[0];
-      const last = path57[path57.length - 1];
+      const first = path58[0];
+      const last = path58[path58.length - 1];
       const EPS42 = 0.000000001;
       const samePoint = (p22, q22) => Math.abs(p22.x - q22.x) < EPS42 && Math.abs(p22.y - q22.y) < EPS42;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
-        this.solvedTracePath = path57;
+        this.solvedTracePath = path58;
         this.solved = true;
       }
       return;
     }
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
-    const isLastSegment = segIndex === path57.length - 2;
+    const isLastSegment = segIndex === path58.length - 2;
     if (isFirstSegment) {
-      if (path57.length < 3) {
+      if (path58.length < 3) {
         return;
       }
       segIndex = 1;
     } else if (isLastSegment) {
-      if (path57.length < 3) {
+      if (path58.length < 3) {
         return;
       }
-      segIndex = path57.length - 3;
+      segIndex = path58.length - 3;
     }
-    const a22 = path57[segIndex];
-    const b22 = path57[segIndex + 1];
+    const a22 = path58[segIndex];
+    const b22 = path58[segIndex + 1];
     const axis = this.axisOfSegment(a22, b22);
     if (!axis) {
       return;
@@ -152589,7 +152632,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
     }
     const newStates = [];
     for (const coord of candidates) {
-      const newPath = shiftSegmentOrth(path57, segIndex, axis, coord);
+      const newPath = shiftSegmentOrth(path58, segIndex, axis, coord);
       if (!newPath)
         continue;
       const key = pathKey(newPath);
@@ -152625,8 +152668,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
       strokeColor: "blue",
       strokeDash: "5 5"
     });
-    for (const { path: path57, collisionChipIds: collisionRectIds } of this.queue) {
-      g22.lines.push({ points: path57, strokeColor: "teal", strokeDash: "2 2" });
+    for (const { path: path58, collisionChipIds: collisionRectIds } of this.queue) {
+      g22.lines.push({ points: path58, strokeColor: "teal", strokeDash: "2 2" });
     }
     if (this.solvedTracePath) {
       g22.lines.push({ points: this.solvedTracePath, strokeColor: "green" });
@@ -152863,9 +152906,9 @@ var TraceOverlapIssueSolver = class extends BaseSolver3 {
         solvedTracePathIndex,
         traceSegmentIndex
       } of group.pathsWithOverlap) {
-        const path57 = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
-        const segStart = path57.tracePath[traceSegmentIndex];
-        const segEnd = path57.tracePath[traceSegmentIndex + 1];
+        const path58 = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+        const segStart = path58.tracePath[traceSegmentIndex];
+        const segEnd = path58.tracePath[traceSegmentIndex + 1];
         graphics.lines.push({
           points: [segStart, segEnd],
           strokeColor: "red"
@@ -152909,11 +152952,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver3 {
   computeTraceNetIslands() {
     const islands = {};
     for (const original of this.inputTracePaths) {
-      const path57 = this.correctedTraceMap[original.mspPairId] ?? original;
-      const key = path57.globalConnNetId;
+      const path58 = this.correctedTraceMap[original.mspPairId] ?? original;
+      const key = path58.globalConnNetId;
       if (!islands[key])
         islands[key] = [];
-      islands[key].push(path57);
+      islands[key].push(path58);
     }
     return islands;
   }
@@ -153161,9 +153204,9 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
   }
   return { hasIntersection: false };
 }
-function lengthOfTrace(path57) {
+function lengthOfTrace(path58) {
   let sum = 0;
-  const pts = path57.tracePath;
+  const pts = path58.tracePath;
   for (let i22 = 0;i22 < pts.length - 1; i22++) {
     sum += Math.abs(pts[i22 + 1].x - pts[i22].x) + Math.abs(pts[i22 + 1].y - pts[i22].y);
   }
@@ -153692,9 +153735,9 @@ var NetLabelPlacementSolver = class extends BaseSolver3 {
         }
         const compTraces = (byGlobal[globalConnNetId] ?? []).filter((t3) => component.has(t3.pins[0].pinId) && component.has(t3.pins[1].pinId));
         if (compTraces.length > 0) {
-          const lengthOf = (path57) => {
+          const lengthOf = (path58) => {
             let sum = 0;
-            const pts = path57.tracePath;
+            const pts = path58.tracePath;
             for (let i22 = 0;i22 < pts.length - 1; i22++) {
               sum += Math.abs(pts[i22 + 1].x - pts[i22].x) + Math.abs(pts[i22 + 1].y - pts[i22].y);
             }
@@ -153839,12 +153882,12 @@ var detectTraceLabelOverlap = (traces, netLabels) => {
   }
   return overlaps;
 };
-var findTraceViolationZone = (path57, labelBounds) => {
+var findTraceViolationZone = (path58, labelBounds) => {
   const isPointInside = (p22) => p22.x > labelBounds.minX && p22.x < labelBounds.maxX && p22.y > labelBounds.minY && p22.y < labelBounds.maxY;
   let firstInsideIndex = -1;
   let lastInsideIndex = -1;
-  for (let i22 = 0;i22 < path57.length; i22++) {
-    if (isPointInside(path57[i22])) {
+  for (let i22 = 0;i22 < path58.length; i22++) {
+    if (isPointInside(path58[i22])) {
       if (firstInsideIndex === -1) {
         firstInsideIndex = i22;
       }
@@ -153853,20 +153896,20 @@ var findTraceViolationZone = (path57, labelBounds) => {
   }
   return { firstInsideIndex, lastInsideIndex };
 };
-var simplifyPath = (path57) => {
-  if (path57.length < 3)
-    return path57;
-  const newPath = [path57[0]];
-  for (let i22 = 1;i22 < path57.length - 1; i22++) {
+var simplifyPath = (path58) => {
+  if (path58.length < 3)
+    return path58;
+  const newPath = [path58[0]];
+  for (let i22 = 1;i22 < path58.length - 1; i22++) {
     const p12 = newPath[newPath.length - 1];
-    const p22 = path57[i22];
-    const p32 = path57[i22 + 1];
+    const p22 = path58[i22];
+    const p32 = path58[i22 + 1];
     if (isVertical(p12, p22) && isVertical(p22, p32) || isHorizontal(p12, p22) && isHorizontal(p22, p32)) {
       continue;
     }
     newPath.push(p22);
   }
-  newPath.push(path57[path57.length - 1]);
+  newPath.push(path58[path58.length - 1]);
   if (newPath.length < 3)
     return newPath;
   const finalPath = [newPath[0]];
@@ -154126,12 +154169,12 @@ var hasCollisionsWithLabels = (pathSegments, labels) => {
   return false;
 };
 var minimizeTurns = ({
-  path: path57,
+  path: path58,
   obstacles,
   labelBounds
 }) => {
-  if (path57.length <= 2) {
-    return path57;
+  if (path58.length <= 2) {
+    return path58;
   }
   const recognizeStairStepPattern = (pathToCheck, startIdx) => {
     if (startIdx >= pathToCheck.length - 3)
@@ -154163,7 +154206,7 @@ var minimizeTurns = ({
     }
     return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
   };
-  let optimizedPath = [...path57];
+  let optimizedPath = [...path58];
   let currentTurns = countTurns(optimizedPath);
   let improved = true;
   while (improved) {
@@ -161768,9 +161811,9 @@ var getFileExtension = (filename) => {
   const extension = lastSegment.split(".").pop();
   return extension?.toLowerCase() ?? null;
 };
-var joinUrlPath = (base, path57) => {
+var joinUrlPath = (base, path58) => {
   const trimmedBase = base.replace(/\/+$/, "");
-  const trimmedPath = path57.replace(/^\/+/, "");
+  const trimmedPath = path58.replace(/^\/+/, "");
   return `${trimmedBase}/${trimmedPath}`;
 };
 var constructAssetUrl = (targetUrl, baseUrl) => {
@@ -163084,7 +163127,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
     for (let i22 = 0;i22 < portsWithPosition.length - 1; i22++) {
       const start = portsWithPosition[i22];
       const end = portsWithPosition[i22 + 1];
-      const path57 = calculateElbow({
+      const path58 = calculateElbow({
         x: start.position.x,
         y: start.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(start.facingDirection)
@@ -163093,8 +163136,8 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         y: end.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(end.facingDirection)
       });
-      for (let j22 = 0;j22 < path57.length - 1; j22++) {
-        elbowEdges.push({ from: path57[j22], to: path57[j22 + 1] });
+      for (let j22 = 0;j22 < path58.length - 1; j22++) {
+        elbowEdges.push({ from: path58[j22], to: path58[j22 + 1] });
       }
     }
     const doesSegmentIntersectRect2 = (edge, rect) => {
@@ -164287,20 +164330,20 @@ var parseLibraryFootprintRef = (s22) => {
 };
 var isStaticAssetPath = (s22) => s22.startsWith("/");
 var resolveStaticFileImportDebug = (0, import_debug92.default)("tscircuit:core:resolveStaticFileImport");
-async function resolveStaticFileImport(path57, platform) {
-  if (!path57)
-    return path57;
+async function resolveStaticFileImport(path58, platform) {
+  if (!path58)
+    return path58;
   const resolver = platform?.resolveProjectStaticFileImportUrl;
-  if (resolver && path57.startsWith("/")) {
+  if (resolver && path58.startsWith("/")) {
     try {
-      const resolved = await resolver(path57);
+      const resolved = await resolver(path58);
       if (resolved)
         return resolved;
     } catch (error) {
       resolveStaticFileImportDebug("failed to resolve static file via platform resolver", error);
     }
   }
-  return constructAssetUrl(path57, platform?.projectBaseUrl);
+  return constructAssetUrl(path58, platform?.projectBaseUrl);
 }
 function NormalComponent_doInitialPcbFootprintStringRender(component, queueAsyncEffect) {
   let { footprint } = component.props;
@@ -171947,7 +171990,7 @@ var NetLabel = class extends PrimitiveComponent2 {
       }
       const portPos = port._getGlobalSchematicPositionAfterLayout();
       const portFacing = convertFacingDirectionToElbowDirection(port.facingDirection ?? "right") ?? "x+";
-      const path57 = calculateElbow({
+      const path58 = calculateElbow({
         x: portPos.x,
         y: portPos.y,
         facingDirection: portFacing
@@ -171956,13 +171999,13 @@ var NetLabel = class extends PrimitiveComponent2 {
         y: anchorPos.y,
         facingDirection: anchorFacing
       });
-      if (!Array.isArray(path57) || path57.length < 2)
+      if (!Array.isArray(path58) || path58.length < 2)
         continue;
       const edges = [];
-      for (let i22 = 0;i22 < path57.length - 1; i22++) {
+      for (let i22 = 0;i22 < path58.length - 1; i22++) {
         edges.push({
-          from: { x: path57[i22].x, y: path57[i22].y },
-          to: { x: path57[i22 + 1].x, y: path57[i22 + 1].y }
+          from: { x: path58[i22].x, y: path58[i22].y },
+          to: { x: path58[i22 + 1].x, y: path58[i22 + 1].y }
         });
       }
       let source_trace_id;
@@ -174275,7 +174318,7 @@ react/cjs/react-jsx-runtime.development.js:
 
 // lib/import/import-component-from-jlcpcb.ts
 import fs56 from "node:fs/promises";
-import path57 from "node:path";
+import path58 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd()) => {
   const component = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const tsx = await convertRawEasyToTsx(component);
@@ -174283,9 +174326,9 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
   if (!fileName) {
     throw new Error("Could not determine file name of converted component");
   }
-  const importsDir = path57.join(projectDir, "imports");
+  const importsDir = path58.join(projectDir, "imports");
   await fs56.mkdir(importsDir, { recursive: true });
-  const filePath = path57.join(importsDir, `${fileName}.tsx`);
+  const filePath = path58.join(importsDir, `${fileName}.tsx`);
   await fs56.writeFile(filePath, tsx);
   return { filePath };
 };
@@ -175631,12 +175674,12 @@ var registerImport = (program2) => {
 
 // cli/init/register.ts
 import * as fs58 from "node:fs";
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 
 // lib/shared/generate-gitignore-file.ts
-import path58 from "node:path";
+import path59 from "node:path";
 var generateGitIgnoreFile = (dir) => {
-  const gitignorePath = path58.join(dir, ".gitignore");
+  const gitignorePath = path59.join(dir, ".gitignore");
   const gitignoreContent = `# Dependencies
 node_modules/
 
@@ -175672,7 +175715,7 @@ yarn-error.log*
 
 // lib/shared/setup-tscircuit-skill.ts
 import * as fs57 from "node:fs";
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 var SKILL_REPO_API_URL = "https://api.github.com/repos/tscircuit/skill/contents";
 var SKILL_INSTALL_PATHS = [
   ".claude/skills/tscircuit",
@@ -175695,7 +175738,7 @@ async function fetchFileContent(downloadUrl) {
 async function downloadDirectory(apiUrl, targetDir) {
   const contents = await fetchGitHubContents(apiUrl);
   for (const item of contents) {
-    const targetPath = path59.join(targetDir, item.name);
+    const targetPath = path60.join(targetDir, item.name);
     if (item.type === "dir") {
       fs57.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${apiUrl}/${item.name}`, targetPath);
@@ -175712,7 +175755,7 @@ async function downloadSkillRepo(targetDir) {
     if (item.name === ".git" || item.name === ".github") {
       continue;
     }
-    const targetPath = path59.join(targetDir, item.name);
+    const targetPath = path60.join(targetDir, item.name);
     if (item.type === "dir") {
       fs57.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${SKILL_REPO_API_URL}/${item.name}`, targetPath);
@@ -175723,7 +175766,7 @@ async function downloadSkillRepo(targetDir) {
   }
 }
 async function setupTscircuitSkill(projectDir, skipPrompt = false) {
-  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs57.existsSync(path59.join(projectDir, skillPath, "SKILL.md")));
+  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs57.existsSync(path60.join(projectDir, skillPath, "SKILL.md")));
   if (missingSkillPaths.length === 0) {
     console.log("TSCircuit AI skills already exist, skipping...");
     return true;
@@ -175743,7 +175786,7 @@ async function setupTscircuitSkill(projectDir, skipPrompt = false) {
   console.info("Setting up tscircuit AI skills...");
   try {
     for (const skillPath of missingSkillPaths) {
-      const targetDir = path59.join(projectDir, skillPath);
+      const targetDir = path60.join(projectDir, skillPath);
       await downloadSkillRepo(targetDir);
       console.info(`tscircuit skill installed at ${skillPath}`);
     }
@@ -175847,7 +175890,7 @@ var registerInit = (program3) => {
         }
       }
     }
-    const projectDir = directory ? path60.resolve(process.cwd(), directory) : process.cwd();
+    const projectDir = directory ? path61.resolve(process.cwd(), directory) : process.cwd();
     let tsciHandle = null;
     const token = getSessionToken();
     if (token) {
@@ -175858,7 +175901,7 @@ var registerInit = (program3) => {
         }
       } catch {}
     }
-    const dirName = path60.basename(projectDir);
+    const dirName = path61.basename(projectDir);
     let defaultPackageName = dirName;
     if (tsciHandle) {
       defaultPackageName = `@tsci/${tsciHandle}.${dirName}`;
@@ -175877,7 +175920,7 @@ var registerInit = (program3) => {
       }
     }
     fs58.mkdirSync(projectDir, { recursive: true });
-    writeFileIfNotExists(path60.join(projectDir, "index.circuit.tsx"), `
+    writeFileIfNotExists(path61.join(projectDir, "index.circuit.tsx"), `
 export default () => (
   <board>
     <resistor resistance="1k" footprint="0402" name="R1" />
@@ -175889,7 +175932,7 @@ export default () => (
     if (saveProjectConfig(null, projectDir)) {
       console.log("Created tscircuit.config.json with schema");
     }
-    writeFileIfNotExists(path60.join(projectDir, ".npmrc"), `
+    writeFileIfNotExists(path61.join(projectDir, ".npmrc"), `
 @tsci:registry=https://npm.tscircuit.com
 `);
     console.log("Generating package.json");
@@ -176040,14 +176083,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path61 = null;
+  let path62 = null;
   let id = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path61 = createKeyPath(key);
+    path62 = createKeyPath(key);
     id = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -176061,11 +176104,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path61 = createKeyPath(name);
+    path62 = createKeyPath(name);
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path61, id, weight, src, getFn };
+  return { path: path62, id, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -176073,34 +176116,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path61) {
+function get(obj, path62) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path62, index) => {
+  const deepGet = (obj2, path63, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path62[index]) {
+    if (!path63[index]) {
       list.push(obj2);
     } else {
-      let key = path62[index];
+      let key = path63[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path62.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
+      if (index === path63.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
         list.push(toString(value));
       } else if (isArray(value)) {
         arr = true;
         for (let i3 = 0, len = value.length;i3 < len; i3 += 1) {
-          deepGet(value[i3], path62, index + 1);
+          deepGet(value[i3], path63, index + 1);
         }
-      } else if (path62.length) {
-        deepGet(value, path62, index + 1);
+      } else if (path63.length) {
+        deepGet(value, path63, index + 1);
       }
     }
   };
-  deepGet(obj, isString2(path61) ? path61.split(".") : path61, 0);
+  deepGet(obj, isString2(path62) ? path62.split(".") : path62, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -177264,7 +177307,7 @@ Fuse2.config = Config;
 
 // cli/search/register.ts
 var registerSearch = (program3) => {
-  program3.command("search").description("Search for footprints, CAD models or packages in the tscircuit ecosystem").argument("<query>", "Search query (e.g. keyword, author, or package name)").option("--kicad", "Search KiCad footprints").option("--jlcpcb", "Search JLCPCB components").option("--lcsc", "Alias for --jlcpcb").option("--tscircuit", "Search tscircuit registry packages").action(async (query, opts) => {
+  program3.command("search").description("Search for footprints, CAD models or packages in the tscircuit ecosystem").argument("<query>", "Search query (e.g. keyword, author, or package name)").option("--kicad", "Search KiCad footprints").option("--jlcpcb", "Search JLCPCB components").option("--lcsc", "Alias for --jlcpcb").option("--tscircuit", "Search tscircuit registry packages").option("--json", "Output search results as JSON").action(async (query, opts) => {
     const hasFilters = opts.kicad || opts.jlcpcb || opts.lcsc || opts.tscircuit;
     const searchKicad = opts.kicad || !hasFilters;
     const searchJlc = opts.jlcpcb || opts.lcsc || !hasFilters;
@@ -177293,6 +177336,27 @@ var registerSearch = (program3) => {
       console.error(kleur_default.red("Failed to search registry:"), error instanceof Error ? error.message : error);
       process.exit(1);
     }
+    if (opts.json) {
+      const unifiedResults = [
+        ...kicadResults.map((path62) => ({
+          source: "kicad",
+          path: path62
+        })),
+        ...results.packages.map((pkg) => ({
+          source: "tscircuit",
+          ...pkg
+        })),
+        ...jlcResults.map((comp) => ({
+          source: "jlcpcb",
+          ...comp
+        }))
+      ];
+      console.log(JSON.stringify({
+        query,
+        results: unifiedResults
+      }, null, 2));
+      return;
+    }
     if (!kicadResults.length && !results.packages.length && !jlcResults.length) {
       const sources = [
         searchTscircuit && "tscircuit registry",
@@ -177304,8 +177368,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path61, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path61.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path62, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path62.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (results.packages.length) {
@@ -177330,20 +177394,20 @@ var registerSearch = (program3) => {
 
 // lib/shared/setup-github-actions.ts
 import fs59 from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path61.resolve(startDir);
-    while (dir !== path61.parse(dir).root) {
-      if (fs59.existsSync(path61.join(dir, ".git"))) {
+    let dir = path62.resolve(startDir);
+    while (dir !== path62.parse(dir).root) {
+      if (fs59.existsSync(path62.join(dir, ".git"))) {
         return dir;
       }
-      dir = path61.dirname(dir);
+      dir = path62.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path61.join(gitRoot, ".github", "workflows");
+  const workflowsDir = path62.join(gitRoot, ".github", "workflows");
   fs59.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
@@ -177383,8 +177447,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path61.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path61.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path62.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path62.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -177551,21 +177615,21 @@ function applyCameraPreset(preset, cam) {
 }
 
 // lib/shared/snapshot-project.ts
-import path64 from "node:path";
+import path65 from "node:path";
 
 // cli/snapshot/worker-pool.ts
 import fs60 from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 var getWorkerEntrypointPath2 = () => {
-  const tsPath = path62.join(import.meta.dir, "snapshot.worker.ts");
+  const tsPath = path63.join(import.meta.dir, "snapshot.worker.ts");
   if (fs60.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path62.join(import.meta.dir, "snapshot", "snapshot.worker.js");
+  const jsBundledPath = path63.join(import.meta.dir, "snapshot", "snapshot.worker.js");
   if (fs60.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path62.join(import.meta.dir, "snapshot.worker.js");
+  return path63.join(import.meta.dir, "snapshot.worker.js");
 };
 var snapshotFilesWithWorkerPool = async (options) => {
   const cancellationError = new Error("Snapshot cancelled due to file failure");
@@ -177633,7 +177697,7 @@ var snapshotFilesWithWorkerPool = async (options) => {
 
 // lib/shared/process-snapshot-file.ts
 import fs62 from "node:fs";
-import path63 from "node:path";
+import path64 from "node:path";
 import {
   convertCircuitJsonToGltf as convertCircuitJsonToGltf5,
   getBestCameraPosition
@@ -177686,7 +177750,7 @@ var processSnapshotFile = async ({
   createDiff,
   cameraPreset
 }) => {
-  const relativeFilePath = path63.relative(projectDir, file);
+  const relativeFilePath = path64.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -177767,11 +177831,11 @@ var processSnapshotFile = async ({
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-        const fileDir = path63.dirname(file);
-        const relativeDir = path63.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path63.join(projectDir, snapshotsDirName, relativeDir) : path63.join(fileDir, "__snapshots__");
-        const base2 = path63.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path63.join(snapDir2, `${base2}-3d.snap.png`);
+        const fileDir = path64.dirname(file);
+        const relativeDir = path64.relative(projectDir, fileDir);
+        const snapDir2 = snapshotsDirName ? path64.join(projectDir, snapshotsDirName, relativeDir) : path64.join(fileDir, "__snapshots__");
+        const base2 = path64.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path64.join(snapDir2, `${base2}-3d.snap.png`);
         const existing3dSnapshot = fs62.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
@@ -177783,7 +177847,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: ${path63.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path64.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -177804,9 +177868,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path63.join(projectDir, snapshotsDirName, path63.relative(projectDir, path63.dirname(file))) : path63.join(path63.dirname(file), "__snapshots__");
+  const snapDir = snapshotsDirName ? path64.join(projectDir, snapshotsDirName, path64.relative(projectDir, path64.dirname(file))) : path64.join(path64.dirname(file), "__snapshots__");
   fs62.mkdirSync(snapDir, { recursive: true });
-  const base = path63.basename(file).replace(/\.[^.]+$/, "");
+  const base = path64.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (pcbOnly || !schematicOnly) {
     snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -177820,13 +177884,13 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path63.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const snapPath = path64.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
     const existing = fs62.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
       fs62.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path63.relative(projectDir, snapPath));
+      successPaths.push(path64.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
@@ -177835,16 +177899,16 @@ var processSnapshotFile = async ({
     const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath, createDiff);
     if (update) {
       if (!forceUpdate && equal2) {
-        successPaths.push(path63.relative(projectDir, snapPath));
+        successPaths.push(path64.relative(projectDir, snapPath));
       } else {
         fs62.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path63.relative(projectDir, snapPath));
+        successPaths.push(path64.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal2) {
       mismatches.push(createDiff ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path63.relative(projectDir, snapPath));
+      successPaths.push(path64.relative(projectDir, snapPath));
     }
   }
   return {
@@ -177881,7 +177945,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path64.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path65.resolve(projectDir, f2));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -178011,7 +178075,7 @@ var registerSnapshot = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path65 from "node:path";
+import path66 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 {
@@ -178019,7 +178083,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path65.join(projectDir, "dist");
+      const distDir = path66.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];