@tscircuit/cli 0.1.1018 → 0.1.1019

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, path43) {
+      function isIgnored(self2, path44) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return item.matcher.match(path43) || !!(item.gmatcher && item.gmatcher.match(path43));
+          return item.matcher.match(path44) || !!(item.gmatcher && item.gmatcher.match(path44));
         });
       }
-      function childrenIgnored(self2, path43) {
+      function childrenIgnored(self2, path44) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return !!(item.gmatcher && item.gmatcher.match(path43));
+          return !!(item.gmatcher && item.gmatcher.match(path44));
         });
       }
     }
@@ -71664,18 +71664,19 @@ var registerStaticAssetLoaders = () => {
 // cli/main.ts
 var import_perfect_cli = __toESM2(require_dist2(), 1);
 // package.json
-var version = "0.1.1017";
+var version = "0.1.1018";
 var package_default = {
   name: "@tscircuit/cli",
+  version,
   main: "dist/cli/main.js",
   exports: {
     ".": "./dist/cli/main.js",
     "./lib": "./dist/lib/index.js"
   },
-  version,
   devDependencies: {
     "@babel/standalone": "^7.26.9",
     "@biomejs/biome": "^1.9.4",
+    "@tscircuit/circuit-json-placement-analysis": "^0.0.1",
     "@tscircuit/circuit-json-util": "0.0.72",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
@@ -71735,6 +71736,10 @@ var package_default = {
   peerDependencies: {
     tscircuit: "*"
   },
+  exports: {
+    ".": "./dist/cli/main.js",
+    "./lib": "./dist/lib/index.js"
+  },
   bin: {
     "tscircuit-cli": "./cli/entrypoint.js"
   },
@@ -82469,9 +82474,363 @@ var registerCheckNetlist = (program2) => {
 };
 
 // cli/check/placement/register.ts
+import fs38 from "node:fs";
+import path39 from "node:path";
+
+// node_modules/@tscircuit/circuit-json-placement-analysis/dist/index.js
+var CENTER_ANCHOR = "center";
+var toNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var fmtNumber = (value) => {
+  if (Number.isInteger(value))
+    return String(value);
+  return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
+};
+var fmtMm = (value) => `${fmtNumber(value)}mm`;
+var withSignedMm = (value) => {
+  const abs = fmtMm(Math.abs(value));
+  return value >= 0 ? `+${abs}` : `-${abs}`;
+};
+var isOffBoardEdgeOffset = (boardEdge, offset) => {
+  if (boardEdge === "board.minX" || boardEdge === "board.minY") {
+    return offset < 0;
+  }
+  return offset > 0;
+};
+var getComponentToComponentCalcString = (componentName, otherComponentName, direction, distance) => {
+  const d = fmtMm(distance);
+  switch (direction) {
+    case "right":
+      return `${componentName}.pcbLeftEdgeX=calc(${otherComponentName}.maxX+${d})`;
+    case "left":
+      return `${componentName}.pcbRightEdgeX=calc(${otherComponentName}.minX-${d})`;
+    case "up":
+      return `${componentName}.pcbTopEdgeY=calc(${otherComponentName}.minY-${d})`;
+    case "down":
+      return `${componentName}.pcbBottomEdgeY=calc(${otherComponentName}.maxY+${d})`;
+  }
+};
+var getComponentToBoardCalcString = (componentName, direction, distance) => {
+  const d = fmtMm(distance);
+  switch (direction) {
+    case "right":
+      return `${componentName}.centerX=calc(board.centerX+${d})`;
+    case "left":
+      return `${componentName}.centerX=calc(board.centerX-${d})`;
+    case "up":
+      return `${componentName}.centerY=calc(board.centerY-${d})`;
+    case "down":
+      return `${componentName}.centerY=calc(board.centerY+${d})`;
+  }
+};
+var getDirectionAndDistance = (fromX, fromY, toX, toY) => {
+  const dx = toX - fromX;
+  const dy = toY - fromY;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return {
+      direction: dx >= 0 ? "right" : "left",
+      distance: Math.abs(dx),
+      axis: "x"
+    };
+  }
+  return {
+    direction: dy >= 0 ? "up" : "down",
+    distance: Math.abs(dy),
+    axis: "y"
+  };
+};
+var lineItemToString = (lineItem) => {
+  switch (lineItem.line_item_type) {
+    case "absolute_component_position":
+      return `${lineItem.component_name}.center=(${fmtMm(lineItem.anchor_position.x)}, ${fmtMm(lineItem.anchor_position.y)}) on ${lineItem.anchor_position.layer}`;
+    case "relative_component_to_component_position":
+      return getComponentToComponentCalcString(lineItem.component_name, lineItem.other_component_name, lineItem.direction, lineItem.distance);
+    case "relative_component_to_board_position":
+      return getComponentToBoardCalcString(lineItem.component_name, lineItem.direction, lineItem.distance);
+    case "component_position_defined_as": {
+      const bits = [];
+      if (lineItem.x_definition)
+        bits.push(`x=${lineItem.x_definition}`);
+      if (lineItem.y_definition)
+        bits.push(`y=${lineItem.y_definition}`);
+      if (lineItem.placement_mode)
+        bits.push(`placement_mode=${lineItem.placement_mode}`);
+      if (bits.length === 0)
+        return `${lineItem.component_name} has no explicit placement definition`;
+      return `${lineItem.component_name} placement definition: ${bits.join(", ")}`;
+    }
+    case "component_anchor_alignment":
+      return `${lineItem.component_name}.anchor_alignment="${lineItem.anchor_alignment}"`;
+    case "component_bounds":
+      return `${lineItem.component_name}.bounds=(minX=${fmtMm(lineItem.min_x)}, maxX=${fmtMm(lineItem.max_x)}, minY=${fmtMm(lineItem.min_y)}, maxY=${fmtMm(lineItem.max_y)})`;
+    case "component_size":
+      return `${lineItem.component_name}.size=(width=${fmtMm(lineItem.width)}, height=${fmtMm(lineItem.height)})`;
+    case "component_orientation":
+      return `${lineItem.component_name}.orientation=${lineItem.orientation}`;
+    case "relative_component_edge_to_board_edge_position":
+      return `${lineItem.component_name}.${lineItem.component_edge}=calc(${lineItem.board_edge}${withSignedMm(lineItem.offset)})${isOffBoardEdgeOffset(lineItem.board_edge, lineItem.offset) ? " [offboard]" : ""}`;
+    default:
+      return "";
+  }
+};
+var analyzeComponentPlacement = (circuitJson, componentName) => {
+  const sourceComponent = circuitJson.find((el) => el.type === "source_component" && el.name === componentName);
+  const sourceComponentId = typeof sourceComponent?.source_component_id === "string" ? sourceComponent.source_component_id : null;
+  const lineItems = [];
+  if (!sourceComponent || !sourceComponentId) {
+    return {
+      getLineItems: () => [],
+      getString: () => `Component ${componentName} was not found`
+    };
+  }
+  const pcbComponent = circuitJson.find((el) => el.type === "pcb_component" && el.source_component_id === sourceComponentId);
+  const center = pcbComponent && typeof pcbComponent.center === "object" && pcbComponent.center ? pcbComponent.center : null;
+  const centerX = center ? toNumber2(center.x) : null;
+  const centerY = center ? toNumber2(center.y) : null;
+  const layer = typeof pcbComponent?.layer === "string" ? pcbComponent.layer : null;
+  if (centerX !== null && centerY !== null && layer !== null) {
+    lineItems.push({
+      line_item_type: "absolute_component_position",
+      component_name: componentName,
+      anchor_alignment: CENTER_ANCHOR,
+      anchor_position: {
+        x: centerX,
+        y: centerY,
+        layer
+      }
+    });
+  }
+  const componentWidth = toNumber2(pcbComponent?.width);
+  const componentHeight = toNumber2(pcbComponent?.height);
+  let componentBounds = null;
+  if (centerX !== null && centerY !== null && componentWidth !== null && componentHeight !== null) {
+    const halfWidth = componentWidth / 2;
+    const halfHeight = componentHeight / 2;
+    componentBounds = {
+      line_item_type: "component_bounds",
+      component_name: componentName,
+      width: componentWidth,
+      height: componentHeight,
+      min_x: centerX - halfWidth,
+      max_x: centerX + halfWidth,
+      min_y: centerY - halfHeight,
+      max_y: centerY + halfHeight
+    };
+    lineItems.push(componentBounds);
+    const componentSize = {
+      line_item_type: "component_size",
+      component_name: componentName,
+      width: componentWidth,
+      height: componentHeight
+    };
+    lineItems.push(componentSize);
+    if (sourceComponent.ftype === "simple_pin_header") {
+      const componentOrientation = {
+        line_item_type: "component_orientation",
+        component_name: componentName,
+        orientation: componentWidth >= componentHeight ? "horizontal" : "vertical"
+      };
+      lineItems.push(componentOrientation);
+    }
+  }
+  const anchorAlignmentFromSilk = typeof pcbComponent?.pcb_component_id === "string" ? circuitJson.find((el) => el.type === "pcb_silkscreen_text" && el.pcb_component_id === pcbComponent.pcb_component_id && typeof el.anchor_alignment === "string") : null;
+  const anchorAlignment = typeof anchorAlignmentFromSilk?.anchor_alignment === "string" ? anchorAlignmentFromSilk.anchor_alignment : CENTER_ANCHOR;
+  lineItems.push({
+    line_item_type: "component_anchor_alignment",
+    component_name: componentName,
+    anchor_alignment: anchorAlignment
+  });
+  const xDefinitionRaw = sourceComponent.pcbX ?? sourceComponent.pcb_x ?? sourceComponent.x;
+  const yDefinitionRaw = sourceComponent.pcbY ?? sourceComponent.pcb_y ?? sourceComponent.y;
+  const xDefinition = xDefinitionRaw === undefined ? undefined : String(xDefinitionRaw);
+  const yDefinition = yDefinitionRaw === undefined ? undefined : String(yDefinitionRaw);
+  let placementMode = "none";
+  if (xDefinition !== undefined || yDefinition !== undefined) {
+    placementMode = "props_set";
+  } else if (sourceComponent.placement_mode === "auto" || pcbComponent?.position_mode === "auto") {
+    placementMode = "auto";
+  }
+  lineItems.push({
+    line_item_type: "component_position_defined_as",
+    component_name: componentName,
+    x_definition: xDefinition,
+    y_definition: yDefinition,
+    placement_mode: placementMode
+  });
+  const pcbBoard = circuitJson.find((el) => el.type === "pcb_board");
+  const boardCenter = pcbBoard && typeof pcbBoard.center === "object" && pcbBoard.center ? pcbBoard.center : null;
+  const boardCenterX = boardCenter ? toNumber2(boardCenter.x) : null;
+  const boardCenterY = boardCenter ? toNumber2(boardCenter.y) : null;
+  if (componentBounds !== null && boardCenterX !== null && boardCenterY !== null && toNumber2(pcbBoard?.width) !== null && toNumber2(pcbBoard?.height) !== null) {
+    const boardWidth = toNumber2(pcbBoard?.width);
+    const boardHeight = toNumber2(pcbBoard?.height);
+    const boardMinX = boardCenterX - boardWidth / 2;
+    const boardMaxX = boardCenterX + boardWidth / 2;
+    const boardMinY = boardCenterY - boardHeight / 2;
+    const boardMaxY = boardCenterY + boardHeight / 2;
+    const leftOffsetFromBoardMinX = componentBounds.min_x - boardMinX;
+    const rightOffsetFromBoardMaxX = componentBounds.max_x - boardMaxX;
+    const topOffsetFromBoardMinY = componentBounds.min_y - boardMinY;
+    const bottomOffsetFromBoardMaxY = componentBounds.max_y - boardMaxY;
+    const nearestHorizontal = Math.abs(leftOffsetFromBoardMinX) <= Math.abs(rightOffsetFromBoardMaxX) ? {
+      line_item_type: "relative_component_edge_to_board_edge_position",
+      component_name: componentName,
+      component_edge: "pcbLeftEdgeX",
+      board_edge: "board.minX",
+      offset: leftOffsetFromBoardMinX
+    } : {
+      line_item_type: "relative_component_edge_to_board_edge_position",
+      component_name: componentName,
+      component_edge: "pcbRightEdgeX",
+      board_edge: "board.maxX",
+      offset: rightOffsetFromBoardMaxX
+    };
+    const nearestVertical = Math.abs(topOffsetFromBoardMinY) <= Math.abs(bottomOffsetFromBoardMaxY) ? {
+      line_item_type: "relative_component_edge_to_board_edge_position",
+      component_name: componentName,
+      component_edge: "pcbTopEdgeY",
+      board_edge: "board.minY",
+      offset: topOffsetFromBoardMinY
+    } : {
+      line_item_type: "relative_component_edge_to_board_edge_position",
+      component_name: componentName,
+      component_edge: "pcbBottomEdgeY",
+      board_edge: "board.maxY",
+      offset: bottomOffsetFromBoardMaxY
+    };
+    lineItems.push(nearestHorizontal);
+    lineItems.push(nearestVertical);
+    const boardRelation = getDirectionAndDistance(boardCenterX, boardCenterY, componentBounds.min_x + componentBounds.width / 2, componentBounds.min_y + componentBounds.height / 2);
+    const boardLineItem = {
+      line_item_type: "relative_component_to_board_position",
+      component_name: componentName,
+      anchor_alignment: CENTER_ANCHOR,
+      board_anchor_alignment: CENTER_ANCHOR,
+      direction: boardRelation.direction,
+      distance: boardRelation.distance,
+      calc_distance: `abs(${componentName}.center.${boardRelation.axis} - board.center.${boardRelation.axis})`
+    };
+    lineItems.push(boardLineItem);
+  }
+  if (centerX !== null && centerY !== null) {
+    const sourceComponentsById = /* @__PURE__ */ new Map;
+    for (const el of circuitJson) {
+      if (el.type === "source_component" && typeof el.source_component_id === "string" && typeof el.name === "string") {
+        sourceComponentsById.set(el.source_component_id, el.name);
+      }
+    }
+    const otherPcbComponents = circuitJson.filter((el) => el.type === "pcb_component" && el.source_component_id !== sourceComponentId && typeof el.source_component_id === "string");
+    let closest = null;
+    for (const other of otherPcbComponents) {
+      const otherName = sourceComponentsById.get(other.source_component_id);
+      if (!otherName)
+        continue;
+      const otherCenter = typeof other.center === "object" && other.center ? other.center : null;
+      const otherCenterX = otherCenter ? toNumber2(otherCenter.x) : null;
+      const otherCenterY = otherCenter ? toNumber2(otherCenter.y) : null;
+      if (otherCenterX === null || otherCenterY === null)
+        continue;
+      const dx = otherCenterX - centerX;
+      const dy = otherCenterY - centerY;
+      const score = Math.hypot(dx, dy);
+      if (!closest || score < closest.score) {
+        closest = {
+          name: otherName,
+          centerX: otherCenterX,
+          centerY: otherCenterY,
+          score
+        };
+      }
+    }
+    if (closest) {
+      const relation = getDirectionAndDistance(closest.centerX, closest.centerY, centerX, centerY);
+      const relativeLineItem = {
+        line_item_type: "relative_component_to_component_position",
+        component_name: componentName,
+        anchor_alignment: CENTER_ANCHOR,
+        other_component_name: closest.name,
+        other_anchor_alignment: CENTER_ANCHOR,
+        direction: relation.direction,
+        distance: relation.distance,
+        calc_distance: `abs(${componentName}.center.${relation.axis} - ${closest.name}.center.${relation.axis})`
+      };
+      lineItems.push(relativeLineItem);
+    }
+  }
+  return {
+    getLineItems: () => lineItems,
+    getString: () => lineItems.map(lineItemToString).join(`
+`)
+  };
+};
+var analyzeAllPlacements = (circuitJson) => {
+  const componentNames = [];
+  const seenNames = /* @__PURE__ */ new Set;
+  for (const el of circuitJson) {
+    if (el.type !== "source_component" || typeof el.name !== "string")
+      continue;
+    if (seenNames.has(el.name))
+      continue;
+    seenNames.add(el.name);
+    componentNames.push(el.name);
+  }
+  const analyses = componentNames.map((componentName) => ({
+    componentName,
+    analysis: analyzeComponentPlacement(circuitJson, componentName)
+  }));
+  const lineItems = analyses.flatMap(({ analysis }) => analysis.getLineItems());
+  return {
+    getLineItems: () => lineItems,
+    getString: () => analyses.map(({ analysis }) => analysis.getString()).join(`
+`)
+  };
+};
+
+// cli/check/placement/register.ts
+var isPrebuiltCircuitJsonFile = (filePath) => {
+  const normalizedInputPath = filePath.toLowerCase().replaceAll("\\", "/");
+  return normalizedInputPath.endsWith(".circuit.json") || normalizedInputPath.endsWith("/circuit.json");
+};
+var resolveInputFilePath = async (file) => {
+  if (file) {
+    return path39.isAbsolute(file) ? file : path39.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 getCircuitJsonForPlacementCheck = async (filePath) => {
+  if (isPrebuiltCircuitJsonFile(filePath)) {
+    const parsedJson = JSON.parse(fs38.readFileSync(filePath, "utf-8"));
+    return Array.isArray(parsedJson) ? parsedJson : [];
+  }
+  const completePlatformConfig = getCompletePlatformConfig({
+    pcbDisabled: true
+  });
+  const { circuitJson } = await generateCircuitJson({
+    filePath,
+    platformConfig: completePlatformConfig
+  });
+  return circuitJson;
+};
+var checkPlacement = async (file, refdes) => {
+  const resolvedInputFilePath = await resolveInputFilePath(file);
+  const circuitJson = await getCircuitJsonForPlacementCheck(resolvedInputFilePath);
+  const analysis = refdes ? analyzeComponentPlacement(circuitJson, refdes) : analyzeAllPlacements(circuitJson);
+  return analysis.getString();
+};
 var registerCheckPlacement = (program2) => {
-  program2.commands.find((c) => c.name() === "check").command("placement").description("Partially build and validate the placement").argument("[refdeses]", "Optional refdeses to scope the check").action(() => {
-    throw new Error("Not implemented");
+  program2.commands.find((c) => c.name() === "check").command("placement").description("Partially build and validate the placement").argument("[file]", "Path to the entry file").argument("[refdes]", "Optional refdes to scope the check").action(async (file, refdes) => {
+    try {
+      const output = await checkPlacement(file, refdes);
+      console.log(output);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
   });
 };
 
@@ -82488,26 +82847,26 @@ var registerCheckRouting = (program2) => {
 };
 
 // cli/clone/register.ts
-import * as fs40 from "node:fs";
-import * as path41 from "node:path";
+import * as fs41 from "node:fs";
+import * as path42 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 fs39 from "node:fs";
-import * as path40 from "node:path";
+import * as fs40 from "node:fs";
+import * as path41 from "node:path";
 
 // cli/clone/handle-existing-directory.ts
 var import_prompts3 = __toESM2(require_prompts3(), 1);
-import * as fs38 from "node:fs";
-import * as path39 from "node:path";
+import * as fs39 from "node:fs";
+import * as path40 from "node:path";
 var handleExistingDirectory = async (dirPath) => {
-  if (!fs38.existsSync(dirPath))
+  if (!fs39.existsSync(dirPath))
     return;
   const response = await import_prompts3.default({
     type: "select",
     name: "action",
-    message: `Directory "${path39.basename(dirPath)}" already exists. What would you like to do?`,
+    message: `Directory "${path40.basename(dirPath)}" already exists. What would you like to do?`,
     choices: [
       { title: "Merge files into existing directory", value: "merge" },
       {
@@ -82522,7 +82881,7 @@ var handleExistingDirectory = async (dirPath) => {
     process.exit(0);
   }
   if (response.action === "delete") {
-    fs38.rmSync(dirPath, { recursive: true, force: true });
+    fs39.rmSync(dirPath, { recursive: true, force: true });
     console.log(`Deleted existing directory: ${dirPath}`);
   } else if (response.action === "merge") {
     console.log(`Merging files into existing directory: ${dirPath}`);
@@ -82548,12 +82907,12 @@ var getCommonDirectoryPrefix = (paths) => {
   return commonSegments.join("/");
 };
 var sanitizeRelativePath = (relativePath) => {
-  const normalizedPath = path40.normalize(relativePath);
+  const normalizedPath = path41.normalize(relativePath);
   if (!normalizedPath)
     return null;
-  if (path40.isAbsolute(normalizedPath))
+  if (path41.isAbsolute(normalizedPath))
     return null;
-  const segments = normalizedPath.split(path40.sep);
+  const segments = normalizedPath.split(path41.sep);
   if (segments.some((segment) => segment === ".." || segment === "")) {
     return null;
   }
@@ -82568,7 +82927,7 @@ var cloneBugReport = async ({
     console.error("Bug report ID must not be empty.");
     process.exit(1);
   }
-  let dirPath = path40.resolve(`bug-report-${trimmedBugReportId}`);
+  let dirPath = path41.resolve(`bug-report-${trimmedBugReportId}`);
   await handleExistingDirectory(dirPath);
   const ky2 = getRegistryApiKy();
   let zipBuffer;
@@ -82586,7 +82945,7 @@ var cloneBugReport = async ({
     }
     process.exit(1);
   }
-  fs39.mkdirSync(dirPath, { recursive: true });
+  fs40.mkdirSync(dirPath, { recursive: true });
   const zip = await import_jszip2.default.loadAsync(zipBuffer);
   const fileEntries = Object.entries(zip.files).filter(([, entry]) => !entry.dir);
   const commonPrefix = getCommonDirectoryPrefix(fileEntries.map(([fileName]) => fileName));
@@ -82598,29 +82957,29 @@ var cloneBugReport = async ({
       console.warn(`Skipping potentially unsafe path: ${fileName}`);
       continue;
     }
-    const fullPath = path40.join(dirPath, sanitizedRelativePath);
-    fs39.mkdirSync(path40.dirname(fullPath), { recursive: true });
+    const fullPath = path41.join(dirPath, sanitizedRelativePath);
+    fs40.mkdirSync(path41.dirname(fullPath), { recursive: true });
     const fileContent = await entry.async("nodebuffer");
-    fs39.writeFileSync(fullPath, fileContent);
+    fs40.writeFileSync(fullPath, fileContent);
   }
-  const packageJsonPath = path40.join(dirPath, "package.json");
-  if (fs39.existsSync(packageJsonPath)) {
+  const packageJsonPath = path41.join(dirPath, "package.json");
+  if (fs40.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs39.readFileSync(packageJsonPath, "utf-8"));
+      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 = path40.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
+        const suggestedDirPath = path41.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 "${path40.basename(suggestedDirPath)}"?`
+            message: `Rename the directory to "${path41.basename(suggestedDirPath)}"?`
           });
           if (response.rename) {
             await handleExistingDirectory(suggestedDirPath);
-            fs39.renameSync(dirPath, suggestedDirPath);
+            fs40.renameSync(dirPath, suggestedDirPath);
             dirPath = suggestedDirPath;
           }
         }
@@ -82629,9 +82988,9 @@ var cloneBugReport = async ({
       console.warn("Unable to read package name for renaming:", error);
     }
   }
-  fs39.writeFileSync(path40.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+  fs40.writeFileSync(path41.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
   generateTsConfig(dirPath);
-  const relativeDirPath = path40.relative(originalCwd, dirPath);
+  const relativeDirPath = path41.relative(originalCwd, dirPath);
   console.log(kleur_default.green(`
 Successfully cloned bug report to:`));
   console.log(`  ${dirPath}/
@@ -82670,7 +83029,7 @@ var registerClone = (program2) => {
     const [, author, packageName] = match;
     console.log(`Cloning ${author}/${packageName}...`);
     const userSettingToIncludeAuthor = options.includeAuthor || cliConfig.get("alwaysCloneWithAuthorName");
-    const dirPath = userSettingToIncludeAuthor ? path41.resolve(`${author}.${packageName}`) : path41.resolve(packageName);
+    const dirPath = userSettingToIncludeAuthor ? path42.resolve(`${author}.${packageName}`) : path42.resolve(packageName);
     await handleExistingDirectory(dirPath);
     const ky2 = getRegistryApiKy();
     let packageFileList = {
@@ -82691,13 +83050,13 @@ var registerClone = (program2) => {
       console.error("Failed to fetch package files:", error instanceof Error ? error.message : error);
       process.exit(1);
     }
-    fs40.mkdirSync(dirPath, { recursive: true });
+    fs41.mkdirSync(dirPath, { recursive: true });
     for (const fileInfo of packageFileList.package_files) {
       const filePath = fileInfo.file_path.replace(/^\/+/, "");
       if (!filePath)
         continue;
-      const fullPath = path41.join(dirPath, filePath);
-      fs40.mkdirSync(path41.dirname(fullPath), { recursive: true });
+      const fullPath = path42.join(dirPath, filePath);
+      fs41.mkdirSync(path42.dirname(fullPath), { recursive: true });
       try {
         const fileContent = await ky2.get("package_files/get", {
           searchParams: {
@@ -82708,14 +83067,14 @@ var registerClone = (program2) => {
         }).json();
         const { is_text: isText, content_text: contentText } = fileContent.package_file;
         if (isText && typeof contentText === "string") {
-          fs40.writeFileSync(fullPath, contentText);
+          fs41.writeFileSync(fullPath, contentText);
         } else if (!isText) {
           const fileBuffer = await ky2.get("package_files/download", {
             searchParams: {
               package_file_id: fileContent.package_file.package_file_id
             }
           }).arrayBuffer();
-          fs40.writeFileSync(fullPath, Buffer.from(fileBuffer));
+          fs41.writeFileSync(fullPath, Buffer.from(fileBuffer));
         } else {
           console.warn(`Skipping ${filePath} due to empty content.`);
         }
@@ -82723,10 +83082,10 @@ var registerClone = (program2) => {
         console.warn(`Skipping ${filePath} due to error:`, error instanceof Error ? error.message : error);
       }
     }
-    fs40.writeFileSync(path41.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+    fs41.writeFileSync(path42.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
     generateTsConfig(dirPath);
     await setupTsciProject(dirPath);
-    const relativeDirPath = path41.relative(originalCwd, dirPath);
+    const relativeDirPath = path42.relative(originalCwd, dirPath);
     console.log(kleur_default.green(`
 Successfully cloned to:`));
     console.log(`  ${dirPath}/
@@ -82793,8 +83152,8 @@ var registerConfigSet = (program2) => {
 };
 
 // cli/convert/register.ts
-import fs41 from "node:fs/promises";
-import path42 from "node:path";
+import fs42 from "node:fs/promises";
+import path43 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -82915,15 +83274,15 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program2) => {
   program2.command("convert").description("Convert a .kicad_mod footprint to a tscircuit component").argument("<file>", "Path to the .kicad_mod file").option("-o, --output <path>", "Output TSX file path").option("-n, --name <component>", "Component name for export").action(async (file, options) => {
     try {
-      const inputPath = path42.resolve(file);
-      const modContent = await fs41.readFile(inputPath, "utf-8");
+      const inputPath = path43.resolve(file);
+      const modContent = await fs42.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path42.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path43.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path42.resolve(options.output) : path42.join(path42.dirname(inputPath), `${componentName}.tsx`);
-      await fs41.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path43.resolve(options.output) : path43.join(path43.dirname(inputPath), `${componentName}.tsx`);
+      await fs42.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
       console.error(kleur_default.red("Failed to convert footprint:"), error instanceof Error ? error.message : error);
@@ -82933,13 +83292,13 @@ var registerConvert = (program2) => {
 };
 
 // cli/dev/register.ts
-import * as fs48 from "node:fs";
+import * as fs49 from "node:fs";
 import * as net from "node:net";
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 
 // lib/server/createHttpServer.ts
 import * as http from "node:http";
-import * as fs43 from "node:fs";
+import * as fs44 from "node:fs";
 
 // node_modules/winterspec/dist/edge/transform-to-node.js
 var import_node_utils = __toESM2(require_dist5(), 1);
@@ -83641,10 +84000,10 @@ var databaseSchema = z5.object({
   files: z5.array(fileSchema).default([]),
   events: z5.array(eventSchema).default([])
 });
-function normalizePath(path43) {
-  if (!path43 || path43 === "/")
+function normalizePath(path44) {
+  if (!path44 || path44 === "/")
     return "";
-  let normalized = path43.replace(/\\+/g, "/").replace(/\/\/+/, "/");
+  let normalized = path44.replace(/\\+/g, "/").replace(/\/\/+/, "/");
   if (normalized.startsWith("/")) {
     normalized = normalized.slice(1);
   }
@@ -84501,14 +84860,14 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 };
 
 // lib/server/kicad-pcm-proxy.ts
-import * as fs42 from "node:fs";
-import * as path43 from "node:path";
+import * as fs43 from "node:fs";
+import * as path44 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 stat = fs42.statSync(path43.join(projectDir, file));
+      const stat = fs43.statSync(path44.join(projectDir, file));
       checksum += `${file}:${stat.mtimeMs};`;
     } catch {}
   }
@@ -84528,9 +84887,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url, res) => {
     const requestedFile = url.pathname.replace(/^\/pcm\/?/, "") || "repository.json";
-    const distDir = path43.join(projectDir, "dist");
-    const pcmDir = path43.join(distDir, "pcm");
-    const filePath = path43.join(pcmDir, requestedFile);
+    const distDir = path44.join(projectDir, "dist");
+    const pcmDir = path44.join(distDir, "pcm");
+    const filePath = path44.join(pcmDir, requestedFile);
     const currentChecksum = getSourceFilesChecksum(projectDir);
     const needsRebuild = currentChecksum !== pcmState.lastFileChecksum;
     if (needsRebuild) {
@@ -84575,12 +84934,12 @@ Rebuilding KiCad PCM assets...`));
         }
       }
     }
-    if (!fs42.existsSync(filePath)) {
+    if (!fs43.existsSync(filePath)) {
       res.writeHead(404);
       res.end(`PCM file not found: ${requestedFile}`);
       return;
     }
-    const ext = path43.extname(filePath).toLowerCase();
+    const ext = path44.extname(filePath).toLowerCase();
     let contentType = "application/octet-stream";
     if (ext === ".json") {
       contentType = "application/json";
@@ -84588,7 +84947,7 @@ Rebuilding KiCad PCM assets...`));
       contentType = "application/zip";
     }
     try {
-      const content = fs42.readFileSync(filePath);
+      const content = fs43.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch (error) {
@@ -84621,7 +84980,7 @@ var createHttpServer = async ({
         return;
       }
       try {
-        const content = fs43.readFileSync(standaloneFilePath, "utf8");
+        const content = fs44.readFileSync(standaloneFilePath, "utf8");
         res.writeHead(200, {
           "Content-Type": "application/javascript; charset=utf-8"
         });
@@ -84712,8 +85071,8 @@ class EventsWatcher extends EventEmitter {
 }
 
 // cli/dev/DevServer.ts
-import path48 from "node:path";
-import fs46 from "node:fs";
+import path49 from "node:path";
+import fs47 from "node:fs";
 
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -84792,7 +85151,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path44) => statMethod(path44, { bigint: true });
+      this._stat = (path45) => statMethod(path45, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -84817,8 +85176,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path44, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path44));
+          const { path: path45, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path45));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -84858,20 +85217,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path44, depth) {
+  async _exploreDir(path45, depth) {
     let files;
     try {
-      files = await readdir(path44, this._rdOptions);
+      files = await readdir(path45, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path44 };
+    return { files, depth, path: path45 };
   }
-  async _formatEntry(dirent, path44) {
+  async _formatEntry(dirent, path45) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path44, basename4));
+      const fullPath = presolve(pjoin(path45, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -85269,16 +85628,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path44, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path45, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path44);
-    emitRaw(rawEvent, evPath, { watchedPath: path44 });
-    if (evPath && path44 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path44, evPath), KEY_LISTENERS, sysPath.join(path44, evPath));
+    listener(path45);
+    emitRaw(rawEvent, evPath, { watchedPath: path45 });
+    if (evPath && path45 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path45, evPath), KEY_LISTENERS, sysPath.join(path45, evPath));
     }
   };
   try {
-    return fs_watch(path44, {
+    return fs_watch(path45, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -85294,12 +85653,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path44, fullPath, options, handlers) => {
+var setFsWatchListener = (path45, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path44, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path45, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -85309,7 +85668,7 @@ var setFsWatchListener = (path44, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path44, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path45, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -85318,7 +85677,7 @@ var setFsWatchListener = (path44, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path44, "r");
+          const fd = await open(path45, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -85348,7 +85707,7 @@ var setFsWatchListener = (path44, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path44, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path45, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -85370,7 +85729,7 @@ var setFsWatchFileListener = (path44, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path44, curr));
+          foreach(cont.listeners, (listener2) => listener2(path45, curr));
         }
       })
     };
@@ -85393,13 +85752,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path44, listener) {
+  _watchWithNodeFs(path45, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path44);
-    const basename5 = sysPath.basename(path44);
+    const directory = sysPath.dirname(path45);
+    const basename5 = sysPath.basename(path45);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sysPath.resolve(path44);
+    const absolutePath = sysPath.resolve(path45);
     const options = {
       persistent: opts.persistent
     };
@@ -85409,12 +85768,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path44, absolutePath, options, {
+      closer = setFsWatchFileListener(path45, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path44, absolutePath, options, {
+      closer = setFsWatchListener(path45, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -85432,7 +85791,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path44, newStats) => {
+    const listener = async (path45, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -85446,11 +85805,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path44);
+            this.fsw._closeFile(path45);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path44, closer2);
+              this.fsw._addPathCloser(path45, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -85474,7 +85833,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path44, item) {
+  async _handleSymlink(entry, directory, path45, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -85484,7 +85843,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path44);
+        linkPath = await fsrealpath(path45);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -85494,12 +85853,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, path44, entry.stats);
+          this.fsw._emit(EV.CHANGE, path45, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path44, entry.stats);
+        this.fsw._emit(EV.ADD, path45, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -85528,9 +85887,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path44 = sysPath.join(directory, item);
+      let path45 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path44, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path45, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -85539,8 +85898,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path44 = sysPath.join(dir, sysPath.relative(dir, path44));
-        this._addToNodeFs(path44, initialAdd, wh, depth + 1);
+        path45 = sysPath.join(dir, sysPath.relative(dir, path45));
+        this._addToNodeFs(path45, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve7, reject) => {
@@ -85589,13 +85948,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path44, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path45, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path44) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path45) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path44);
+    const wh = this.fsw._getWatchHelpers(path45);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -85611,8 +85970,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path44);
-        const targetPath = follow ? await fsrealpath(path44) : path44;
+        const absPath = sysPath.resolve(path45);
+        const targetPath = follow ? await fsrealpath(path45) : path45;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -85622,29 +85981,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path44) : path44;
+        const targetPath = follow ? await fsrealpath(path45) : path45;
         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, path44, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path45, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path44), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path45), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path44, closer);
+        this.fsw._addPathCloser(path45, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path44;
+        return path45;
       }
     }
   }
@@ -85687,26 +86046,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path44) {
-  if (typeof path44 !== "string")
+function normalizePath2(path45) {
+  if (typeof path45 !== "string")
     throw new Error("string expected");
-  path44 = sysPath2.normalize(path44);
-  path44 = path44.replace(/\\/g, "/");
+  path45 = sysPath2.normalize(path45);
+  path45 = path45.replace(/\\/g, "/");
   let prepend = false;
-  if (path44.startsWith("//"))
+  if (path45.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path44.match(DOUBLE_SLASH_RE2))
-    path44 = path44.replace(DOUBLE_SLASH_RE2, "/");
+  while (path45.match(DOUBLE_SLASH_RE2))
+    path45 = path45.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path44 = "/" + path44;
-  return path44;
+    path45 = "/" + path45;
+  return path45;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path44 = normalizePath2(testString);
+  const path45 = normalizePath2(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path44, stats)) {
+    if (pattern(path45, stats)) {
       return true;
     }
   }
@@ -85746,19 +86105,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path44) => toUnix(sysPath2.normalize(toUnix(path44)));
-var normalizeIgnored = (cwd = "") => (path44) => {
-  if (typeof path44 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path44) ? path44 : sysPath2.join(cwd, path44));
+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));
   } else {
-    return path44;
+    return path45;
   }
 };
-var getAbsolutePath = (path44, cwd) => {
-  if (sysPath2.isAbsolute(path44)) {
-    return path44;
+var getAbsolutePath = (path45, cwd) => {
+  if (sysPath2.isAbsolute(path45)) {
+    return path45;
   }
-  return sysPath2.join(cwd, path44);
+  return sysPath2.join(cwd, path45);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -85815,10 +86174,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path44, follow, fsw) {
+  constructor(path45, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path44;
-    this.path = path44 = path44.replace(REPLACER_RE, "");
+    const watchPath = path45;
+    this.path = path45 = path45.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -85931,20 +86290,20 @@ class FSWatcher extends EventEmitter2 {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path44) => {
-        const absPath = getAbsolutePath(path44, cwd);
+      paths = paths.map((path45) => {
+        const absPath = getAbsolutePath(path45, cwd);
         return absPath;
       });
     }
-    paths.forEach((path44) => {
-      this._removeIgnoredPath(path44);
+    paths.forEach((path45) => {
+      this._removeIgnoredPath(path45);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path44) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path44, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path45) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path45, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -85963,17 +86322,17 @@ class FSWatcher extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path44) => {
-      if (!sysPath2.isAbsolute(path44) && !this._closers.has(path44)) {
+    paths.forEach((path45) => {
+      if (!sysPath2.isAbsolute(path45) && !this._closers.has(path45)) {
         if (cwd)
-          path44 = sysPath2.join(cwd, path44);
-        path44 = sysPath2.resolve(path44);
+          path45 = sysPath2.join(cwd, path45);
+        path45 = sysPath2.resolve(path45);
       }
-      this._closePath(path44);
-      this._addIgnoredPath(path44);
-      if (this._watched.has(path44)) {
+      this._closePath(path45);
+      this._addIgnoredPath(path45);
+      if (this._watched.has(path45)) {
         this._addIgnoredPath({
-          path: path44,
+          path: path45,
           recursive: true
         });
       }
@@ -86022,38 +86381,38 @@ class FSWatcher extends EventEmitter2 {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, ...args);
   }
-  async _emit(event, path44, stats) {
+  async _emit(event, path45, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path44 = sysPath2.normalize(path44);
+      path45 = sysPath2.normalize(path45);
     if (opts.cwd)
-      path44 = sysPath2.relative(opts.cwd, path44);
-    const args = [event, path44];
+      path45 = sysPath2.relative(opts.cwd, path45);
+    const args = [event, path45];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path44))) {
+    if (awf && (pw = this._pendingWrites.get(path45))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path44, args);
+        this._pendingUnlinks.set(path45, args);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path45) => {
+          this._pendingUnlinks.forEach((entry, path46) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path45);
+            this._pendingUnlinks.delete(path46);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path44)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path45)) {
         event = args[0] = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path44);
+        this._pendingUnlinks.delete(path45);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -86071,16 +86430,16 @@ class FSWatcher extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path44, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path45, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path44, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path45, 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, path44) : path44;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path45) : path45;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -86099,23 +86458,23 @@ class FSWatcher extends EventEmitter2 {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path44, timeout2) {
+  _throttle(actionType, path45, 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(path44);
+    const actionPath = action.get(path45);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path44);
+      const item = action.get(path45);
       const count = item ? item.count : 0;
-      action.delete(path44);
+      action.delete(path45);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -86123,50 +86482,50 @@ class FSWatcher extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout2);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path44, thr);
+    action.set(path45, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path44, threshold, event, awfEmit) {
+  _awaitWriteFinish(path45, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path44;
-    if (this.options.cwd && !sysPath2.isAbsolute(path44)) {
-      fullPath = sysPath2.join(this.options.cwd, path44);
+    let fullPath = path45;
+    if (this.options.cwd && !sysPath2.isAbsolute(path45)) {
+      fullPath = sysPath2.join(this.options.cwd, path45);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path44)) {
+        if (err || !writes.has(path45)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path44).lastChange = now2;
+          writes.get(path45).lastChange = now2;
         }
-        const pw = writes.get(path44);
+        const pw = writes.get(path45);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path44);
+          writes.delete(path45);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path44)) {
-      writes.set(path44, {
+    if (!writes.has(path45)) {
+      writes.set(path45, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path44);
+          writes.delete(path45);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -86174,8 +86533,8 @@ class FSWatcher extends EventEmitter2 {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path44, stats) {
-    if (this.options.atomic && DOT_RE.test(path44))
+  _isIgnored(path45, stats) {
+    if (this.options.atomic && DOT_RE.test(path45))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -86185,13 +86544,13 @@ class FSWatcher extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path44, stats);
+    return this._userIgnored(path45, stats);
   }
-  _isntIgnored(path44, stat4) {
-    return !this._isIgnored(path44, stat4);
+  _isntIgnored(path45, stat4) {
+    return !this._isIgnored(path45, stat4);
   }
-  _getWatchHelpers(path44) {
-    return new WatchHelper(path44, this.options.followSymlinks, this);
+  _getWatchHelpers(path45) {
+    return new WatchHelper(path45, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -86205,57 +86564,57 @@ class FSWatcher extends EventEmitter2 {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory2) {
-    const path44 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path44);
-    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path44) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path44, 100))
+    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))
       return;
     if (!isDirectory2 && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path44);
+    const wp = this._getWatchedDir(path45);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path44, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path45, 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 = path44;
+    let relPath = path45;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path44);
+      relPath = sysPath2.relative(this.options.cwd, path45);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path44);
+    this._watched.delete(path45);
     this._watched.delete(fullPath);
     const eventName = isDirectory2 ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path44))
-      this._emit(eventName, path44);
-    this._closePath(path44);
+    if (wasTracked && !this._isIgnored(path45))
+      this._emit(eventName, path45);
+    this._closePath(path45);
   }
-  _closePath(path44) {
-    this._closeFile(path44);
-    const dir = sysPath2.dirname(path44);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path44));
+  _closePath(path45) {
+    this._closeFile(path45);
+    const dir = sysPath2.dirname(path45);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path45));
   }
-  _closeFile(path44) {
-    const closers = this._closers.get(path44);
+  _closeFile(path45) {
+    const closers = this._closers.get(path45);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path44);
+    this._closers.delete(path45);
   }
-  _addPathCloser(path44, closer) {
+  _addPathCloser(path45, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path44);
+    let list = this._closers.get(path45);
     if (!list) {
       list = [];
-      this._closers.set(path44, list);
+      this._closers.set(path45, list);
     }
     list.push(closer);
   }
@@ -86285,8 +86644,8 @@ function watch(paths, options = {}) {
 
 // lib/shared/push-snippet.ts
 var import_semver3 = __toESM2(require_semver2(), 1);
-import * as fs44 from "node:fs";
-import * as path46 from "node:path";
+import * as fs45 from "node:fs";
+import * as path47 from "node:path";
 import Debug2 from "debug";
 
 // lib/utils/validate-package-name.ts
@@ -86304,7 +86663,7 @@ var validatePackageName = (name) => {
 };
 
 // cli/dev/get-package-file-paths.ts
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 var getPackageFilePaths = (projectDir, ignored = []) => {
   const ignorePatterns = [
     ...DEFAULT_IGNORED_PATTERNS,
@@ -86315,7 +86674,7 @@ var getPackageFilePaths = (projectDir, ignored = []) => {
     ignore: ignorePatterns
   });
   fileNames.sort();
-  return fileNames.map((fileName) => path44.join(projectDir, fileName));
+  return fileNames.map((fileName) => path45.join(projectDir, fileName));
 };
 
 // lib/utils/check-org-access.ts
@@ -86331,7 +86690,7 @@ var checkOrgAccess = async (ky2, orgTscircuitHandle) => {
 };
 
 // lib/shared/is-binary-file.ts
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 var BINARY_FILE_EXTENSIONS = new Set([
   ".glb",
   ".gltf",
@@ -86347,7 +86706,7 @@ var BINARY_FILE_EXTENSIONS = new Set([
   ".tar"
 ]);
 var isBinaryFile = (filePath) => {
-  const ext = path45.extname(filePath).toLowerCase();
+  const ext = path46.extname(filePath).toLowerCase();
   return BINARY_FILE_EXTENSIONS.has(ext);
 };
 
@@ -86373,8 +86732,8 @@ var debug2 = Debug2("tsci:push-snippet");
 var getArchivePayload = async (filePaths, projectDir, packageNameWithVersion) => {
   const zip = new import_jszip3.default;
   for (const fullFilePath of filePaths) {
-    const relativeFilePath = path46.relative(projectDir, fullFilePath);
-    zip.file(relativeFilePath, fs44.readFileSync(fullFilePath));
+    const relativeFilePath = path47.relative(projectDir, fullFilePath);
+    zip.file(relativeFilePath, fs45.readFileSync(fullFilePath));
   }
   const archive = await zip.generateAsync({
     type: "uint8array",
@@ -86411,24 +86770,24 @@ var pushSnippet = async ({
     return onExit(1);
   }
   const packageJsonPath = [
-    path46.resolve(path46.join(path46.dirname(snippetFilePath), "package.json")),
-    path46.resolve(path46.join(process.cwd(), "package.json"))
-  ].find((path47) => fs44.existsSync(path47));
-  const projectDir = packageJsonPath ? path46.dirname(packageJsonPath) : path46.dirname(snippetFilePath);
+    path47.resolve(path47.join(path47.dirname(snippetFilePath), "package.json")),
+    path47.resolve(path47.join(process.cwd(), "package.json"))
+  ].find((path48) => fs45.existsSync(path48));
+  const projectDir = packageJsonPath ? path47.dirname(packageJsonPath) : path47.dirname(snippetFilePath);
   if (!packageJsonPath) {
     onError("No package.json found, try running 'tsci init' to bootstrap the project");
     return onExit(1);
   }
   let packageJson = {};
-  if (fs44.existsSync(packageJsonPath)) {
+  if (fs45.existsSync(packageJsonPath)) {
     try {
-      packageJson = JSON.parse(fs44.readFileSync(packageJsonPath).toString());
+      packageJson = JSON.parse(fs45.readFileSync(packageJsonPath).toString());
     } catch {
       onError("Invalid package.json");
       return onExit(1);
     }
   }
-  if (!fs44.existsSync(snippetFilePath)) {
+  if (!fs45.existsSync(snippetFilePath)) {
     onError(`File not found: ${snippetFilePath}`);
     return onExit(1);
   }
@@ -86469,7 +86828,7 @@ var pushSnippet = async ({
     }
     unscopedPackageName = inputName;
     packageJson.name = `@tsci/${currentUsername}.${unscopedPackageName}`;
-    fs44.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    fs45.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
   }
   let accountName = currentUsername;
   if (packageJsonAuthor && currentUsername !== packageJsonAuthor) {
@@ -86500,7 +86859,7 @@ var pushSnippet = async ({
   const updatePackageJsonVersion = (newVersion) => {
     try {
       packageJson.version = newVersion ?? `${packageVersion}`;
-      fs44.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      fs45.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
     } catch (error) {
       onError(`Failed to update package.json version: ${error}`);
     }
@@ -86608,7 +86967,7 @@ var pushSnippet = async ({
         json: archivePayload
       });
       for (const fullFilePath of filePaths) {
-        const relativeFilePath = path46.relative(projectDir, fullFilePath);
+        const relativeFilePath = path47.relative(projectDir, fullFilePath);
         uploadResults.succeeded.push(relativeFilePath);
       }
       log(kleur_default.gray(`\uD83D\uDCE6 Uploaded archive with ${filePaths.length} files`));
@@ -86618,8 +86977,8 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path46.relative(projectDir, fullFilePath);
-      const fileBuffer = fs44.readFileSync(fullFilePath);
+      const relativeFilePath = path47.relative(projectDir, fullFilePath);
+      const fileBuffer = fs45.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
         file_path: relativeFilePath,
@@ -86690,16 +87049,16 @@ import Debug3 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts from "typescript";
-import * as path47 from "path";
-import * as fs45 from "fs";
+import * as path48 from "path";
+import * as fs46 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path47.join(projectDir, "package.json");
+  const packageJsonPath = path48.join(projectDir, "package.json");
   const allPackages = new Set;
-  if (!fs45.existsSync(packageJsonPath)) {
+  if (!fs46.existsSync(packageJsonPath)) {
     return allPackages;
   }
   try {
-    const packageJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
     const deps = packageJson.dependencies || {};
     const devDeps = packageJson.devDependencies || {};
     for (const packageName of Object.keys(deps)) {
@@ -86714,11 +87073,11 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path47.resolve(filePath);
-  if (!fs45.existsSync(absolutePath)) {
+  const absolutePath = path48.resolve(filePath);
+  if (!fs46.existsSync(absolutePath)) {
     return [];
   }
-  const content = fs45.readFileSync(absolutePath, "utf-8");
+  const content = fs46.readFileSync(absolutePath, "utf-8");
   const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
   const imports = new Set;
   function visit(node) {
@@ -86768,17 +87127,17 @@ function resolveNodeModuleImport({
 }) {
   const packageName = getPackageNameFromImport(importPath);
   const searchPaths = [
-    path47.join(projectDir, "node_modules", packageName)
+    path48.join(projectDir, "node_modules", packageName)
   ];
   if (searchFromDir) {
-    let currentDir = path47.dirname(searchFromDir);
-    const projectDirNormalized = path47.normalize(projectDir);
+    let currentDir = path48.dirname(searchFromDir);
+    const projectDirNormalized = path48.normalize(projectDir);
     while (currentDir.startsWith(projectDirNormalized)) {
-      const candidatePath = path47.join(currentDir, "node_modules", packageName);
+      const candidatePath = path48.join(currentDir, "node_modules", packageName);
       if (!searchPaths.includes(candidatePath)) {
         searchPaths.push(candidatePath);
       }
-      const parentDir = path47.dirname(currentDir);
+      const parentDir = path48.dirname(currentDir);
       if (parentDir === currentDir)
         break;
       currentDir = parentDir;
@@ -86786,7 +87145,7 @@ function resolveNodeModuleImport({
   }
   let packageDir;
   for (const candidatePath of searchPaths) {
-    if (fs45.existsSync(candidatePath)) {
+    if (fs46.existsSync(candidatePath)) {
       packageDir = candidatePath;
       break;
     }
@@ -86794,25 +87153,25 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path47.join(packageDir, "package.json");
-  const hasPackageJson = fs45.existsSync(packageJsonPath);
-  const packageJson = hasPackageJson ? JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8")) : null;
+  const packageJsonPath = path48.join(packageDir, "package.json");
+  const hasPackageJson = fs46.existsSync(packageJsonPath);
+  const packageJson = hasPackageJson ? JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8")) : null;
   const resolvedFiles = [];
   if (importPath !== packageName) {
     const subpath = importPath.slice(packageName.length + 1);
     const possiblePaths = [
-      path47.join(packageDir, subpath),
-      path47.join(packageDir, `${subpath}.js`),
-      path47.join(packageDir, `${subpath}.mjs`),
-      path47.join(packageDir, `${subpath}.ts`),
-      path47.join(packageDir, `${subpath}.tsx`),
-      path47.join(packageDir, subpath, "index.js"),
-      path47.join(packageDir, subpath, "index.mjs"),
-      path47.join(packageDir, subpath, "index.ts"),
-      path47.join(packageDir, subpath, "index.tsx")
+      path48.join(packageDir, subpath),
+      path48.join(packageDir, `${subpath}.js`),
+      path48.join(packageDir, `${subpath}.mjs`),
+      path48.join(packageDir, `${subpath}.ts`),
+      path48.join(packageDir, `${subpath}.tsx`),
+      path48.join(packageDir, subpath, "index.js"),
+      path48.join(packageDir, subpath, "index.mjs"),
+      path48.join(packageDir, subpath, "index.ts"),
+      path48.join(packageDir, subpath, "index.tsx")
     ];
     for (const p of possiblePaths) {
-      if (fs45.existsSync(p) && fs45.statSync(p).isFile()) {
+      if (fs46.existsSync(p) && fs46.statSync(p).isFile()) {
         resolvedFiles.push(p);
         break;
       }
@@ -86844,25 +87203,25 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path47.join(packageDir, entry);
-    if (fs45.existsSync(entryPath) && fs45.statSync(entryPath).isFile()) {
+    const entryPath = path48.join(packageDir, entry);
+    if (fs46.existsSync(entryPath) && fs46.statSync(entryPath).isFile()) {
       resolvedFiles.push(entryPath);
     }
   }
   if (resolvedFiles.length === 0) {
     const fallbackPaths = [
-      path47.join(packageDir, "index.js"),
-      path47.join(packageDir, "index.mjs"),
-      path47.join(packageDir, "index.ts"),
-      path47.join(packageDir, "index.tsx"),
-      path47.join(packageDir, "dist", "index.js"),
-      path47.join(packageDir, "dist", "index.mjs"),
-      path47.join(packageDir, "lib", "index.js"),
-      path47.join(packageDir, "src", "index.ts"),
-      path47.join(packageDir, "src", "index.tsx")
+      path48.join(packageDir, "index.js"),
+      path48.join(packageDir, "index.mjs"),
+      path48.join(packageDir, "index.ts"),
+      path48.join(packageDir, "index.tsx"),
+      path48.join(packageDir, "dist", "index.js"),
+      path48.join(packageDir, "dist", "index.mjs"),
+      path48.join(packageDir, "lib", "index.js"),
+      path48.join(packageDir, "src", "index.ts"),
+      path48.join(packageDir, "src", "index.tsx")
     ];
     for (const p of fallbackPaths) {
-      if (fs45.existsSync(p) && fs45.statSync(p).isFile()) {
+      if (fs46.existsSync(p) && fs46.statSync(p).isFile()) {
         resolvedFiles.push(p);
         break;
       }
@@ -86900,12 +87259,12 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path47.resolve(filePath);
-    const baseDir = path47.dirname(absolutePath);
-    if (!fs45.existsSync(absolutePath)) {
+    const absolutePath = path48.resolve(filePath);
+    const baseDir = path48.dirname(absolutePath);
+    if (!fs46.existsSync(absolutePath)) {
       return [];
     }
-    const content = fs45.readFileSync(absolutePath, "utf-8");
+    const content = fs46.readFileSync(absolutePath, "utf-8");
     const sourceFile = ts.createSourceFile(absolutePath, content, ts.ScriptTarget.Latest, true);
     const dependencies2 = [];
     function visit(node) {
@@ -86927,20 +87286,20 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path47.resolve(baseDir, importPath);
-    if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isFile()) {
+    const resolvedPath = path48.resolve(baseDir, importPath);
+    if (fs46.existsSync(resolvedPath) && fs46.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
     for (const ext of extensions) {
       const pathWithExt = resolvedPath + ext;
-      if (fs45.existsSync(pathWithExt)) {
+      if (fs46.existsSync(pathWithExt)) {
         return pathWithExt;
       }
     }
-    if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isDirectory()) {
+    if (fs46.existsSync(resolvedPath) && fs46.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path47.join(resolvedPath, `index${ext}`);
-        if (fs45.existsSync(indexPath)) {
+        const indexPath = path48.join(resolvedPath, `index${ext}`);
+        if (fs46.existsSync(indexPath)) {
           return indexPath;
         }
       }
@@ -86965,12 +87324,12 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path47.join(packageDir, dirName);
-    if (fs45.existsSync(dirPath)) {
+    const dirPath = path48.join(packageDir, dirName);
+    if (fs46.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path47.join(packageDir, "package.json");
-        if (fs45.existsSync(packageJsonPath)) {
+        const packageJsonPath = path48.join(packageDir, "package.json");
+        if (fs46.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
         return files;
@@ -86981,11 +87340,11 @@ function collectLocalPackageFiles(packageDir) {
 }
 function walkDirectory(dir, excludedDirs) {
   const files = [];
-  if (!fs45.existsSync(dir))
+  if (!fs46.existsSync(dir))
     return files;
-  const entries = fs45.readdirSync(dir, { withFileTypes: true });
+  const entries = fs46.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path47.join(dir, entry.name);
+    const fullPath = path48.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirs.has(entry.name)) {
         continue;
@@ -87046,13 +87405,13 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
       processedPackages.add(packageName);
       if (resolvedFiles.length > 0) {
         const firstResolvedFile = resolvedFiles[0];
-        let packageDir = path47.dirname(firstResolvedFile);
+        let packageDir = path48.dirname(firstResolvedFile);
         let hasPackageJson = false;
         while (packageDir.includes("node_modules")) {
-          const packageJsonPath = path47.join(packageDir, "package.json");
-          if (fs45.existsSync(packageJsonPath)) {
+          const packageJsonPath = path48.join(packageDir, "package.json");
+          if (fs46.existsSync(packageJsonPath)) {
             try {
-              const pkgJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+              const pkgJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
               if (pkgJson.name === packageName) {
                 hasPackageJson = true;
                 break;
@@ -87060,15 +87419,15 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
             } catch {}
           }
           const expectedPackagePath = packageName.startsWith("@") ? `node_modules/${packageName}` : `node_modules/${packageName}`;
-          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path47.sep))) {
+          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path48.sep))) {
             break;
           }
-          const parentDir = path47.dirname(packageDir);
+          const parentDir = path48.dirname(packageDir);
           if (parentDir === packageDir)
             break;
           packageDir = parentDir;
         }
-        if (fs45.existsSync(packageDir)) {
+        if (fs46.existsSync(packageDir)) {
           if (hasPackageJson) {
             const packageFiles = collectLocalPackageFiles(packageDir);
             packageFiles.forEach((file) => allFiles.add(file));
@@ -87113,7 +87472,7 @@ class DevServer {
   }) {
     this.port = port;
     this.componentFilePath = componentFilePath;
-    this.projectDir = projectDir ?? path48.dirname(componentFilePath);
+    this.projectDir = projectDir ?? path49.dirname(componentFilePath);
     this.kicadPcm = kicadPcm ?? false;
     const projectConfig = loadProjectConfig(this.projectDir);
     this.ignoredFiles = projectConfig?.ignoredFiles ?? [];
@@ -87124,7 +87483,7 @@ class DevServer {
   async start() {
     const { server } = await createHttpServer({
       port: this.port,
-      defaultMainComponentPath: path48.relative(this.projectDir, this.componentFilePath),
+      defaultMainComponentPath: path49.relative(this.projectDir, this.componentFilePath),
       kicadPcm: this.kicadPcm,
       projectDir: this.projectDir,
       entryFile: this.componentFilePath
@@ -87140,7 +87499,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p) => shouldIgnorePath(path48.relative(this.projectDir, p), this.ignoredFiles)
+      ignored: (p) => shouldIgnorePath(path49.relative(this.projectDir, p), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -87155,27 +87514,27 @@ class DevServer {
     const { file } = await this.fsKy.get("api/files/get", {
       searchParams: { file_path: ev.file_path }
     }).json();
-    const fullPath = path48.join(this.projectDir, ev.file_path);
-    const dirPath = path48.dirname(fullPath);
-    if (!fs46.existsSync(dirPath)) {
-      fs46.mkdirSync(dirPath, { recursive: true });
+    const fullPath = path49.join(this.projectDir, ev.file_path);
+    const dirPath = path49.dirname(fullPath);
+    if (!fs47.existsSync(dirPath)) {
+      fs47.mkdirSync(dirPath, { recursive: true });
     }
     if (file.binary_content_b64) {
       const decodedContent = Buffer.from(file.binary_content_b64, "base64");
-      fs46.writeFileSync(fullPath, decodedContent);
+      fs47.writeFileSync(fullPath, decodedContent);
     } else {
-      fs46.writeFileSync(fullPath, file.text_content ?? "", "utf-8");
+      fs47.writeFileSync(fullPath, file.text_content ?? "", "utf-8");
     }
   }
   async handleFileDeletedEventFromServer(ev) {
-    const fullPath = path48.join(this.projectDir, ev.file_path);
-    if (fs46.existsSync(fullPath)) {
+    const fullPath = path49.join(this.projectDir, ev.file_path);
+    if (fs47.existsSync(fullPath)) {
       debug3(`Deleting file ${ev.file_path} from filesystem`);
-      fs46.unlinkSync(fullPath);
+      fs47.unlinkSync(fullPath);
     }
   }
   async handleFileChangedOnFilesystem(absoluteFilePath) {
-    const relativeFilePath = path48.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path49.relative(this.projectDir, absoluteFilePath);
     if (relativeFilePath.includes("manual-edits.json"))
       return;
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
@@ -87190,14 +87549,14 @@ class DevServer {
     await this.checkAndUploadNewNodeModules(absoluteFilePath);
   }
   async checkAndUploadNewNodeModules(filePath) {
-    const ext = path48.extname(filePath).toLowerCase();
+    const ext = path49.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 = path48.relative(this.projectDir, file);
+        const relativePath = path49.relative(this.projectDir, file);
         return !this.uploadedNodeModules.has(relativePath);
       });
       if (newFiles.length === 0)
@@ -87210,7 +87569,7 @@ class DevServer {
     }
   }
   async handleFileRemovedFromFilesystem(absoluteFilePath) {
-    const relativeFilePath = path48.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path49.relative(this.projectDir, absoluteFilePath);
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
       return;
     if (!relativeFilePath || relativeFilePath.trim() === "") {
@@ -87248,8 +87607,8 @@ class DevServer {
     debug3(`Successfully deleted file ${relativeFilePath} from server`);
   }
   async handleFileRename(oldPath, newPath) {
-    const oldRelativePath = path48.relative(this.projectDir, oldPath);
-    const newRelativePath = path48.relative(this.projectDir, newPath);
+    const oldRelativePath = path49.relative(this.projectDir, oldPath);
+    const newRelativePath = path49.relative(this.projectDir, newPath);
     if (shouldIgnorePath(oldRelativePath, this.ignoredFiles) || shouldIgnorePath(newRelativePath, this.ignoredFiles))
       return;
     await this.handleFileRemovedFromFilesystem(oldPath);
@@ -87267,7 +87626,7 @@ class DevServer {
     });
     const filePaths = getPackageFilePaths(this.projectDir, this.ignoredFiles);
     for (const filePath of filePaths) {
-      const relativeFilePath = path48.relative(this.projectDir, filePath);
+      const relativeFilePath = path49.relative(this.projectDir, filePath);
       const filePayload = this.createFileUploadPayload(filePath, relativeFilePath);
       await this.postFileUpsert({
         filePath: relativeFilePath,
@@ -87299,7 +87658,7 @@ class DevServer {
   }
   async uploadNodeModuleFiles(files) {
     for (const nodeModuleFile of files) {
-      const relativeFilePath = path48.relative(this.projectDir, nodeModuleFile);
+      const relativeFilePath = path49.relative(this.projectDir, nodeModuleFile);
       this.uploadedNodeModules.add(relativeFilePath);
       const filePayload = this.createFileUploadPayload(nodeModuleFile, relativeFilePath);
       await this.postFileUpsert({
@@ -87357,12 +87716,12 @@ class DevServer {
     await this.filesystemWatcher?.close();
   }
   createFileUploadPayload(absoluteFilePath, relativeFilePath) {
-    const ext = path48.extname(relativeFilePath).toLowerCase();
+    const ext = path49.extname(relativeFilePath).toLowerCase();
     if (BINARY_FILE_EXTENSIONS2.has(ext)) {
-      const fileBuffer = fs46.readFileSync(absoluteFilePath);
+      const fileBuffer = fs47.readFileSync(absoluteFilePath);
       return { binary_content_b64: fileBuffer.toString("base64") };
     }
-    return { text_content: fs46.readFileSync(absoluteFilePath, "utf-8") };
+    return { text_content: fs47.readFileSync(absoluteFilePath, "utf-8") };
   }
   async handleInstallPackage(full_package_name) {
     const postEvent = async (event, message) => {
@@ -87392,10 +87751,10 @@ class DevServer {
 }
 
 // cli/dev/resolve-dev-target.ts
-import * as fs47 from "node:fs";
-import * as path49 from "node:path";
+import * as fs48 from "node:fs";
+import * as path50 from "node:path";
 var findSelectableFiles = (projectDir) => {
-  const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs47.existsSync(file)).sort();
+  const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs48.existsSync(file)).sort();
   if (boardFiles.length > 0) {
     return boardFiles;
   }
@@ -87403,7 +87762,7 @@ var findSelectableFiles = (projectDir) => {
     cwd: projectDir,
     ignore: DEFAULT_IGNORED_PATTERNS
   });
-  return files.map((file) => path49.resolve(projectDir, file)).filter((file) => fs47.existsSync(file)).sort();
+  return files.map((file) => path50.resolve(projectDir, file)).filter((file) => fs48.existsSync(file)).sort();
 };
 var isValidDevFile = (filePath) => {
   return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
@@ -87411,18 +87770,18 @@ var isValidDevFile = (filePath) => {
 var resolveDevTarget = async (file) => {
   let projectDir = process.cwd();
   if (file) {
-    const resolvedPath = path49.resolve(file);
-    if (fs47.existsSync(resolvedPath) && fs47.statSync(resolvedPath).isDirectory()) {
+    const resolvedPath = path50.resolve(file);
+    if (fs48.existsSync(resolvedPath) && fs48.statSync(resolvedPath).isDirectory()) {
       projectDir = resolvedPath;
       const availableFiles2 = findSelectableFiles(projectDir);
       if (availableFiles2.length === 0) {
         console.log(`No .tsx, .ts, or .circuit.json files found in ${projectDir}. Run 'tsci init' to bootstrap a basic project.`);
         return null;
       }
-      console.log("Selected file:", path49.relative(projectDir, availableFiles2[0]));
+      console.log("Selected file:", path50.relative(projectDir, availableFiles2[0]));
       return { absolutePath: availableFiles2[0], projectDir };
     }
-    if (!fs47.existsSync(resolvedPath)) {
+    if (!fs48.existsSync(resolvedPath)) {
       console.error(`Error: File not found: ${file}`);
       return null;
     }
@@ -87433,7 +87792,7 @@ var resolveDevTarget = async (file) => {
     return { absolutePath: resolvedPath, projectDir };
   }
   const entrypointPath = await getEntrypoint({ onError: () => {} });
-  if (entrypointPath && fs47.existsSync(entrypointPath)) {
+  if (entrypointPath && fs48.existsSync(entrypointPath)) {
     console.log("Found entrypoint at:", entrypointPath);
     return { absolutePath: entrypointPath, projectDir };
   }
@@ -87442,7 +87801,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:", path49.relative(projectDir, availableFiles[0]));
+  console.log("Selected file:", path50.relative(projectDir, availableFiles[0]));
   return { absolutePath: availableFiles[0], projectDir };
 };
 
@@ -87458,12 +87817,12 @@ var isPortAvailable = (port) => {
   });
 };
 var warnIfTsconfigMissingTscircuitType = (projectDir) => {
-  const tsconfigPath = path50.join(projectDir, "tsconfig.json");
-  if (!fs48.existsSync(tsconfigPath)) {
+  const tsconfigPath = path51.join(projectDir, "tsconfig.json");
+  if (!fs49.existsSync(tsconfigPath)) {
     return;
   }
   try {
-    const tsconfig = JSON.parse(fs48.readFileSync(tsconfigPath, "utf-8"));
+    const tsconfig = JSON.parse(fs49.readFileSync(tsconfigPath, "utf-8"));
     const types = tsconfig?.compilerOptions?.types;
     if (!Array.isArray(types) || !types.includes("tscircuit")) {
       console.warn(kleur_default.yellow('Warning: "tscircuit" is missing from tsconfig.json compilerOptions.types. Add it (e.g. "types": ["tscircuit"]) to ensure CLI-provided types work correctly.'));
@@ -87495,7 +87854,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(path50.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(path51.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
 
 `);
     console.log(kleur_default.gray(`Watching ${kleur_default.underline(server.projectDir.split("/").slice(-2).join("/"))} for changes...`));
@@ -87523,15 +87882,15 @@ var checkLoggedIn = () => {
 
 // cli/doctor/checks/check-npmrc-registry.ts
 import { spawnSync } from "node:child_process";
-import fs49 from "node:fs";
+import fs50 from "node:fs";
 import os5 from "node:os";
-import path51 from "node:path";
+import path52 from "node:path";
 var hasBunInstalled = () => {
   const result = spawnSync("bun", ["--version"], { stdio: "ignore" });
   return result.status === 0;
 };
 var createTempProject = (tempDir) => {
-  const packageJsonPath = path51.join(tempDir, "package.json");
+  const packageJsonPath = path52.join(tempDir, "package.json");
   const packageJson = {
     name: "tsci-doctor-check",
     version: "0.0.0",
@@ -87540,7 +87899,7 @@ var createTempProject = (tempDir) => {
       "@tsci/does-not-exist": "0.0.0"
     }
   };
-  fs49.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  fs50.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
 };
 var checkGlobalNpmrcRegistry = async () => {
   const name = "Global .npmrc configured for tscircuit NPM registry?";
@@ -87551,7 +87910,7 @@ var checkGlobalNpmrcRegistry = async () => {
       details: "Bun is required to verify registry settings. Install Bun and rerun `tsci doctor`."
     };
   }
-  const tempDir = fs49.mkdtempSync(path51.join(os5.tmpdir(), "tsci-doctor-"));
+  const tempDir = fs50.mkdtempSync(path52.join(os5.tmpdir(), "tsci-doctor-"));
   try {
     createTempProject(tempDir);
     const result = spawnSync("bun", ["install"], {
@@ -87589,7 +87948,7 @@ ${result.stderr ?? ""}`;
     }
     return { name, success: true };
   } finally {
-    fs49.rmSync(tempDir, { recursive: true, force: true });
+    fs50.rmSync(tempDir, { recursive: true, force: true });
   }
 };
 
@@ -87622,8 +87981,8 @@ var registerDoctor = (program2) => {
 };
 
 // lib/shared/export-snippet.ts
-import fs50 from "node:fs";
-import path52 from "node:path";
+import fs51 from "node:fs";
+import path53 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf4 } from "circuit-json-to-gltf";
 
@@ -88696,9 +89055,9 @@ var stringifyDsnJson = (dsnJson) => {
   const stringifyCoordinates = (coordinates) => {
     return coordinates.join(" ");
   };
-  const stringifyPath = (path52, level) => {
+  const stringifyPath = (path53, level) => {
     const padding = indent.repeat(level);
-    return `${padding}(path ${path52.layer} ${path52.width}  ${stringifyCoordinates(path52.coordinates)})`;
+    return `${padding}(path ${path53.layer} ${path53.width}  ${stringifyCoordinates(path53.coordinates)})`;
   };
   result += `(pcb ${dsnJson.filename ? dsnJson.filename : "./converted_dsn.dsn"}
 `;
@@ -88880,7 +89239,7 @@ var debug10 = Debug10("dsn-converter:parse-dsn-to-dsn-json");
 
 // lib/shared/export-snippet.ts
 var import_jszip4 = __toESM2(require_lib4(), 1);
-var writeFileAsync = promisify3(fs50.writeFile);
+var writeFileAsync = promisify3(fs51.writeFile);
 var ALLOWED_EXPORT_FORMATS = [
   "json",
   "circuit-json",
@@ -88925,10 +89284,10 @@ var exportSnippet = async ({
     onError(`Invalid format: ${format}`);
     return onExit(1);
   }
-  const projectDir = path52.dirname(filePath);
-  const outputBaseName = path52.basename(filePath).replace(/\.[^.]+$/, "");
+  const projectDir = path53.dirname(filePath);
+  const outputBaseName = path53.basename(filePath).replace(/\.[^.]+$/, "");
   const outputFileName = `${outputBaseName}${OUTPUT_EXTENSIONS[format]}`;
-  const outputDestination = path52.join(projectDir, outputPath ?? outputFileName);
+  const outputDestination = path53.join(projectDir, outputPath ?? outputFileName);
   if (format === "kicad-library") {
     try {
       const result = await convertToKicadLibrary({
@@ -89125,12 +89484,12 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 };
 
 // lib/eecircuit-engine/run-simulation.ts
-import { promises as fs51, existsSync as existsSync13 } from "node:fs";
-import path53 from "node:path";
+import { promises as fs52, existsSync as existsSync13 } from "node:fs";
+import path54 from "node:path";
 import os6 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path53.join(os6.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  const tempFilePath = path54.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);
@@ -89138,7 +89497,7 @@ var fetchSimulation = async () => {
       throw new Error(`Failed to fetch eecircuit-engine from ${url}: ${response.statusText}`);
     }
     const scriptContent = await response.text();
-    await fs51.writeFile(tempFilePath, scriptContent);
+    await fs52.writeFile(tempFilePath, scriptContent);
   }
   const module2 = await import(tempFilePath);
   return module2.Simulation;
@@ -89227,8 +89586,8 @@ var resultToCsv = (result) => {
 };
 
 // cli/export/register.ts
-import path54 from "node:path";
-import { promises as fs52 } from "node:fs";
+import path55 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) => {
     const formatOption = options.format ?? "json";
@@ -89240,12 +89599,12 @@ var registerExport = (program2) => {
       });
       if (circuitJson) {
         const spiceString = getSpiceWithPaddedSim(circuitJson);
-        const outputSpicePath = options.output ?? path54.join(path54.dirname(file), `${path54.basename(file, path54.extname(file))}.spice.cir`);
-        await fs52.writeFile(outputSpicePath, spiceString);
+        const outputSpicePath = options.output ?? path55.join(path55.dirname(file), `${path55.basename(file, path55.extname(file))}.spice.cir`);
+        await fs53.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
         const outputCsvPath = outputSpicePath.replace(/\.spice\.cir$/, ".csv");
-        await fs52.writeFile(outputCsvPath, csvContent);
+        await fs53.writeFile(outputCsvPath, csvContent);
         console.log(`Exported to ${outputSpicePath} and ${outputCsvPath} (simulation results)!`);
       }
       process.exit(0);
@@ -90713,8 +91072,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params2) => {
-  const { data, path: path55, errorMaps, issueData } = params2;
-  const fullPath = [...path55, ...issueData.path || []];
+  const { data, path: path56, errorMaps, issueData } = params2;
+  const fullPath = [...path56, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -90822,11 +91181,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path55, key) {
+  constructor(parent, value, path56, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path55;
+    this._path = path56;
     this._key = key;
   }
   get path() {
@@ -99013,7 +99372,7 @@ var ss = ys;
 var ms2 = { paths: { diag1: { type: "path", points: [{ x: -0.1, y: -0.1 }, { x: 0.1, y: 0.1 }], color: "primary", fill: false }, diag2: { type: "path", points: [{ x: -0.1, y: 0.1 }, { x: 0.1, y: -0.1 }], color: "primary", fill: false }, stem: { type: "path", points: [{ x: -0.2, y: 0 }, { x: 0, y: 0 }], color: "primary", fill: false } }, texts: {}, refblocks: { left1: { x: -0.2, y: 0 } }, bounds: { minX: -0.19, maxX: 0.2, minY: -0.12, maxY: 0.12, width: 0.39, height: 0.24, centerX: 0, centerY: 0 }, circles: {} };
 var { paths: Yd, bounds: ns, refblocks: Xd } = ms2;
 var U = e({ primitives: [...Object.values(Yd)], ports: [{ ...Xd.left1, labels: ["1"] }], center: { x: ns.centerX, y: ns.centerY } }).rotateRightFacingSymbol("right").labelPort("left1", ["1"]).build();
-var fs53 = r(U, "down");
+var fs54 = r(U, "down");
 var hs = r(U, "left");
 var cs = r(U, "up");
 var g = { paths: { path11: { type: "path", points: [{ x: -0.4, y: 0 }, { x: 0.06, y: -0.01 }], color: "primary", fill: false }, "path40-0": { type: "path", points: [{ x: 0.07, y: 0.27 }, { x: 0.07, y: -0.28 }], color: "primary", fill: false }, "path40-0-5": { type: "path", points: [{ x: 0.28, y: 0.24 }, { x: 0.08, y: 0.11 }], color: "primary", fill: false }, "path40-0-5-0": { type: "path", points: [{ x: 0.29, y: -0.24 }, { x: 0.09, y: -0.11 }], color: "primary", fill: false }, "path12-1-5": { type: "path", points: [{ x: 0.29, y: 0.25 }, { x: 0.29, y: 0.55 }], color: "primary", fill: false }, "path12-1-5-3": { type: "path", points: [{ x: 0.29, y: -0.55 }, { x: 0.29, y: -0.25 }], color: "primary", fill: false }, path15: { type: "path", points: [{ x: 0.19, y: -0.1 }, { x: 0.12, y: -0.2 }, { x: 0.22, y: -0.2 }, { x: 0.19, y: -0.1 }], color: "primary", fill: true } }, texts: { top1: { type: "text", text: "{REF}", x: -0.08, y: 0.36 }, bottom1: { type: "text", text: "{VAL}", x: -0.07, y: -0.41 } }, refblocks: { top1: { x: 0.29, y: 0.55 }, bottom1: { x: 0.29, y: -0.55 }, left1: { x: -0.4, y: 0 } }, bounds: { minX: -0.43, maxX: 0.43, minY: -0.58, maxY: 0.58, width: 0.85, height: 1.16, centerX: 0, centerY: 0 }, circles: { "path1-0": { type: "circle", x: 0.14, y: 0, radius: 0.29, color: "primary", fill: false } } };
@@ -99616,7 +99975,7 @@ var jb = Il.primitives.find((t) => t.type === "text" && t.text === "{VAL}");
 Vb.anchor = "middle_left";
 jb.anchor = "middle_right";
 var tf = Il;
-var ef = { ac_voltmeter_down: Wl, ac_voltmeter_horz: Zl, ac_voltmeter_left: Kl, ac_voltmeter_right: ep, ac_voltmeter_up: op, ac_voltmeter_vert: lp, avalanche_diode_down: ap, avalanche_diode_horz: yp, avalanche_diode_left: sp, avalanche_diode_right: mp, avalanche_diode_up: fp, avalanche_diode_vert: cp, backward_diode_down: bp, backward_diode_left: Ut, backward_diode_right: up, backward_diode_up: vp, battery_horz: Zt, battery_vert: Sp, boxresistor_down: Tp, boxresistor_left: Xp, boxresistor_right: jp, boxresistor_small_down: zp, boxresistor_small_left: Jp, boxresistor_small_right: Mp, boxresistor_small_up: Np, boxresistor_up: qp, bridged_ground_down: Up, bridged_ground_left: Zp, bridged_ground_right: re, bridged_ground_up: ta, capacitor_down: ra, capacitor_left: oa, capacitor_polarized_down: la, capacitor_polarized_left: pa, capacitor_polarized_right: ya, capacitor_polarized_up: sa, capacitor_right: ma, capacitor_up: fa, constant_current_diode_down: ca, constant_current_diode_horz: da, constant_current_diode_left: _a, constant_current_diode_right: ga, constant_current_diode_up: va, constant_current_diode_vert: Aa, crystal_4pin_down: Pa, crystal_4pin_left: Sa, crystal_4pin_right: Fa, crystal_4pin_up: Ra, crystal_down: Ea, crystal_left: Ya, crystal_right: Xa, crystal_up: Va, darlington_pair_transistor_down: ja, darlington_pair_transistor_horz: ka, darlington_pair_transistor_left: za, darlington_pair_transistor_right: Oa, darlington_pair_transistor_up: Ja, darlington_pair_transistor_vert: $a, dc_ammeter_horz: Pt, dc_ammeter_vert: Ia, dc_voltmeter_down: qa, dc_voltmeter_horz: Ga, dc_voltmeter_left: Wa, dc_voltmeter_right: Za, dc_voltmeter_up: Ka, dc_voltmeter_vert: ey, diac_down: ry, diac_horz: oy, diac_left: iy, diac_right: ly, diac_up: py, diac_vert: ay, digital_ground_down: xy, digital_ground_left: my, digital_ground_right: fy, digital_ground_up: cy, diode_down: by, diode_left: _y, diode_right: C, diode_up: gy, dpdt_normally_closed_switch_down: vy, dpdt_normally_closed_switch_left: wy, dpdt_normally_closed_switch_right: N, dpdt_normally_closed_switch_up: Ay, dpdt_switch_down: Sy, dpdt_switch_left: Fy, dpdt_switch_right: I, dpdt_switch_up: Ry, dpst_normally_closed_switch_down: Ey, dpst_normally_closed_switch_left: Yy, dpst_normally_closed_switch_right: B, dpst_normally_closed_switch_up: Xy5, dpst_switch_down: Vy, dpst_switch_left: jy, dpst_switch_right: q, dpst_switch_up: ky2, ferrite_bead_down: Oy, ferrite_bead_left: Jy, ferrite_bead_right: Te, ferrite_bead_up: Re, filled_diode_down: My, filled_diode_horz: Ny, filled_diode_left: By, filled_diode_right: Dy, filled_diode_up: Uy, filled_diode_vert: Hy, frequency_meter_horz: St, frequency_meter_vert: tx, fuse_horz: Oe, fuse_vert: ox, ground_down: ix, ground_horz: lx, ground_left: px, ground_right: ax, ground_up: yx, ground_vert: xx, gunn_diode_horz: sx, gunn_diode_vert: mx, icled_down: fx, icled_left: hx, icled_right: D, icled_up: cx, igbt_transistor_horz: Je, igbt_transistor_vert: _x, illuminated_push_button_normally_open_horz: $e, illuminated_push_button_normally_open_vert: wx, inductor_down: Fx, inductor_left: Rx, inductor_right: ut, inductor_up: Ce, laser_diode_down: Tx, laser_diode_left: Ex, laser_diode_right: G, laser_diode_up: Yx, led_down: jx, led_left: kx, led_right: vt, led_up: Ie, light_dependent_resistor_horz: qe, light_dependent_resistor_vert: Cx, mosfet_depletion_normally_on_horz: Ge, mosfet_depletion_normally_on_vert: qx, mushroom_head_normally_open_momentary_horz: We, mushroom_head_normally_open_momentary_vert: Wx, n_channel_d_mosfet_transistor_horz: Qe, n_channel_d_mosfet_transistor_vert: ts2, n_channel_e_mosfet_transistor_horz: t0, n_channel_e_mosfet_transistor_vert: ls, njfet_transistor_horz: r0, njfet_transistor_vert: ss, not_connected_down: fs53, not_connected_left: hs, not_connected_right: U, not_connected_up: cs, npn_bipolar_transistor_down: ds, npn_bipolar_transistor_horz: bs, npn_bipolar_transistor_left: _s, npn_bipolar_transistor_right: gs, npn_bipolar_transistor_up: us, npn_bipolar_transistor_vert: vs, opamp_no_power_down: As, opamp_no_power_left: Ps, opamp_no_power_right: W, opamp_no_power_up: Ss, opamp_with_power_down: Rs, opamp_with_power_left: Ts, opamp_with_power_right: H, opamp_with_power_up: Es, p_channel_d_mosfet_transistor_horz: x0, p_channel_d_mosfet_transistor_vert: js, p_channel_e_mosfet_transistor_horz: m0, p_channel_e_mosfet_transistor_vert: $s, photodiode_horz: n0, photodiode_vert: Is, pjfet_transistor_horz: h0, pjfet_transistor_vert: Us, pnp_bipolar_transistor_down: Ws, pnp_bipolar_transistor_horz: Hs, pnp_bipolar_transistor_left: Zs, pnp_bipolar_transistor_right: Qs, pnp_bipolar_transistor_up: Ks, pnp_bipolar_transistor_vert: tm, potentiometer_horz: v0, potentiometer_vert: im, potentiometer2_down: ym, potentiometer2_left: xm, potentiometer2_right: Z, potentiometer2_up: sm, potentiometer3_down: mm2, potentiometer3_left: nm, potentiometer3_right: fm, potentiometer3_up: hm, power_factor_meter_horz: R0, power_factor_meter_vert: _m, push_button_normally_closed_momentary_horz: E0, push_button_normally_closed_momentary_vert: wm, push_button_normally_open_momentary_horz: X0, push_button_normally_open_momentary_vert: Fm, rail_down: Tm, rail_left: Ym, rail_right: Lm, rail_up: jm, rectifier_diode_horz: j0, rectifier_diode_vert: Om, resistor_down: $m, resistor_left: Cm, resistor_right: Im, resistor_up: qm, resonator_down: Gm, resonator_horz: N0, resonator_left: Um, resonator_right: et, resonator_up: Wm, resonator_vert: Hm, schottky_diode_down: Qm, schottky_diode_left: Km, schottky_diode_right: rt, schottky_diode_up: tn, silicon_controlled_rectifier_horz: I0, silicon_controlled_rectifier_vert: on2, solderjumper2_bridged12_down: ln, solderjumper2_bridged12_left: pn, solderjumper2_bridged12_right: an, solderjumper2_bridged12_up: yn, solderjumper2_down: xn, solderjumper2_left: sn, solderjumper2_right: mn, solderjumper2_up: nn, solderjumper3_bridged12_down: fn, solderjumper3_bridged12_left: hn, solderjumper3_bridged12_right: cn, solderjumper3_bridged12_up: dn, solderjumper3_bridged123_down: bn, solderjumper3_bridged123_left: _n, solderjumper3_bridged123_right: gn, solderjumper3_bridged123_up: un, solderjumper3_bridged23_down: vn, solderjumper3_bridged23_left: wn, solderjumper3_bridged23_right: An, solderjumper3_bridged23_up: Pn, solderjumper3_down: Sn, solderjumper3_left: Fn, solderjumper3_right: Rn, solderjumper3_up: Tn, spdt_normally_closed_switch_down: Yn, spdt_normally_closed_switch_left: Xn, spdt_normally_closed_switch_right: xt, spdt_normally_closed_switch_up: Ln, spdt_switch_down: jn, spdt_switch_left: kn, spdt_switch_right: st, spdt_switch_up: zn, spst_normally_closed_switch_down: On, spst_normally_closed_switch_left: Jn, spst_normally_closed_switch_right: mt, spst_normally_closed_switch_up: $n, spst_switch_down: Mn, spst_switch_left: Cn, spst_switch_right: nt, spst_switch_up: Nn, square_wave_down: In, square_wave_left: Bn, square_wave_right: qn, square_wave_up: Dn, step_recovery_diode_horz: B0, step_recovery_diode_vert: Gn, tachometer_horz: Yt, tachometer_vert: Zn, testpoint_down: t1, testpoint_left: e1, testpoint_right: ht, testpoint_up: i1, tilted_ground_down: p1, tilted_ground_left: a1, tilted_ground_right: wt, tilted_ground_up: D0, triac_horz: G0, triac_vert: s1, tunnel_diode_horz: W0, tunnel_diode_vert: h1, unijunction_transistor_horz: Z0, unijunction_transistor_vert: u1, usbc: w1, var_meter_horz: K0, var_meter_vert: S1, varactor_diode_horz: er, varactor_diode_vert: E1, varistor_horz: or, varistor_vert: V1, varmeter_horz: Xt, varmeter_vert: O1, vcc_down: J1, vcc_left: $1, vcc_right: M1, vcc_up: C1, volt_meter_horz: lr, volt_meter_vert: N1, watt_hour_meter_horz: Lt, watt_hour_meter_vert: D1, wattmeter_horz: Vt, wattmeter_vert: H1, zener_diode_horz: xr, zener_diode_vert: tf };
+var ef = { ac_voltmeter_down: Wl, ac_voltmeter_horz: Zl, ac_voltmeter_left: Kl, ac_voltmeter_right: ep, ac_voltmeter_up: op, ac_voltmeter_vert: lp, avalanche_diode_down: ap, avalanche_diode_horz: yp, avalanche_diode_left: sp, avalanche_diode_right: mp, avalanche_diode_up: fp, avalanche_diode_vert: cp, backward_diode_down: bp, backward_diode_left: Ut, backward_diode_right: up, backward_diode_up: vp, battery_horz: Zt, battery_vert: Sp, boxresistor_down: Tp, boxresistor_left: Xp, boxresistor_right: jp, boxresistor_small_down: zp, boxresistor_small_left: Jp, boxresistor_small_right: Mp, boxresistor_small_up: Np, boxresistor_up: qp, bridged_ground_down: Up, bridged_ground_left: Zp, bridged_ground_right: re, bridged_ground_up: ta, capacitor_down: ra, capacitor_left: oa, capacitor_polarized_down: la, capacitor_polarized_left: pa, capacitor_polarized_right: ya, capacitor_polarized_up: sa, capacitor_right: ma, capacitor_up: fa, constant_current_diode_down: ca, constant_current_diode_horz: da, constant_current_diode_left: _a, constant_current_diode_right: ga, constant_current_diode_up: va, constant_current_diode_vert: Aa, crystal_4pin_down: Pa, crystal_4pin_left: Sa, crystal_4pin_right: Fa, crystal_4pin_up: Ra, crystal_down: Ea, crystal_left: Ya, crystal_right: Xa, crystal_up: Va, darlington_pair_transistor_down: ja, darlington_pair_transistor_horz: ka, darlington_pair_transistor_left: za, darlington_pair_transistor_right: Oa, darlington_pair_transistor_up: Ja, darlington_pair_transistor_vert: $a, dc_ammeter_horz: Pt, dc_ammeter_vert: Ia, dc_voltmeter_down: qa, dc_voltmeter_horz: Ga, dc_voltmeter_left: Wa, dc_voltmeter_right: Za, dc_voltmeter_up: Ka, dc_voltmeter_vert: ey, diac_down: ry, diac_horz: oy, diac_left: iy, diac_right: ly, diac_up: py, diac_vert: ay, digital_ground_down: xy, digital_ground_left: my, digital_ground_right: fy, digital_ground_up: cy, diode_down: by, diode_left: _y, diode_right: C, diode_up: gy, dpdt_normally_closed_switch_down: vy, dpdt_normally_closed_switch_left: wy, dpdt_normally_closed_switch_right: N, dpdt_normally_closed_switch_up: Ay, dpdt_switch_down: Sy, dpdt_switch_left: Fy, dpdt_switch_right: I, dpdt_switch_up: Ry, dpst_normally_closed_switch_down: Ey, dpst_normally_closed_switch_left: Yy, dpst_normally_closed_switch_right: B, dpst_normally_closed_switch_up: Xy5, dpst_switch_down: Vy, dpst_switch_left: jy, dpst_switch_right: q, dpst_switch_up: ky2, ferrite_bead_down: Oy, ferrite_bead_left: Jy, ferrite_bead_right: Te, ferrite_bead_up: Re, filled_diode_down: My, filled_diode_horz: Ny, filled_diode_left: By, filled_diode_right: Dy, filled_diode_up: Uy, filled_diode_vert: Hy, frequency_meter_horz: St, frequency_meter_vert: tx, fuse_horz: Oe, fuse_vert: ox, ground_down: ix, ground_horz: lx, ground_left: px, ground_right: ax, ground_up: yx, ground_vert: xx, gunn_diode_horz: sx, gunn_diode_vert: mx, icled_down: fx, icled_left: hx, icled_right: D, icled_up: cx, igbt_transistor_horz: Je, igbt_transistor_vert: _x, illuminated_push_button_normally_open_horz: $e, illuminated_push_button_normally_open_vert: wx, inductor_down: Fx, inductor_left: Rx, inductor_right: ut, inductor_up: Ce, laser_diode_down: Tx, laser_diode_left: Ex, laser_diode_right: G, laser_diode_up: Yx, led_down: jx, led_left: kx, led_right: vt, led_up: Ie, light_dependent_resistor_horz: qe, light_dependent_resistor_vert: Cx, mosfet_depletion_normally_on_horz: Ge, mosfet_depletion_normally_on_vert: qx, mushroom_head_normally_open_momentary_horz: We, mushroom_head_normally_open_momentary_vert: Wx, n_channel_d_mosfet_transistor_horz: Qe, n_channel_d_mosfet_transistor_vert: ts2, n_channel_e_mosfet_transistor_horz: t0, n_channel_e_mosfet_transistor_vert: ls, njfet_transistor_horz: r0, njfet_transistor_vert: ss, not_connected_down: fs54, not_connected_left: hs, not_connected_right: U, not_connected_up: cs, npn_bipolar_transistor_down: ds, npn_bipolar_transistor_horz: bs, npn_bipolar_transistor_left: _s, npn_bipolar_transistor_right: gs, npn_bipolar_transistor_up: us, npn_bipolar_transistor_vert: vs, opamp_no_power_down: As, opamp_no_power_left: Ps, opamp_no_power_right: W, opamp_no_power_up: Ss, opamp_with_power_down: Rs, opamp_with_power_left: Ts, opamp_with_power_right: H, opamp_with_power_up: Es, p_channel_d_mosfet_transistor_horz: x0, p_channel_d_mosfet_transistor_vert: js, p_channel_e_mosfet_transistor_horz: m0, p_channel_e_mosfet_transistor_vert: $s, photodiode_horz: n0, photodiode_vert: Is, pjfet_transistor_horz: h0, pjfet_transistor_vert: Us, pnp_bipolar_transistor_down: Ws, pnp_bipolar_transistor_horz: Hs, pnp_bipolar_transistor_left: Zs, pnp_bipolar_transistor_right: Qs, pnp_bipolar_transistor_up: Ks, pnp_bipolar_transistor_vert: tm, potentiometer_horz: v0, potentiometer_vert: im, potentiometer2_down: ym, potentiometer2_left: xm, potentiometer2_right: Z, potentiometer2_up: sm, potentiometer3_down: mm2, potentiometer3_left: nm, potentiometer3_right: fm, potentiometer3_up: hm, power_factor_meter_horz: R0, power_factor_meter_vert: _m, push_button_normally_closed_momentary_horz: E0, push_button_normally_closed_momentary_vert: wm, push_button_normally_open_momentary_horz: X0, push_button_normally_open_momentary_vert: Fm, rail_down: Tm, rail_left: Ym, rail_right: Lm, rail_up: jm, rectifier_diode_horz: j0, rectifier_diode_vert: Om, resistor_down: $m, resistor_left: Cm, resistor_right: Im, resistor_up: qm, resonator_down: Gm, resonator_horz: N0, resonator_left: Um, resonator_right: et, resonator_up: Wm, resonator_vert: Hm, schottky_diode_down: Qm, schottky_diode_left: Km, schottky_diode_right: rt, schottky_diode_up: tn, silicon_controlled_rectifier_horz: I0, silicon_controlled_rectifier_vert: on2, solderjumper2_bridged12_down: ln, solderjumper2_bridged12_left: pn, solderjumper2_bridged12_right: an, solderjumper2_bridged12_up: yn, solderjumper2_down: xn, solderjumper2_left: sn, solderjumper2_right: mn, solderjumper2_up: nn, solderjumper3_bridged12_down: fn, solderjumper3_bridged12_left: hn, solderjumper3_bridged12_right: cn, solderjumper3_bridged12_up: dn, solderjumper3_bridged123_down: bn, solderjumper3_bridged123_left: _n, solderjumper3_bridged123_right: gn, solderjumper3_bridged123_up: un, solderjumper3_bridged23_down: vn, solderjumper3_bridged23_left: wn, solderjumper3_bridged23_right: An, solderjumper3_bridged23_up: Pn, solderjumper3_down: Sn, solderjumper3_left: Fn, solderjumper3_right: Rn, solderjumper3_up: Tn, spdt_normally_closed_switch_down: Yn, spdt_normally_closed_switch_left: Xn, spdt_normally_closed_switch_right: xt, spdt_normally_closed_switch_up: Ln, spdt_switch_down: jn, spdt_switch_left: kn, spdt_switch_right: st, spdt_switch_up: zn, spst_normally_closed_switch_down: On, spst_normally_closed_switch_left: Jn, spst_normally_closed_switch_right: mt, spst_normally_closed_switch_up: $n, spst_switch_down: Mn, spst_switch_left: Cn, spst_switch_right: nt, spst_switch_up: Nn, square_wave_down: In, square_wave_left: Bn, square_wave_right: qn, square_wave_up: Dn, step_recovery_diode_horz: B0, step_recovery_diode_vert: Gn, tachometer_horz: Yt, tachometer_vert: Zn, testpoint_down: t1, testpoint_left: e1, testpoint_right: ht, testpoint_up: i1, tilted_ground_down: p1, tilted_ground_left: a1, tilted_ground_right: wt, tilted_ground_up: D0, triac_horz: G0, triac_vert: s1, tunnel_diode_horz: W0, tunnel_diode_vert: h1, unijunction_transistor_horz: Z0, unijunction_transistor_vert: u1, usbc: w1, var_meter_horz: K0, var_meter_vert: S1, varactor_diode_horz: er, varactor_diode_vert: E1, varistor_horz: or, varistor_vert: V1, varmeter_horz: Xt, varmeter_vert: O1, vcc_down: J1, vcc_left: $1, vcc_right: M1, vcc_up: C1, volt_meter_horz: lr, volt_meter_vert: N1, watt_hour_meter_horz: Lt, watt_hour_meter_vert: D1, wattmeter_horz: Vt, wattmeter_vert: H1, zener_diode_horz: xr, zener_diode_vert: tf };
 var gM = Object.fromEntries(Object.keys(ef).map((t) => [t, t]));
 function doesLineIntersectLine([a12, a22], [b12, b22], {
   lineThickness = 0
@@ -101924,11 +102283,11 @@ var require_react_reconciler_development = __commonJS2({
           fiber = fiber.next, id--;
         return fiber;
       }
-      function copyWithSetImpl(obj, path55, index, value) {
-        if (index >= path55.length)
+      function copyWithSetImpl(obj, path56, index, value) {
+        if (index >= path56.length)
           return value;
-        var key = path55[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        updated[key] = copyWithSetImpl(obj[key], path55, index + 1, value);
+        var key = path56[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        updated[key] = copyWithSetImpl(obj[key], path56, index + 1, value);
         return updated;
       }
       function copyWithRename(obj, oldPath, newPath) {
@@ -101948,11 +102307,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, path55, index) {
-        var key = path55[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        if (index + 1 === path55.length)
+      function copyWithDeleteImpl(obj, path56, index) {
+        var key = path56[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        if (index + 1 === path56.length)
           return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-        updated[key] = copyWithDeleteImpl(obj[key], path55, index + 1);
+        updated[key] = copyWithDeleteImpl(obj[key], path56, index + 1);
         return updated;
       }
       function shouldSuspendImpl() {
@@ -110978,29 +111337,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, path55, value) {
+      overrideHookState = function(fiber, id, path56, value) {
         id = findHook(fiber, id);
-        id !== null && (path55 = copyWithSetImpl(id.memoizedState, path55, 0, value), id.memoizedState = path55, id.baseState = path55, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path55 = enqueueConcurrentRenderForLane(fiber, 2), path55 !== null && scheduleUpdateOnFiber(path55, fiber, 2));
+        id !== null && (path56 = copyWithSetImpl(id.memoizedState, path56, 0, value), id.memoizedState = path56, id.baseState = path56, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path56 = enqueueConcurrentRenderForLane(fiber, 2), path56 !== null && scheduleUpdateOnFiber(path56, fiber, 2));
       };
-      overrideHookStateDeletePath = function(fiber, id, path55) {
+      overrideHookStateDeletePath = function(fiber, id, path56) {
         id = findHook(fiber, id);
-        id !== null && (path55 = copyWithDeleteImpl(id.memoizedState, path55, 0), id.memoizedState = path55, id.baseState = path55, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path55 = enqueueConcurrentRenderForLane(fiber, 2), path55 !== null && scheduleUpdateOnFiber(path55, fiber, 2));
+        id !== null && (path56 = copyWithDeleteImpl(id.memoizedState, path56, 0), id.memoizedState = path56, id.baseState = path56, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path56 = enqueueConcurrentRenderForLane(fiber, 2), path56 !== null && scheduleUpdateOnFiber(path56, 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, path55, value) {
-        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path55, 0, value);
+      overrideProps = function(fiber, path56, value) {
+        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path56, 0, value);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path55 = enqueueConcurrentRenderForLane(fiber, 2);
-        path55 !== null && scheduleUpdateOnFiber(path55, fiber, 2);
+        path56 = enqueueConcurrentRenderForLane(fiber, 2);
+        path56 !== null && scheduleUpdateOnFiber(path56, fiber, 2);
       };
-      overridePropsDeletePath = function(fiber, path55) {
-        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path55, 0);
+      overridePropsDeletePath = function(fiber, path56) {
+        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path56, 0);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path55 = enqueueConcurrentRenderForLane(fiber, 2);
-        path55 !== null && scheduleUpdateOnFiber(path55, fiber, 2);
+        path56 = enqueueConcurrentRenderForLane(fiber, 2);
+        path56 !== null && scheduleUpdateOnFiber(path56, fiber, 2);
       };
       overridePropsRenamePath = function(fiber, oldPath, newPath) {
         fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -117303,7 +117662,7 @@ var parsePin = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path55 = pathMatch ? pathMatch[1] : "";
+  const path56 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r2 = Number.parseFloat(rotation4);
@@ -117317,7 +117676,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r2) ? 0 : r2,
     label,
     labelColor,
-    path: path55,
+    path: path56,
     arrow
   };
 };
@@ -117757,15 +118116,15 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path55 = [];
+  const path56 = [];
   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);
-    path55.push({ x: x22, y: y22 });
+    path56.push({ x: x22, y: y22 });
   }
-  return path55;
+  return path56;
 }
 var __defProp4 = Object.defineProperty;
 var __export22 = (target, all) => {
@@ -126844,17 +127203,17 @@ var ObstacleList = class {
     return obstacles;
   }
 };
-function removePathLoops(path55) {
-  if (path55.length < 4)
-    return path55;
-  const result = [{ ...path55[0] }];
-  let currentLayer = path55[0].layer;
-  for (let i22 = 1;i22 < path55.length; i22++) {
-    const currentSegment = { start: path55[i22 - 1], end: path55[i22] };
-    const isVia = path55[i22].route_type === "via" || path55[i22 - 1].route_type === "via";
-    if (path55[i22].layer !== currentLayer || isVia) {
-      result.push({ ...path55[i22] });
-      currentLayer = path55[i22].layer;
+function removePathLoops(path56) {
+  if (path56.length < 4)
+    return path56;
+  const result = [{ ...path56[0] }];
+  let currentLayer = path56[0].layer;
+  for (let i22 = 1;i22 < path56.length; i22++) {
+    const currentSegment = { start: path56[i22 - 1], end: path56[i22] };
+    const isVia = path56[i22].route_type === "via" || path56[i22 - 1].route_type === "via";
+    if (path56[i22].layer !== currentLayer || isVia) {
+      result.push({ ...path56[i22] });
+      currentLayer = path56[i22].layer;
       continue;
     }
     let intersectionFound = false;
@@ -126883,8 +127242,8 @@ function removePathLoops(path55) {
       result.push(intersectionPoint);
     }
     const lastPoint = result[result.length - 1];
-    if (lastPoint.x !== path55[i22].x || lastPoint.y !== path55[i22].y) {
-      result.push(path55[i22]);
+    if (lastPoint.x !== path56[i22].x || lastPoint.y !== path56[i22].y) {
+      result.push(path56[i22]);
     }
   }
   return result;
@@ -127373,10 +127732,10 @@ var GeneralizedAstarAutorouter = class {
       });
     }
     if (current2.parent) {
-      const path55 = [];
+      const path56 = [];
       let p22 = current2;
       while (p22) {
-        path55.unshift(p22);
+        path56.unshift(p22);
         p22 = p22.parent;
       }
       debugSolution.push({
@@ -127384,7 +127743,7 @@ var GeneralizedAstarAutorouter = class {
         pcb_component_id: "",
         pcb_fabrication_note_path_id: `note_path_${current2.x}_${current2.y}`,
         layer: "top",
-        route: path55,
+        route: path56,
         stroke_width: 0.01
       });
     }
@@ -135735,7 +136094,7 @@ var ps2 = class extends e3 {
     return t3;
   }
 };
-var fs54 = (t3) => {
+var fs55 = (t3) => {
   const e22 = [], s22 = [], n22 = [], i22 = ht2(t3);
   if (t3.connections)
     for (const e32 of t3.connections)
@@ -138358,7 +138717,7 @@ var Tn2 = class extends e3 {
       const t3 = M22.map((t42) => ({ x: t42.x, y: t42.y }));
       t3.push({ ...t3[0] }), v22.push({ points: t3, strokeColor: "rgba(0, 136, 255, 0.95)" });
     }
-    const S22 = { points: [...this.srj.connections.flatMap((t3) => t3.pointsToConnect.map((e32) => ({ ...e32, label: `${t3.name} ${e32.pcb_port_id ?? ""}` })))], rects: [...(this.srj.obstacles ?? []).map((t3) => ({ ...t3, fill: t3.layers?.includes("top") ? "rgba(255,0,0,0.25)" : t3.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)", label: t3.layers?.join(", ") }))], lines: v22 }, b22 = [S22, e22, s22, n22, i22, o22, a22, r22, h22, c22, d2, l22, u22, p22 ? t(S22, p22) : null, f2, m22, y22, g22, x22, this.solved ? t(S22, fs54(this.getOutputSimpleRouteJson())) : null].filter(Boolean);
+    const S22 = { points: [...this.srj.connections.flatMap((t3) => t3.pointsToConnect.map((e32) => ({ ...e32, label: `${t3.name} ${e32.pcb_port_id ?? ""}` })))], rects: [...(this.srj.obstacles ?? []).map((t3) => ({ ...t3, fill: t3.layers?.includes("top") ? "rgba(255,0,0,0.25)" : t3.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)", label: t3.layers?.join(", ") }))], lines: v22 }, b22 = [S22, e22, s22, n22, i22, o22, a22, r22, h22, c22, d2, l22, u22, p22 ? t(S22, p22) : null, f2, m22, y22, g22, x22, this.solved ? t(S22, fs55(this.getOutputSimpleRouteJson())) : null].filter(Boolean);
     return t(...b22);
   }
   preview() {
@@ -151829,10 +152188,10 @@ var findFirstCollision = (pts, rects, opts = {}) => {
   }
   return null;
 };
-var isPathCollidingWithObstacles = (path55, obstacles) => {
-  for (let i22 = 0;i22 < path55.length - 1; i22++) {
+var isPathCollidingWithObstacles = (path56, obstacles) => {
+  for (let i22 = 0;i22 < path56.length - 1; i22++) {
     for (const obstacle of obstacles) {
-      if (segmentIntersectsRect(path55[i22], path55[i22 + 1], obstacle)) {
+      if (segmentIntersectsRect(path56[i22], path56[i22 + 1], obstacle)) {
         return true;
       }
     }
@@ -152026,36 +152385,36 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
       this.error = "No collision-free path found";
       return;
     }
-    const { path: path55, collisionChipIds } = state;
+    const { path: path56, collisionChipIds } = state;
     const [PA, PB] = this.pins;
-    const collision = findFirstCollision(path55, this.obstacles);
+    const collision = findFirstCollision(path56, this.obstacles);
     if (!collision) {
-      const first = path55[0];
-      const last = path55[path55.length - 1];
+      const first = path56[0];
+      const last = path56[path56.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 = path55;
+        this.solvedTracePath = path56;
         this.solved = true;
       }
       return;
     }
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
-    const isLastSegment = segIndex === path55.length - 2;
+    const isLastSegment = segIndex === path56.length - 2;
     if (isFirstSegment) {
-      if (path55.length < 3) {
+      if (path56.length < 3) {
         return;
       }
       segIndex = 1;
     } else if (isLastSegment) {
-      if (path55.length < 3) {
+      if (path56.length < 3) {
         return;
       }
-      segIndex = path55.length - 3;
+      segIndex = path56.length - 3;
     }
-    const a22 = path55[segIndex];
-    const b22 = path55[segIndex + 1];
+    const a22 = path56[segIndex];
+    const b22 = path56[segIndex + 1];
     const axis = this.axisOfSegment(a22, b22);
     if (!axis) {
       return;
@@ -152073,7 +152432,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
     }
     const newStates = [];
     for (const coord of candidates) {
-      const newPath = shiftSegmentOrth(path55, segIndex, axis, coord);
+      const newPath = shiftSegmentOrth(path56, segIndex, axis, coord);
       if (!newPath)
         continue;
       const key = pathKey(newPath);
@@ -152109,8 +152468,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver3 {
       strokeColor: "blue",
       strokeDash: "5 5"
     });
-    for (const { path: path55, collisionChipIds: collisionRectIds } of this.queue) {
-      g22.lines.push({ points: path55, strokeColor: "teal", strokeDash: "2 2" });
+    for (const { path: path56, collisionChipIds: collisionRectIds } of this.queue) {
+      g22.lines.push({ points: path56, strokeColor: "teal", strokeDash: "2 2" });
     }
     if (this.solvedTracePath) {
       g22.lines.push({ points: this.solvedTracePath, strokeColor: "green" });
@@ -152347,9 +152706,9 @@ var TraceOverlapIssueSolver = class extends BaseSolver3 {
         solvedTracePathIndex,
         traceSegmentIndex
       } of group.pathsWithOverlap) {
-        const path55 = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
-        const segStart = path55.tracePath[traceSegmentIndex];
-        const segEnd = path55.tracePath[traceSegmentIndex + 1];
+        const path56 = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+        const segStart = path56.tracePath[traceSegmentIndex];
+        const segEnd = path56.tracePath[traceSegmentIndex + 1];
         graphics.lines.push({
           points: [segStart, segEnd],
           strokeColor: "red"
@@ -152393,11 +152752,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver3 {
   computeTraceNetIslands() {
     const islands = {};
     for (const original of this.inputTracePaths) {
-      const path55 = this.correctedTraceMap[original.mspPairId] ?? original;
-      const key = path55.globalConnNetId;
+      const path56 = this.correctedTraceMap[original.mspPairId] ?? original;
+      const key = path56.globalConnNetId;
       if (!islands[key])
         islands[key] = [];
-      islands[key].push(path55);
+      islands[key].push(path56);
     }
     return islands;
   }
@@ -152645,9 +153004,9 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
   }
   return { hasIntersection: false };
 }
-function lengthOfTrace(path55) {
+function lengthOfTrace(path56) {
   let sum = 0;
-  const pts = path55.tracePath;
+  const pts = path56.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);
   }
@@ -153176,9 +153535,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 = (path55) => {
+          const lengthOf = (path56) => {
             let sum = 0;
-            const pts = path55.tracePath;
+            const pts = path56.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);
             }
@@ -153323,12 +153682,12 @@ var detectTraceLabelOverlap = (traces, netLabels) => {
   }
   return overlaps;
 };
-var findTraceViolationZone = (path55, labelBounds) => {
+var findTraceViolationZone = (path56, 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 < path55.length; i22++) {
-    if (isPointInside(path55[i22])) {
+  for (let i22 = 0;i22 < path56.length; i22++) {
+    if (isPointInside(path56[i22])) {
       if (firstInsideIndex === -1) {
         firstInsideIndex = i22;
       }
@@ -153337,20 +153696,20 @@ var findTraceViolationZone = (path55, labelBounds) => {
   }
   return { firstInsideIndex, lastInsideIndex };
 };
-var simplifyPath = (path55) => {
-  if (path55.length < 3)
-    return path55;
-  const newPath = [path55[0]];
-  for (let i22 = 1;i22 < path55.length - 1; i22++) {
+var simplifyPath = (path56) => {
+  if (path56.length < 3)
+    return path56;
+  const newPath = [path56[0]];
+  for (let i22 = 1;i22 < path56.length - 1; i22++) {
     const p12 = newPath[newPath.length - 1];
-    const p22 = path55[i22];
-    const p32 = path55[i22 + 1];
+    const p22 = path56[i22];
+    const p32 = path56[i22 + 1];
     if (isVertical(p12, p22) && isVertical(p22, p32) || isHorizontal(p12, p22) && isHorizontal(p22, p32)) {
       continue;
     }
     newPath.push(p22);
   }
-  newPath.push(path55[path55.length - 1]);
+  newPath.push(path56[path56.length - 1]);
   if (newPath.length < 3)
     return newPath;
   const finalPath = [newPath[0]];
@@ -153610,12 +153969,12 @@ var hasCollisionsWithLabels = (pathSegments, labels) => {
   return false;
 };
 var minimizeTurns = ({
-  path: path55,
+  path: path56,
   obstacles,
   labelBounds
 }) => {
-  if (path55.length <= 2) {
-    return path55;
+  if (path56.length <= 2) {
+    return path56;
   }
   const recognizeStairStepPattern = (pathToCheck, startIdx) => {
     if (startIdx >= pathToCheck.length - 3)
@@ -153647,7 +154006,7 @@ var minimizeTurns = ({
     }
     return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
   };
-  let optimizedPath = [...path55];
+  let optimizedPath = [...path56];
   let currentTurns = countTurns(optimizedPath);
   let improved = true;
   while (improved) {
@@ -161252,9 +161611,9 @@ var getFileExtension = (filename) => {
   const extension = lastSegment.split(".").pop();
   return extension?.toLowerCase() ?? null;
 };
-var joinUrlPath = (base, path55) => {
+var joinUrlPath = (base, path56) => {
   const trimmedBase = base.replace(/\/+$/, "");
-  const trimmedPath = path55.replace(/^\/+/, "");
+  const trimmedPath = path56.replace(/^\/+/, "");
   return `${trimmedBase}/${trimmedPath}`;
 };
 var constructAssetUrl = (targetUrl, baseUrl) => {
@@ -162568,7 +162927,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
     for (let i22 = 0;i22 < portsWithPosition.length - 1; i22++) {
       const start = portsWithPosition[i22];
       const end = portsWithPosition[i22 + 1];
-      const path55 = calculateElbow({
+      const path56 = calculateElbow({
         x: start.position.x,
         y: start.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(start.facingDirection)
@@ -162577,8 +162936,8 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         y: end.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(end.facingDirection)
       });
-      for (let j22 = 0;j22 < path55.length - 1; j22++) {
-        elbowEdges.push({ from: path55[j22], to: path55[j22 + 1] });
+      for (let j22 = 0;j22 < path56.length - 1; j22++) {
+        elbowEdges.push({ from: path56[j22], to: path56[j22 + 1] });
       }
     }
     const doesSegmentIntersectRect2 = (edge, rect) => {
@@ -163771,20 +164130,20 @@ var parseLibraryFootprintRef = (s22) => {
 };
 var isStaticAssetPath = (s22) => s22.startsWith("/");
 var resolveStaticFileImportDebug = (0, import_debug92.default)("tscircuit:core:resolveStaticFileImport");
-async function resolveStaticFileImport(path55, platform) {
-  if (!path55)
-    return path55;
+async function resolveStaticFileImport(path56, platform) {
+  if (!path56)
+    return path56;
   const resolver = platform?.resolveProjectStaticFileImportUrl;
-  if (resolver && path55.startsWith("/")) {
+  if (resolver && path56.startsWith("/")) {
     try {
-      const resolved = await resolver(path55);
+      const resolved = await resolver(path56);
       if (resolved)
         return resolved;
     } catch (error) {
       resolveStaticFileImportDebug("failed to resolve static file via platform resolver", error);
     }
   }
-  return constructAssetUrl(path55, platform?.projectBaseUrl);
+  return constructAssetUrl(path56, platform?.projectBaseUrl);
 }
 function NormalComponent_doInitialPcbFootprintStringRender(component, queueAsyncEffect) {
   let { footprint } = component.props;
@@ -168872,7 +169231,7 @@ var Group6 = class extends NormalComponent3 {
       });
     }
     if (debug112.enabled) {
-      const graphicsObject = fs54(simpleRouteJson);
+      const graphicsObject = fs55(simpleRouteJson);
       graphicsObject.title = `autorouting-${this.props.name}`;
       global.debugGraphics?.push(graphicsObject);
     }
@@ -171431,7 +171790,7 @@ var NetLabel = class extends PrimitiveComponent2 {
       }
       const portPos = port._getGlobalSchematicPositionAfterLayout();
       const portFacing = convertFacingDirectionToElbowDirection(port.facingDirection ?? "right") ?? "x+";
-      const path55 = calculateElbow({
+      const path56 = calculateElbow({
         x: portPos.x,
         y: portPos.y,
         facingDirection: portFacing
@@ -171440,13 +171799,13 @@ var NetLabel = class extends PrimitiveComponent2 {
         y: anchorPos.y,
         facingDirection: anchorFacing
       });
-      if (!Array.isArray(path55) || path55.length < 2)
+      if (!Array.isArray(path56) || path56.length < 2)
         continue;
       const edges = [];
-      for (let i22 = 0;i22 < path55.length - 1; i22++) {
+      for (let i22 = 0;i22 < path56.length - 1; i22++) {
         edges.push({
-          from: { x: path55[i22].x, y: path55[i22].y },
-          to: { x: path55[i22 + 1].x, y: path55[i22 + 1].y }
+          from: { x: path56[i22].x, y: path56[i22].y },
+          to: { x: path56[i22 + 1].x, y: path56[i22 + 1].y }
         });
       }
       let source_trace_id;
@@ -173758,8 +174117,8 @@ react/cjs/react-jsx-runtime.development.js:
 */
 
 // lib/import/import-component-from-jlcpcb.ts
-import fs55 from "node:fs/promises";
-import path55 from "node:path";
+import fs56 from "node:fs/promises";
+import path56 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd()) => {
   const component = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const tsx = await convertRawEasyToTsx(component);
@@ -173767,10 +174126,10 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
   if (!fileName) {
     throw new Error("Could not determine file name of converted component");
   }
-  const importsDir = path55.join(projectDir, "imports");
-  await fs55.mkdir(importsDir, { recursive: true });
-  const filePath = path55.join(importsDir, `${fileName}.tsx`);
-  await fs55.writeFile(filePath, tsx);
+  const importsDir = path56.join(projectDir, "imports");
+  await fs56.mkdir(importsDir, { recursive: true });
+  const filePath = path56.join(importsDir, `${fileName}.tsx`);
+  await fs56.writeFile(filePath, tsx);
   return { filePath };
 };
 
@@ -175114,13 +175473,13 @@ var registerImport = (program2) => {
 };
 
 // cli/init/register.ts
-import * as fs57 from "node:fs";
-import * as path58 from "node:path";
+import * as fs58 from "node:fs";
+import * as path59 from "node:path";
 
 // lib/shared/generate-gitignore-file.ts
-import path56 from "node:path";
+import path57 from "node:path";
 var generateGitIgnoreFile = (dir) => {
-  const gitignorePath = path56.join(dir, ".gitignore");
+  const gitignorePath = path57.join(dir, ".gitignore");
   const gitignoreContent = `# Dependencies
 node_modules/
 
@@ -175155,8 +175514,8 @@ yarn-error.log*
 };
 
 // lib/shared/setup-tscircuit-skill.ts
-import * as fs56 from "node:fs";
-import * as path57 from "node:path";
+import * as fs57 from "node:fs";
+import * as path58 from "node:path";
 var SKILL_REPO_API_URL = "https://api.github.com/repos/tscircuit/skill/contents";
 var SKILL_DIR_NAME = ".claude/skills/tscircuit";
 async function fetchGitHubContents(apiUrl) {
@@ -175176,36 +175535,36 @@ async function fetchFileContent(downloadUrl) {
 async function downloadDirectory(apiUrl, targetDir) {
   const contents = await fetchGitHubContents(apiUrl);
   for (const item of contents) {
-    const targetPath = path57.join(targetDir, item.name);
+    const targetPath = path58.join(targetDir, item.name);
     if (item.type === "dir") {
-      fs56.mkdirSync(targetPath, { recursive: true });
+      fs57.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${apiUrl}/${item.name}`, targetPath);
     } else if (item.type === "file" && item.download_url) {
       const content = await fetchFileContent(item.download_url);
-      fs56.writeFileSync(targetPath, content, "utf-8");
+      fs57.writeFileSync(targetPath, content, "utf-8");
     }
   }
 }
 async function downloadSkillRepo(targetDir) {
-  fs56.mkdirSync(targetDir, { recursive: true });
+  fs57.mkdirSync(targetDir, { recursive: true });
   const rootContents = await fetchGitHubContents(SKILL_REPO_API_URL);
   for (const item of rootContents) {
     if (item.name === ".git" || item.name === ".github") {
       continue;
     }
-    const targetPath = path57.join(targetDir, item.name);
+    const targetPath = path58.join(targetDir, item.name);
     if (item.type === "dir") {
-      fs56.mkdirSync(targetPath, { recursive: true });
+      fs57.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${SKILL_REPO_API_URL}/${item.name}`, targetPath);
     } else if (item.type === "file" && item.download_url) {
       const content = await fetchFileContent(item.download_url);
-      fs56.writeFileSync(targetPath, content, "utf-8");
+      fs57.writeFileSync(targetPath, content, "utf-8");
     }
   }
 }
 async function setupTscircuitSkill(projectDir, skipPrompt = false) {
-  const skillDir = path57.join(projectDir, SKILL_DIR_NAME);
-  if (fs56.existsSync(path57.join(skillDir, "SKILL.md"))) {
+  const skillDir = path58.join(projectDir, SKILL_DIR_NAME);
+  if (fs57.existsSync(path58.join(skillDir, "SKILL.md"))) {
     console.log("Claude skill already exists, skipping...");
     return true;
   }
@@ -175324,7 +175683,7 @@ var registerInit = (program3) => {
         }
       }
     }
-    const projectDir = directory ? path58.resolve(process.cwd(), directory) : process.cwd();
+    const projectDir = directory ? path59.resolve(process.cwd(), directory) : process.cwd();
     let tsciHandle = null;
     const token = getSessionToken();
     if (token) {
@@ -175335,7 +175694,7 @@ var registerInit = (program3) => {
         }
       } catch {}
     }
-    const dirName = path58.basename(projectDir);
+    const dirName = path59.basename(projectDir);
     let defaultPackageName = dirName;
     if (tsciHandle) {
       defaultPackageName = `@tsci/${tsciHandle}.${dirName}`;
@@ -175353,8 +175712,8 @@ var registerInit = (program3) => {
         authorName = account.tscircuit_handle;
       }
     }
-    fs57.mkdirSync(projectDir, { recursive: true });
-    writeFileIfNotExists(path58.join(projectDir, "index.circuit.tsx"), `
+    fs58.mkdirSync(projectDir, { recursive: true });
+    writeFileIfNotExists(path59.join(projectDir, "index.circuit.tsx"), `
 export default () => (
   <board>
     <resistor resistance="1k" footprint="0402" name="R1" />
@@ -175366,7 +175725,7 @@ export default () => (
     if (saveProjectConfig(null, projectDir)) {
       console.log("Created tscircuit.config.json with schema");
     }
-    writeFileIfNotExists(path58.join(projectDir, ".npmrc"), `
+    writeFileIfNotExists(path59.join(projectDir, ".npmrc"), `
 @tsci:registry=https://npm.tscircuit.com
 `);
     console.log("Generating package.json");
@@ -175517,14 +175876,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path59 = null;
+  let path60 = null;
   let id = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path59 = createKeyPath(key);
+    path60 = createKeyPath(key);
     id = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -175538,11 +175897,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path59 = createKeyPath(name);
+    path60 = createKeyPath(name);
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path59, id, weight, src, getFn };
+  return { path: path60, id, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -175550,34 +175909,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path59) {
+function get(obj, path60) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path60, index) => {
+  const deepGet = (obj2, path61, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path60[index]) {
+    if (!path61[index]) {
       list.push(obj2);
     } else {
-      let key = path60[index];
+      let key = path61[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path60.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value))) {
+      if (index === path61.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], path60, index + 1);
+          deepGet(value[i3], path61, index + 1);
         }
-      } else if (path60.length) {
-        deepGet(value, path60, index + 1);
+      } else if (path61.length) {
+        deepGet(value, path61, index + 1);
       }
     }
   };
-  deepGet(obj, isString2(path59) ? path59.split(".") : path59, 0);
+  deepGet(obj, isString2(path60) ? path60.split(".") : path60, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -176781,8 +177140,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path59, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path59.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path60, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path60.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (results.packages.length) {
@@ -176806,22 +177165,22 @@ var registerSearch = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs58 from "node:fs";
-import path59 from "node:path";
+import fs59 from "node:fs";
+import path60 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path59.resolve(startDir);
-    while (dir !== path59.parse(dir).root) {
-      if (fs58.existsSync(path59.join(dir, ".git"))) {
+    let dir = path60.resolve(startDir);
+    while (dir !== path60.parse(dir).root) {
+      if (fs59.existsSync(path60.join(dir, ".git"))) {
         return dir;
       }
-      dir = path59.dirname(dir);
+      dir = path60.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path59.join(gitRoot, ".github", "workflows");
-  fs58.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path60.join(gitRoot, ".github", "workflows");
+  fs59.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -176860,8 +177219,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path59.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path59.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path60.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path60.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -176973,8 +177332,8 @@ var registerSimulate = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs60 from "node:fs";
-import path60 from "node:path";
+import fs61 from "node:fs";
+import path61 from "node:path";
 import {
   convertCircuitJsonToGltf as convertCircuitJsonToGltf5,
   getBestCameraPosition
@@ -176988,7 +177347,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs59 from "node:fs/promises";
+import fs60 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -177004,7 +177363,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true)
         tolerance: 2
       });
     } else {
-      await fs59.writeFile(diffPath, buffer2);
+      await fs60.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -177030,7 +177389,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path60.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path61.resolve(projectDir, f2));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -177048,13 +177407,13 @@ var snapshotProject = async ({
     return normalizedPath.endsWith(".circuit.json") || normalizedPath.endsWith("/circuit.json");
   };
   for (const file of boardFiles) {
-    const relativeFilePath = path60.relative(projectDir, file);
+    const relativeFilePath = path61.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
     try {
       if (isCircuitJsonFile(file)) {
-        const parsed = JSON.parse(fs60.readFileSync(file, "utf-8"));
+        const parsed = JSON.parse(fs61.readFileSync(file, "utf-8"));
         circuitJson = Array.isArray(parsed) ? parsed : [];
       } else {
         const completePlatformConfig = getCompletePlatformConfig(platformConfig2);
@@ -177104,17 +177463,17 @@ var snapshotProject = async ({
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-          const fileDir = path60.dirname(file);
-          const relativeDir = path60.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path60.join(projectDir, snapshotsDirName, relativeDir) : path60.join(fileDir, "__snapshots__");
-          const base2 = path60.basename(file).replace(/\.[^.]+$/, "");
-          const snap3dPath = path60.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs60.existsSync(snap3dPath);
+          const fileDir = path61.dirname(file);
+          const relativeDir = path61.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path61.join(projectDir, snapshotsDirName, relativeDir) : path61.join(fileDir, "__snapshots__");
+          const base2 = path61.basename(file).replace(/\.[^.]+$/, "");
+          const snap3dPath = path61.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs61.existsSync(snap3dPath);
           if (existing3dSnapshot) {
             onError(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: ${path60.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path61.relative(projectDir, snap3dPath)}
 `));
             return onExit2(1);
           } else {
@@ -177130,9 +177489,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path60.join(projectDir, snapshotsDirName, path60.relative(projectDir, path60.dirname(file))) : path60.join(path60.dirname(file), "__snapshots__");
-    fs60.mkdirSync(snapDir, { recursive: true });
-    const base = path60.basename(file).replace(/\.[^.]+$/, "");
+    const snapDir = snapshotsDirName ? path61.join(projectDir, snapshotsDirName, path61.relative(projectDir, path61.dirname(file))) : path61.join(path61.dirname(file), "__snapshots__");
+    fs61.mkdirSync(snapDir, { recursive: true });
+    const base = path61.basename(file).replace(/\.[^.]+$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -177150,31 +177509,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path60.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs60.existsSync(snapPath);
+      const snapPath = path61.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs61.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs60.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path60.relative(projectDir, snapPath)));
+        fs61.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path61.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs60.readFileSync(snapPath);
+      const oldContentBuffer = fs61.readFileSync(snapPath);
       const diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
       const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath, createDiff);
       if (update) {
         if (!forceUpdate && equal2) {
-          console.log("✅", kleur_default.gray(path60.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path61.relative(projectDir, snapPath)));
         } else {
-          fs60.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path60.relative(projectDir, snapPath)));
+          fs61.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path61.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(createDiff ? `${snapPath} (diff: ${diffPath})` : snapPath);
       } else {
-        console.log("✅", kleur_default.gray(path60.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path61.relative(projectDir, snapPath)));
       }
     }
   }
@@ -177214,7 +177573,7 @@ var registerSnapshot = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path61 from "node:path";
+import path62 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 {
@@ -177222,7 +177581,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path61.join(projectDir, "dist");
+      const distDir = path62.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];