@tscircuit/cli 0.1.653 → 0.1.655

package/dist/main.js

@@ -74139,7 +74139,7 @@ var package_default = {
     chokidar: "4.0.1",
     "circuit-json": "0.0.325",
     "circuit-json-to-gltf": "^0.0.56",
-    "circuit-json-to-kicad": "^0.0.3",
+    "circuit-json-to-kicad": "^0.0.29",
     "circuit-json-to-readable-netlist": "^0.0.13",
     "circuit-json-to-spice": "^0.0.10",
     "circuit-json-to-tscircuit": "^0.0.9",
@@ -80228,8 +80228,8 @@ Successfully cloned to:`));
 var import_perfect_cli = __toESM2(require_dist7(), 1);
 
 // lib/shared/export-snippet.ts
-import fs27 from "node:fs";
-import path29 from "node:path";
+import fs28 from "node:fs";
+import path30 from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // node_modules/circuit-json-to-readable-netlist/dist/index.js
@@ -81614,6 +81614,7 @@ import {
   Xy
 } from "kicadts";
 import { symbols } from "schematic-symbols";
+import { applyToPoint as applyToPoint3, scale as createScaleMatrix } from "transformation-matrix";
 import {
   SchematicSymbol as SchematicSymbol2,
   SymbolLibId,
@@ -81626,10 +81627,24 @@ import {
   TextEffectsFont as TextEffectsFont2,
   TextEffectsJustify
 } from "kicadts";
-import { applyToPoint as applyToPoint3 } from "transformation-matrix";
+import { applyToPoint as applyToPoint23 } from "transformation-matrix";
 import { symbols as symbols2 } from "schematic-symbols";
+import {
+  SchematicSymbol as SchematicSymbol3,
+  SymbolLibId as SymbolLibId2,
+  SymbolProperty as SymbolProperty3,
+  SymbolPin as SymbolPin3,
+  SymbolInstances as SymbolInstances2,
+  SymbolInstancesProject as SymbolInstancesProject2,
+  SymbolInstancePath as SymbolInstancePath2,
+  TextEffects as TextEffects3,
+  TextEffectsFont as TextEffectsFont3,
+  TextEffectsJustify as TextEffectsJustify2,
+  GlobalLabel
+} from "kicadts";
+import { applyToPoint as applyToPoint32 } from "transformation-matrix";
 import { Wire, Pts as Pts2, Xy as Xy2, Stroke as Stroke2, Junction } from "kicadts";
-import { applyToPoint as applyToPoint23 } from "transformation-matrix";
+import { applyToPoint as applyToPoint42 } from "transformation-matrix";
 import {
   SheetInstances,
   SheetInstancesRootPath,
@@ -81638,7 +81653,7 @@ import {
 } from "kicadts";
 import { KicadPcb } from "kicadts";
 import { cju as cju2 } from "@tscircuit/circuit-json-util";
-import { compose as compose2, translate as translate2, scale as scale22 } from "transformation-matrix";
+import { compose as compose3, translate as translate3, scale as scale32 } from "transformation-matrix";
 import {
   Paper as Paper2,
   PcbLayers,
@@ -81647,14 +81662,45 @@ import {
   Setup
 } from "kicadts";
 import { PcbNet } from "kicadts";
-import { Footprint, FpText, FootprintPad } from "kicadts";
-import { applyToPoint as applyToPoint32 } from "transformation-matrix";
+import { Footprint, FootprintModel } from "kicadts";
+import { applyToPoint as applyToPoint92 } from "transformation-matrix";
+import {
+  FootprintPad,
+  PadPrimitives,
+  PadPrimitiveGrPoly,
+  Pts as Pts3,
+  Xy as Xy3,
+  PadOptions,
+  PadNet
+} from "kicadts";
+import {
+  applyToPoint as applyToPoint52,
+  compose as compose2,
+  translate as translate2,
+  scale as scale22,
+  rotate
+} from "transformation-matrix";
+import { FootprintPad as FootprintPad2, PadDrill, PadNet as PadNet2 } from "kicadts";
+import { applyToPoint as applyToPoint62, rotate as rotate2, identity } from "transformation-matrix";
+import { FootprintPad as FootprintPad3, PadDrill as PadDrill2 } from "kicadts";
+import { applyToPoint as applyToPoint72, rotate as rotate3, identity as identity2 } from "transformation-matrix";
+import { FpText, TextEffects as TextEffects4, TextEffectsFont as TextEffectsFont4 } from "kicadts";
+import { applyToPoint as applyToPoint8, rotate as rotate4, identity as identity3 } from "transformation-matrix";
 import { Segment, SegmentNet } from "kicadts";
-import { applyToPoint as applyToPoint42 } from "transformation-matrix";
+import { applyToPoint as applyToPoint102 } from "transformation-matrix";
 import { Via, ViaNet } from "kicadts";
-import { applyToPoint as applyToPoint52 } from "transformation-matrix";
+import { applyToPoint as applyToPoint11 } from "transformation-matrix";
 import { GrLine } from "kicadts";
-import { applyToPoint as applyToPoint62 } from "transformation-matrix";
+import { applyToPoint as applyToPoint13 } from "transformation-matrix";
+import {
+  GrText,
+  TextEffects as TextEffects5,
+  TextEffectsFont as TextEffectsFont5,
+  TextEffectsJustify as TextEffectsJustify3,
+  At
+} from "kicadts";
+import { applyToPoint as applyToPoint122 } from "transformation-matrix";
+import { cju as cju3 } from "@tscircuit/circuit-json-util";
 var ConverterStage = class {
   MAX_ITERATIONS = 1000;
   iteration = 0;
@@ -81686,13 +81732,13 @@ var ConverterStage = class {
 };
 var InitializeSchematicStage = class extends ConverterStage {
   _step() {
-    const { kicadSch } = this.ctx;
+    const { kicadSch, schematicPaperSize } = this.ctx;
     if (!kicadSch) {
       throw new Error("KicadSch instance not initialized in context");
     }
     kicadSch.version = 20250114;
     const paper = new Paper;
-    paper.size = "A4";
+    paper.size = schematicPaperSize?.name ?? "A4";
     kicadSch.paper = paper;
     kicadSch.uuid = new Uuid(crypto.randomUUID());
     this.finished = true;
@@ -81701,49 +81747,62 @@ var InitializeSchematicStage = class extends ConverterStage {
     return this.ctx.kicadSch;
   }
 };
+function getLibraryId(sourceComp, schematicComp) {
+  if (sourceComp.type !== "source_component") {
+    if (schematicComp.symbol_name) {
+      return `Custom:${schematicComp.symbol_name}`;
+    }
+    return "Device:Component";
+  }
+  if (sourceComp.ftype === "simple_resistor") {
+    return `Device:R_${sourceComp.source_component_id}`;
+  }
+  if (sourceComp.ftype === "simple_capacitor") {
+    return `Device:C_${sourceComp.source_component_id}`;
+  }
+  if (sourceComp.ftype === "simple_inductor") {
+    return `Device:L_${sourceComp.source_component_id}`;
+  }
+  if (sourceComp.ftype === "simple_diode") {
+    return `Device:D_${sourceComp.source_component_id}`;
+  }
+  if (sourceComp.ftype === "simple_chip") {
+    return `Device:U_${sourceComp.source_component_id}`;
+  }
+  if (schematicComp.symbol_name) {
+    return `Custom:${schematicComp.symbol_name}`;
+  }
+  return `Device:Component_${sourceComp.source_component_id}`;
+}
 var AddLibrarySymbolsStage = class extends ConverterStage {
   _step() {
     const { kicadSch, db } = this.ctx;
-    const schematicComponents = db.schematic_component.list();
-    if (schematicComponents.length === 0) {
-      this.finished = true;
-      return;
-    }
     const libSymbols = new LibSymbols;
-    const symbolsToCreate = /* @__PURE__ */ new Set;
-    for (const comp of schematicComponents) {
-      if (comp.symbol_name) {
-        symbolsToCreate.add(comp.symbol_name);
-      } else {
-        const sourceComp = comp.source_component_id ? db.source_component.get(comp.source_component_id) : null;
-        if (sourceComp?.ftype === "simple_chip") {
-          symbolsToCreate.add(`generic_chip_${comp.source_component_id}`);
-        }
-      }
-    }
     const librarySymbols = [];
-    for (const symbolName of symbolsToCreate) {
-      let symbolData = symbols[symbolName];
-      let exampleComp;
-      let sourceComp;
-      if (symbolName.startsWith("generic_chip_")) {
-        const sourceCompId = symbolName.replace("generic_chip_", "");
-        sourceComp = db.source_component.get(sourceCompId);
-        exampleComp = schematicComponents.find((c) => c.source_component_id === sourceCompId);
-        if (exampleComp) {
-          symbolData = this.createGenericChipSymbolData(exampleComp, db);
-        }
-      } else {
-        symbolData = symbols[symbolName];
-        if (!symbolData) {
-          console.warn(`Symbol ${symbolName} not found in schematic-symbols`);
-          continue;
+    const schematicComponents = db.schematic_component.list();
+    for (const schematicComponent of schematicComponents) {
+      const libSymbol = this.createLibrarySymbolForComponent(schematicComponent);
+      if (libSymbol) {
+        librarySymbols.push(libSymbol);
+      }
+    }
+    const netLabels = db.schematic_net_label?.list?.() || [];
+    for (const netLabel of netLabels) {
+      if (netLabel.symbol_name) {
+        const isPower = netLabel.source_net_id ? db.source_net.get(netLabel.source_net_id)?.is_power : false;
+        const isGround = netLabel.source_net_id ? db.source_net.get(netLabel.source_net_id)?.is_ground : false;
+        const isPowerOrGround = isPower || isGround;
+        if (isPowerOrGround) {
+          const libSymbol = this.createLibrarySymbolForNetLabel({
+            netLabel,
+            isPower: isPower ?? false,
+            isGround: isGround ?? false
+          });
+          if (libSymbol) {
+            librarySymbols.push(libSymbol);
+          }
         }
-        exampleComp = schematicComponents.find((c) => c.symbol_name === symbolName);
-        sourceComp = exampleComp && exampleComp.source_component_id ? db.source_component.get(exampleComp.source_component_id) : null;
       }
-      const libSymbol = this.createLibrarySymbolFromSchematicSymbol(symbolName, symbolData, sourceComp);
-      librarySymbols.push(libSymbol);
     }
     libSymbols.symbols = librarySymbols;
     if (kicadSch) {
@@ -81751,6 +81810,59 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     }
     this.finished = true;
   }
+  createLibrarySymbolForComponent(schematicComponent) {
+    const { db } = this.ctx;
+    const sourceComp = schematicComponent.source_component_id ? db.source_component.get(schematicComponent.source_component_id) : null;
+    if (!sourceComp)
+      return null;
+    const symbolName = schematicComponent.symbol_name || (sourceComp.ftype === "simple_chip" ? `generic_chip_${schematicComponent.source_component_id}` : null);
+    if (!symbolName)
+      return null;
+    const symbolData = this.getSymbolData(symbolName, schematicComponent);
+    if (!symbolData)
+      return null;
+    const libId = getLibraryId(sourceComp, schematicComponent);
+    const isChip = sourceComp.ftype === "simple_chip";
+    const footprintName = sourceComp.ftype || "";
+    return this.createLibrarySymbol({
+      libId,
+      symbolData,
+      isChip,
+      schematicComponent,
+      description: this.getDescription(sourceComp),
+      keywords: this.getKeywords(sourceComp),
+      fpFilters: this.getFpFilters(sourceComp),
+      footprintRef: footprintName ? `tscircuit:${footprintName}` : ""
+    });
+  }
+  createLibrarySymbolForNetLabel({
+    netLabel,
+    isPower,
+    isGround
+  }) {
+    const symbolName = netLabel.symbol_name;
+    if (!symbolName)
+      return null;
+    const symbolData = symbols[symbolName];
+    if (!symbolData)
+      return null;
+    const libId = `Custom:${symbolName}`;
+    return this.createLibrarySymbol({
+      libId,
+      symbolData,
+      isChip: false,
+      schematicComponent: undefined,
+      description: isPower ? "Power net label" : isGround ? "Ground net label" : "Net symbol",
+      keywords: isPower ? "power net" : isGround ? "ground net" : "net",
+      fpFilters: ""
+    });
+  }
+  getSymbolData(symbolName, schematicComponent) {
+    if (symbolName.startsWith("generic_chip_")) {
+      return this.createGenericChipSymbolData(schematicComponent, this.ctx.db);
+    }
+    return symbols[symbolName] || null;
+  }
   createGenericChipSymbolData(schematicComp, db) {
     const schematicPorts = db.schematic_port.list().filter((p) => p.schematic_component_id === schematicComp.schematic_component_id).sort((a, b) => (a.pin_number || 0) - (b.pin_number || 0));
     const width = schematicComp.size?.width || 1.5;
@@ -81782,8 +81894,16 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       size: { width, height }
     };
   }
-  createLibrarySymbolFromSchematicSymbol(symbolName, symbolData, sourceComp) {
-    const libId = this.getLibraryId(symbolName, sourceComp);
+  createLibrarySymbol({
+    libId,
+    symbolData,
+    isChip,
+    schematicComponent,
+    description,
+    keywords,
+    fpFilters,
+    footprintRef = ""
+  }) {
     const symbol = new SchematicSymbol({
       libraryId: libId,
       excludeFromSim: false,
@@ -81791,33 +81911,43 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       onBoard: true
     });
     const pinNumbers = new SymbolPinNumbers;
-    pinNumbers.hide = sourceComp?.ftype !== "simple_chip";
+    pinNumbers.hide = !isChip;
     symbol._sxPinNumbers = pinNumbers;
     const pinNames = new SymbolPinNames;
-    pinNames.offset = sourceComp?.ftype === "simple_chip" ? 1.27 : 0;
+    pinNames.offset = isChip ? 1.27 : 0;
     symbol._sxPinNames = pinNames;
-    this.addSymbolProperties(symbol, libId, sourceComp);
-    const isChip = sourceComp?.ftype === "simple_chip";
-    const drawingSymbol = this.createDrawingSubsymbol(libId, symbolData, isChip);
+    this.addSymbolProperties({
+      symbol,
+      libId,
+      description,
+      keywords,
+      fpFilters,
+      footprintRef
+    });
+    const drawingSymbol = this.createDrawingSubsymbol({
+      libId,
+      symbolData,
+      isChip
+    });
     symbol.subSymbols.push(drawingSymbol);
-    const pinSymbol = this.createPinSubsymbol(libId, symbolData, isChip);
+    const pinSymbol = this.createPinSubsymbol({
+      libId,
+      symbolData,
+      isChip,
+      schematicComponent
+    });
     symbol.subSymbols.push(pinSymbol);
     symbol._sxEmbeddedFonts = new EmbeddedFonts(false);
     return symbol;
   }
-  getLibraryId(symbolName, sourceComp) {
-    if (sourceComp?.ftype === "simple_resistor") {
-      return "Device:R";
-    }
-    if (sourceComp?.ftype === "simple_capacitor") {
-      return "Device:C";
-    }
-    if (sourceComp?.ftype === "simple_chip") {
-      return "Device:U";
-    }
-    return `Custom:${symbolName}`;
-  }
-  addSymbolProperties(symbol, libId, sourceComp) {
+  addSymbolProperties({
+    symbol,
+    libId,
+    description,
+    keywords,
+    fpFilters,
+    footprintRef = ""
+  }) {
     const refPrefix = libId.split(":")[1]?.[0] || "U";
     const properties = [
       {
@@ -81830,7 +81960,7 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       { key: "Value", value: refPrefix, id: 1, at: [0, 0, 90], hide: false },
       {
         key: "Footprint",
-        value: "",
+        value: footprintRef,
         id: 2,
         at: [-1.778, 0, 90],
         hide: true
@@ -81844,21 +81974,21 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       },
       {
         key: "Description",
-        value: this.getDescription(sourceComp),
+        value: description,
         id: 4,
         at: [0, 0, 0],
         hide: true
       },
       {
         key: "ki_keywords",
-        value: this.getKeywords(sourceComp),
+        value: keywords,
         id: 5,
         at: [0, 0, 0],
         hide: true
       },
       {
         key: "ki_fp_filters",
-        value: this.getFpFilters(sourceComp),
+        value: fpFilters,
         id: 6,
         at: [0, 0, 0],
         hide: true
@@ -81901,7 +82031,11 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       return "*";
     return "*";
   }
-  createDrawingSubsymbol(libId, symbolData, isChip = false) {
+  createDrawingSubsymbol({
+    libId,
+    symbolData,
+    isChip
+  }) {
     const drawingSymbol = new SchematicSymbol({
       libraryId: `${libId.split(":")[1]}_0_1`
     });
@@ -81909,15 +82043,31 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     for (const primitive of symbolData.primitives || []) {
       if (primitive.type === "path" && primitive.points) {
         const fillType = isChip ? "background" : "none";
-        const polyline = this.createPolylineFromPoints(primitive.points, symbolScale, fillType);
+        const polyline = this.createPolylineFromPoints({
+          points: primitive.points,
+          scale: symbolScale,
+          center: symbolData.center,
+          fillType
+        });
         drawingSymbol.polylines.push(polyline);
       }
     }
     return drawingSymbol;
   }
-  createPolylineFromPoints(points, scale32, fillType = "none") {
+  createPolylineFromPoints({
+    points,
+    scale: scale42,
+    center,
+    fillType
+  }) {
     const polyline = new SymbolPolyline;
-    const xyPoints = points.map((p) => new Xy(p.x * scale32, p.y * scale32));
+    const cx = center?.x ?? 0;
+    const cy = center?.y ?? 0;
+    const scaleMatrix = createScaleMatrix(scale42, scale42);
+    const xyPoints = points.map((p) => {
+      const translated = applyToPoint3(scaleMatrix, { x: p.x - cx, y: p.y - cy });
+      return new Xy(translated.x, translated.y);
+    });
     const pts = new Pts(xyPoints);
     polyline.points = pts;
     const stroke = new Stroke;
@@ -81929,7 +82079,12 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     polyline.fill = fill;
     return polyline;
   }
-  createPinSubsymbol(libId, symbolData, isChip = false) {
+  createPinSubsymbol({
+    libId,
+    symbolData,
+    isChip,
+    schematicComponent
+  }) {
     const pinSymbol = new SchematicSymbol({
       libraryId: `${libId.split(":")[1]}_1_1`
     });
@@ -81938,9 +82093,9 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       const pin = new SymbolPin;
       pin.pinElectricalType = "passive";
       pin.pinGraphicStyle = "line";
-      const { x, y, angle } = this.calculatePinPosition(port, symbolData.center, symbolData.size, isChip);
+      const { x, y, angle } = this.calculatePinPosition(port, symbolData.center, symbolData.size, isChip, i, schematicComponent);
       pin.at = [x, y, angle];
-      pin.length = isChip ? 2.54 : 1.27;
+      pin.length = isChip ? 6 : 1.27;
       const nameFont = new TextEffectsFont;
       nameFont.size = { height: 1.27, width: 1.27 };
       const nameEffects = new TextEffects({ font: nameFont });
@@ -81958,17 +82113,50 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
     }
     return pinSymbol;
   }
-  calculatePinPosition(port, center, size, isChip) {
+  calculatePinPosition(port, center, size, isChip, portIndex, schematicComponent) {
     const symbolScale = this.ctx.c2kMatSch?.a || 15;
-    const dx = port.x - center.x;
-    const dy = port.y - center.y;
-    let x = port.x * symbolScale;
-    let y = port.y * symbolScale;
-    const chipPinLength = 2.54;
+    let portX = port.x ?? 0;
+    let portY = port.y ?? 0;
+    let usingCircuitJsonPort = false;
+    if (portIndex !== undefined && schematicComponent) {
+      const schematicPorts = this.ctx.db.schematic_port.list().filter((p) => p.schematic_component_id === schematicComponent.schematic_component_id).sort((a, b) => (a.pin_number || 0) - (b.pin_number || 0));
+      if (schematicPorts[portIndex]) {
+        const schPort = schematicPorts[portIndex];
+        portX = schPort.center.x - schematicComponent.center.x;
+        portY = schPort.center.y - schematicComponent.center.y;
+        usingCircuitJsonPort = true;
+      }
+    }
+    let dx;
+    let dy;
+    if (usingCircuitJsonPort) {
+      dx = portX;
+      dy = portY;
+    } else {
+      const cx = center?.x ?? 0;
+      const cy = center?.y ?? 0;
+      dx = portX - cx;
+      dy = portY - cy;
+    }
+    const scaleMatrix = createScaleMatrix(symbolScale, symbolScale);
+    const scaled = applyToPoint3(scaleMatrix, { x: dx, y: dy });
+    let isHorizontalPin;
+    if (isChip && size) {
+      const halfWidth = size.width / 2;
+      const halfHeight = size.height / 2;
+      const normalizedDx = Math.abs(dx) / halfWidth;
+      const normalizedDy = Math.abs(dy) / halfHeight;
+      isHorizontalPin = normalizedDx > normalizedDy;
+    } else {
+      isHorizontalPin = Math.abs(dx) > Math.abs(dy);
+    }
+    let x = scaled.x;
+    let y = scaled.y;
+    const chipPinLength = 6;
     if (isChip && size) {
       const halfWidth = size.width / 2 * symbolScale;
       const halfHeight = size.height / 2 * symbolScale;
-      if (Math.abs(dx) > Math.abs(dy)) {
+      if (isHorizontalPin) {
         x = dx > 0 ? halfWidth : -halfWidth;
         y = dy * symbolScale;
       } else {
@@ -81977,7 +82165,7 @@ var AddLibrarySymbolsStage = class extends ConverterStage {
       }
     }
     let angle = 0;
-    if (Math.abs(dx) > Math.abs(dy)) {
+    if (isHorizontalPin) {
       if (dx > 0) {
         if (isChip) {
           angle = 180;
@@ -82042,7 +82230,7 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
         continue;
       if (!this.ctx.c2kMatSch)
         continue;
-      const { x, y } = applyToPoint3(this.ctx.c2kMatSch, {
+      const { x, y } = applyToPoint23(this.ctx.c2kMatSch, {
         x: schematicComponent.center.x,
         y: schematicComponent.center.y
       });
@@ -82057,7 +82245,7 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
         uuid,
         fieldsAutoplaced: true
       });
-      const libId = this.getLibraryId(sourceComponent);
+      const libId = getLibraryId(sourceComponent, schematicComponent);
       const symLibId = new SymbolLibId(libId);
       symbol._sxLibId = symLibId;
       const { reference, value, description } = this.getComponentMetadata(sourceComponent);
@@ -82125,7 +82313,7 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
     const schematicTexts = this.ctx.db.schematic_text?.list?.()?.filter((t2) => t2.schematic_component_id === schematicComponent.schematic_component_id) || [];
     const refText = schematicTexts.find((t2) => t2.text && t2.text.length > 0);
     if (refText && this.ctx.c2kMatSch) {
-      const refTextPos2 = applyToPoint3(this.ctx.c2kMatSch, {
+      const refTextPos2 = applyToPoint23(this.ctx.c2kMatSch, {
         x: refText.position.x,
         y: refText.position.y
       });
@@ -82151,34 +82339,19 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
         }
       }
     }
-    const refTextPos = refTextPrimitive && this.ctx.c2kMatSch ? applyToPoint3(this.ctx.c2kMatSch, {
-      x: schematicComponent.center.x + refTextPrimitive.x,
-      y: schematicComponent.center.y + refTextPrimitive.y
+    const symbolCenter = symbol.center || { x: 0, y: 0 };
+    const isVertical = symbolName.includes("_down") || symbolName.includes("_up");
+    const horizontalTextOffset = isVertical ? 0.15 : 0;
+    const refTextPos = refTextPrimitive && this.ctx.c2kMatSch ? applyToPoint23(this.ctx.c2kMatSch, {
+      x: schematicComponent.center.x + (refTextPrimitive.x - symbolCenter.x) + horizontalTextOffset,
+      y: schematicComponent.center.y + (refTextPrimitive.y - symbolCenter.y)
     }) : { x: symbolKicadPos.x, y: symbolKicadPos.y - 6 };
-    const valTextPos = valTextPrimitive && this.ctx.c2kMatSch ? applyToPoint3(this.ctx.c2kMatSch, {
-      x: schematicComponent.center.x + valTextPrimitive.x,
-      y: schematicComponent.center.y + valTextPrimitive.y
+    const valTextPos = valTextPrimitive && this.ctx.c2kMatSch ? applyToPoint23(this.ctx.c2kMatSch, {
+      x: schematicComponent.center.x + (valTextPrimitive.x - symbolCenter.x) + horizontalTextOffset,
+      y: schematicComponent.center.y + (valTextPrimitive.y - symbolCenter.y)
     }) : { x: symbolKicadPos.x, y: symbolKicadPos.y + 6 };
     return { refTextPos, valTextPos };
   }
-  getLibraryId(sourceComp) {
-    if (sourceComp.ftype === "simple_resistor") {
-      return "Device:R";
-    }
-    if (sourceComp.ftype === "simple_capacitor") {
-      return "Device:C";
-    }
-    if (sourceComp.ftype === "simple_inductor") {
-      return "Device:L";
-    }
-    if (sourceComp.ftype === "simple_diode") {
-      return "Device:D";
-    }
-    if (sourceComp.ftype === "simple_chip") {
-      return "Device:U";
-    }
-    return "Device:Component";
-  }
   getComponentMetadata(sourceComp) {
     const name = sourceComp.name || "?";
     if (sourceComp.ftype === "simple_resistor") {
@@ -82240,6 +82413,172 @@ var AddSchematicSymbolsStage = class extends ConverterStage {
     return this.ctx.kicadSch;
   }
 };
+var AddSchematicNetLabelsStage = class extends ConverterStage {
+  _step() {
+    const { kicadSch, db } = this.ctx;
+    const netLabels = db.schematic_net_label?.list?.() || [];
+    if (netLabels.length === 0) {
+      this.finished = true;
+      return;
+    }
+    if (!this.ctx.c2kMatSch) {
+      this.finished = true;
+      return;
+    }
+    const symbols3 = [];
+    const globalLabels = [];
+    for (const netLabel of netLabels) {
+      const labelText = netLabel.text || "";
+      const symbolName = netLabel.symbol_name;
+      if (symbolName) {
+        const symbol = this.createSymbolFromNetLabel(netLabel, labelText, symbolName);
+        if (symbol) {
+          symbols3.push(symbol);
+        }
+      } else {
+        const label = this.createGlobalLabel(netLabel, labelText);
+        if (label) {
+          globalLabels.push(label);
+        }
+      }
+    }
+    if (kicadSch && symbols3.length > 0) {
+      const existingSymbols = kicadSch.symbols || [];
+      kicadSch.symbols = [...existingSymbols, ...symbols3];
+    }
+    if (kicadSch && globalLabels.length > 0) {
+      kicadSch.globalLabels = [
+        ...kicadSch.globalLabels || [],
+        ...globalLabels
+      ];
+    }
+    this.finished = true;
+  }
+  createSymbolFromNetLabel(netLabel, labelText, symbolName) {
+    if (!this.ctx.c2kMatSch)
+      return null;
+    const { x, y } = applyToPoint32(this.ctx.c2kMatSch, {
+      x: netLabel.anchor_position?.x ?? netLabel.center?.x ?? 0,
+      y: netLabel.anchor_position?.y ?? netLabel.center?.y ?? 0
+    });
+    const uuid = crypto.randomUUID();
+    const symbol = new SchematicSymbol3({
+      at: [x, y, 0],
+      unit: 1,
+      excludeFromSim: false,
+      inBom: true,
+      onBoard: true,
+      dnp: false,
+      uuid,
+      fieldsAutoplaced: true
+    });
+    const libId = `Custom:${symbolName}`;
+    const symLibId = new SymbolLibId2(libId);
+    symbol._sxLibId = symLibId;
+    const isUpSymbol = symbolName.includes("_up") || symbolName.toLowerCase().includes("vcc");
+    const referenceOffset = isUpSymbol ? -4 : 4;
+    const valueOffset = isUpSymbol ? -6 : 6;
+    const referenceProperty = new SymbolProperty3({
+      key: "Reference",
+      value: labelText,
+      id: 0,
+      at: [x, y + referenceOffset, 0],
+      effects: this.createTextEffects(1.27, false)
+    });
+    const valueProperty = new SymbolProperty3({
+      key: "Value",
+      value: labelText,
+      id: 1,
+      at: [x, y + valueOffset, 0],
+      effects: this.createTextEffects(1.27, true)
+    });
+    const footprintProperty = new SymbolProperty3({
+      key: "Footprint",
+      value: "",
+      id: 2,
+      at: [x - 1.778, y, 90],
+      effects: this.createTextEffects(1.27, true)
+    });
+    const datasheetProperty = new SymbolProperty3({
+      key: "Datasheet",
+      value: "~",
+      id: 3,
+      at: [x, y, 0],
+      effects: this.createTextEffects(1.27, true)
+    });
+    const descriptionProperty = new SymbolProperty3({
+      key: "Description",
+      value: `Power/Net symbol: ${labelText}`,
+      id: 4,
+      at: [x, y, 0],
+      effects: this.createTextEffects(1.27, true)
+    });
+    symbol.properties.push(referenceProperty, valueProperty, footprintProperty, datasheetProperty, descriptionProperty);
+    const pin = new SymbolPin3;
+    pin.numberString = "1";
+    pin.uuid = crypto.randomUUID();
+    symbol.pins.push(pin);
+    const { kicadSch } = this.ctx;
+    const instances = new SymbolInstances2;
+    const project = new SymbolInstancesProject2("");
+    const path27 = new SymbolInstancePath2(`/${kicadSch?.uuid?.value || ""}`);
+    path27.reference = labelText;
+    path27.unit = 1;
+    project.paths.push(path27);
+    instances.projects.push(project);
+    symbol._sxInstances = instances;
+    return symbol;
+  }
+  createGlobalLabel(netLabel, labelText) {
+    if (!this.ctx.c2kMatSch || !this.ctx.kicadSch)
+      return null;
+    const { x, y } = applyToPoint32(this.ctx.c2kMatSch, {
+      x: netLabel.anchor_position?.x ?? netLabel.center?.x ?? 0,
+      y: netLabel.anchor_position?.y ?? netLabel.center?.y ?? 0
+    });
+    const anchorSide = netLabel.anchor_side || "left";
+    const angleMap = {
+      left: 0,
+      right: 180,
+      top: 270,
+      bottom: 90
+    };
+    const angle = angleMap[anchorSide] || 0;
+    const justifyMap = {
+      left: { horizontal: "left" },
+      right: { horizontal: "right" },
+      top: { vertical: "top" },
+      bottom: { vertical: "bottom" }
+    };
+    const justify = justifyMap[anchorSide] || {};
+    const effects = this.createTextEffects(1.27, false);
+    if (Object.keys(justify).length > 0) {
+      effects.justify = new TextEffectsJustify2(justify);
+    }
+    const globalLabel = new GlobalLabel({
+      value: labelText,
+      at: [x, y, angle],
+      effects,
+      uuid: crypto.randomUUID(),
+      fieldsAutoplaced: true
+    });
+    return globalLabel;
+  }
+  createTextEffects(size, hide = false) {
+    const font = new TextEffectsFont3;
+    font.size = { height: size, width: size };
+    return new TextEffects3({
+      font,
+      hiddenText: hide
+    });
+  }
+  getOutput() {
+    if (!this.ctx.kicadSch) {
+      throw new Error("kicadSch is not initialized");
+    }
+    return this.ctx.kicadSch;
+  }
+};
 var AddSchematicTracesStage = class extends ConverterStage {
   _step() {
     const { kicadSch, db } = this.ctx;
@@ -82272,11 +82611,11 @@ var AddSchematicTracesStage = class extends ConverterStage {
     if (!this.ctx.c2kMatSch) {
       throw new Error("Schematic transformation matrix not initialized in context");
     }
-    const from = applyToPoint23(this.ctx.c2kMatSch, {
+    const from = applyToPoint42(this.ctx.c2kMatSch, {
       x: edge.from.x,
       y: edge.from.y
     });
-    const to = applyToPoint23(this.ctx.c2kMatSch, {
+    const to = applyToPoint42(this.ctx.c2kMatSch, {
       x: edge.to.x,
       y: edge.to.y
     });
@@ -82297,12 +82636,12 @@ var AddSchematicTracesStage = class extends ConverterStage {
     if (!this.ctx.c2kMatSch) {
       throw new Error("Schematic transformation matrix not initialized in context");
     }
-    const { x, y } = applyToPoint23(this.ctx.c2kMatSch, {
+    const { x, y } = applyToPoint42(this.ctx.c2kMatSch, {
       x: junction.x,
       y: junction.y
     });
     const kicadJunction = new Junction({
-      at: [x, y, 0],
+      at: [x, y],
       diameter: 0
     });
     kicadJunction.uuid = crypto.randomUUID();
@@ -82332,6 +82671,68 @@ var AddSheetInstancesStage = class extends ConverterStage {
     return this.ctx.kicadSch;
   }
 };
+function getSchematicBoundsAndCenter(db) {
+  const schematicComponents = db.schematic_component.list();
+  const schematicTraces = db.schematic_trace.list();
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const component of schematicComponents) {
+    const width = component.size?.width ?? 0;
+    const height = component.size?.height ?? 0;
+    minX = Math.min(minX, component.center.x - width / 2);
+    minY = Math.min(minY, component.center.y - height / 2);
+    maxX = Math.max(maxX, component.center.x + width / 2);
+    maxY = Math.max(maxY, component.center.y + height / 2);
+  }
+  for (const trace of schematicTraces) {
+    for (const edge of trace.edges) {
+      minX = Math.min(minX, edge.from.x, edge.to.x);
+      minY = Math.min(minY, edge.from.y, edge.to.y);
+      maxX = Math.max(maxX, edge.from.x, edge.to.x);
+      maxY = Math.max(maxY, edge.from.y, edge.to.y);
+    }
+  }
+  if (minX === Infinity) {
+    minX = 0;
+    minY = 0;
+    maxX = 0;
+    maxY = 0;
+  }
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  return {
+    center: {
+      x: centerX,
+      y: centerY
+    },
+    bounds: {
+      minX,
+      minY,
+      maxX,
+      maxY
+    }
+  };
+}
+var PAPER_SIZES = [
+  { name: "A4", width: 297, height: 210 },
+  { name: "A3", width: 420, height: 297 },
+  { name: "A2", width: 594, height: 420 },
+  { name: "A1", width: 841, height: 594 },
+  { name: "A0", width: 1189, height: 841 }
+];
+function selectSchematicPaperSize(contentWidth, contentHeight, paddingMm = 20) {
+  const requiredWidth = contentWidth + 2 * paddingMm;
+  const requiredHeight = contentHeight + 2 * paddingMm;
+  for (let i = 0;i < PAPER_SIZES.length; i++) {
+    const paperSize = PAPER_SIZES[i];
+    if (requiredWidth <= paperSize.width && requiredHeight <= paperSize.height) {
+      return paperSize;
+    }
+  }
+  return PAPER_SIZES[PAPER_SIZES.length - 1];
+}
 var CircuitJsonToKicadSchConverter = class {
   ctx;
   pipeline;
@@ -82342,21 +82743,28 @@ var CircuitJsonToKicadSchConverter = class {
   }
   constructor(circuitJson) {
     const CIRCUIT_JSON_SCALE_FACTOR = 15;
-    const KICAD_CENTER_X = 95.25;
-    const KICAD_CENTER_Y = 73.66;
+    const db = cju(circuitJson);
+    const { center, bounds } = getSchematicBoundsAndCenter(db);
+    const schematicWidthMm = (bounds.maxX - bounds.minX) * CIRCUIT_JSON_SCALE_FACTOR;
+    const schematicHeightMm = (bounds.maxY - bounds.minY) * CIRCUIT_JSON_SCALE_FACTOR;
+    const paperSize = selectSchematicPaperSize(schematicWidthMm, schematicHeightMm);
+    const KICAD_CENTER_X = paperSize.width / 2;
+    const KICAD_CENTER_Y = paperSize.height / 2;
     this.ctx = {
-      db: cju(circuitJson),
+      db,
       circuitJson,
       kicadSch: new KicadSch({
         generator: "circuit-json-to-kicad",
         generatorVersion: "0.0.1"
       }),
-      c2kMatSch: compose(translate(KICAD_CENTER_X, KICAD_CENTER_Y), scale6(CIRCUIT_JSON_SCALE_FACTOR, -CIRCUIT_JSON_SCALE_FACTOR))
+      schematicPaperSize: paperSize,
+      c2kMatSch: compose(translate(KICAD_CENTER_X, KICAD_CENTER_Y), scale6(CIRCUIT_JSON_SCALE_FACTOR, -CIRCUIT_JSON_SCALE_FACTOR), translate(-center.x, -center.y))
     };
     this.pipeline = [
       new InitializeSchematicStage(circuitJson, this.ctx),
       new AddLibrarySymbolsStage(circuitJson, this.ctx),
       new AddSchematicSymbolsStage(circuitJson, this.ctx),
+      new AddSchematicNetLabelsStage(circuitJson, this.ctx),
       new AddSchematicTracesStage(circuitJson, this.ctx),
       new AddSheetInstancesStage(circuitJson, this.ctx)
     ];
@@ -82436,36 +82844,426 @@ var AddNetsStage = class extends ConverterStage {
     if (!kicadPcb) {
       throw new Error("KicadPcb instance not initialized in context");
     }
-    if (!this.ctx.pcbNetMap) {
-      this.ctx.pcbNetMap = /* @__PURE__ */ new Map;
-    }
-    const pcbTraces = this.ctx.db.pcb_trace.list();
-    const netNames = /* @__PURE__ */ new Set;
-    netNames.add("GND");
-    for (const trace of pcbTraces) {
-      if (trace.route && trace.route.length > 0) {
-        const netName = `Net-${trace.pcb_trace_id}`;
-        netNames.add(netName);
-      }
-    }
-    let netNumber = 0;
-    for (const netName of Array.from(netNames).sort()) {
-      const net2 = new PcbNet(netNumber, netName);
-      const nets = kicadPcb.nets;
-      nets.push(net2);
-      kicadPcb.nets = nets;
-      this.ctx.pcbNetMap.set(netName, netNumber);
+    this.ctx.pcbNetMap = /* @__PURE__ */ new Map;
+    const netNameByKey = /* @__PURE__ */ new Map;
+    const sourceNets = this.ctx.db.source_net?.list() ?? [];
+    for (const sourceNet of sourceNets) {
+      const connectivityKey = sourceNet.subcircuit_connectivity_map_key || sourceNet.source_net_id;
+      if (!connectivityKey)
+        continue;
+      const candidateName = sourceNet.name || sourceNet.source_net_id || "";
+      const netName = candidateName && candidateName.trim().length > 0 ? candidateName : connectivityKey;
+      netNameByKey.set(connectivityKey, netName);
+    }
+    const sourceTraces = this.ctx.db.source_trace?.list() ?? [];
+    for (const sourceTrace of sourceTraces) {
+      let connectivityKey = sourceTrace.subcircuit_connectivity_map_key;
+      if (!connectivityKey && sourceTrace.connected_source_net_ids?.length) {
+        for (const sourceNetId of sourceTrace.connected_source_net_ids) {
+          const connectedNet = this.ctx.db.source_net?.get(sourceNetId);
+          if (connectedNet?.subcircuit_connectivity_map_key && connectedNet.subcircuit_connectivity_map_key.length > 0) {
+            connectivityKey = connectedNet.subcircuit_connectivity_map_key;
+            break;
+          }
+        }
+      }
+      if (!connectivityKey)
+        continue;
+      if (!netNameByKey.has(connectivityKey)) {
+        const candidateName = sourceTrace.display_name || sourceTrace.source_trace_id || "";
+        const netName = candidateName && candidateName.trim().length > 0 ? candidateName : connectivityKey;
+        netNameByKey.set(connectivityKey, netName);
+      }
+    }
+    const sortedEntries = Array.from(netNameByKey.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    const nets = [];
+    nets.push(new PcbNet(0, ""));
+    let netNumber = 1;
+    for (const [connectivityKey, netName] of sortedEntries) {
+      const pcbNet = new PcbNet(netNumber, netName);
+      nets.push(pcbNet);
+      const netInfo = { id: netNumber, name: netName };
+      this.ctx.pcbNetMap.set(connectivityKey, netInfo);
       netNumber++;
     }
+    kicadPcb.nets = nets;
     this.finished = true;
   }
   getOutput() {
     return this.ctx.kicadPcb;
   }
 };
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  let result = "";
+  for (let i = 0;i < 4; i++) {
+    let h = hash;
+    for (let j = 0;j < str.length; j++) {
+      h = (h << 5) - h + str.charCodeAt(j) + i * 31;
+      h = h & h;
+    }
+    result += Math.abs(h).toString(16).padStart(8, "0");
+  }
+  return result;
+}
+function generateDeterministicUuid(data) {
+  const hash = simpleHash(data);
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+}
+function createSmdPadFromCircuitJson({
+  pcbPad,
+  componentCenter,
+  padNumber,
+  componentRotation = 0,
+  netInfo,
+  componentId
+}) {
+  let padX;
+  let padY;
+  if ("x" in pcbPad && "y" in pcbPad) {
+    padX = pcbPad.x;
+    padY = pcbPad.y;
+  } else if ("points" in pcbPad && Array.isArray(pcbPad.points)) {
+    const points = pcbPad.points;
+    padX = points.reduce((sum, p) => sum + p.x, 0) / points.length;
+    padY = points.reduce((sum, p) => sum + p.y, 0) / points.length;
+  } else {
+    throw new Error("Pad must have either x/y coordinates or points array");
+  }
+  const cj2kicadMatrix = compose2(componentRotation !== 0 ? rotate(componentRotation * Math.PI / 180) : { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }, scale22(1, -1), translate2(-componentCenter.x, -componentCenter.y));
+  const rotatedPos = applyToPoint52(cj2kicadMatrix, {
+    x: padX,
+    y: padY
+  });
+  const layerMap = {
+    top: "F.Cu",
+    bottom: "B.Cu"
+  };
+  const padLayer = layerMap[pcbPad.layer] || "F.Cu";
+  let padShape;
+  let padSize;
+  let padOptions;
+  let padPrimitives;
+  if (pcbPad.shape === "circle") {
+    padShape = "circle";
+    padSize = [
+      "radius" in pcbPad ? pcbPad.radius * 2 : 0.5,
+      "radius" in pcbPad ? pcbPad.radius * 2 : 0.5
+    ];
+  } else if (pcbPad.shape === "polygon" && "points" in pcbPad) {
+    const points = pcbPad.points;
+    const pointTransformMatrix = compose2(scale22(1, -1), translate2(-padX, -padY));
+    const relativePoints = points.map((p) => {
+      const transformed = applyToPoint52(pointTransformMatrix, { x: p.x, y: p.y });
+      return new Xy3(transformed.x, transformed.y);
+    });
+    const grPoly = new PadPrimitiveGrPoly;
+    grPoly.contours = [new Pts3(relativePoints)];
+    grPoly.width = 0;
+    grPoly.filled = true;
+    padPrimitives = new PadPrimitives;
+    padPrimitives.addGraphic(grPoly);
+    padShape = "custom";
+    padOptions = new PadOptions;
+    padOptions.anchor = "circle";
+    padSize = [0.2, 0.2];
+  } else {
+    padShape = "rect";
+    padSize = [
+      "width" in pcbPad ? pcbPad.width : 0.5,
+      "height" in pcbPad ? pcbPad.height : 0.5
+    ];
+  }
+  const padData = `pad:${componentId}:${padNumber}:${rotatedPos.x},${rotatedPos.y}`;
+  const pad = new FootprintPad({
+    number: String(padNumber),
+    padType: "smd",
+    shape: padShape,
+    at: [rotatedPos.x, rotatedPos.y, 0],
+    size: padSize,
+    layers: [
+      `${padLayer}`,
+      `${padLayer === "F.Cu" ? "F" : "B"}.Paste`,
+      `${padLayer === "F.Cu" ? "F" : "B"}.Mask`
+    ],
+    uuid: generateDeterministicUuid(padData)
+  });
+  if (padOptions) {
+    pad.options = padOptions;
+  }
+  if (padPrimitives) {
+    pad.primitives = padPrimitives;
+  }
+  if (netInfo) {
+    pad.net = new PadNet(netInfo.id, netInfo.name);
+  }
+  return pad;
+}
+function createThruHolePadFromCircuitJson({
+  platedHole,
+  componentCenter,
+  padNumber,
+  componentRotation = 0,
+  netInfo,
+  componentId
+}) {
+  if (!(("x" in platedHole) && ("y" in platedHole))) {
+    return null;
+  }
+  const relativeX = platedHole.x - componentCenter.x;
+  const relativeY = -(platedHole.y - componentCenter.y);
+  const rotationMatrix = componentRotation !== 0 ? rotate2(componentRotation * Math.PI / 180) : identity();
+  const rotatedPos = applyToPoint62(rotationMatrix, {
+    x: relativeX,
+    y: relativeY
+  });
+  let padShape = "circle";
+  let padSize;
+  let drill;
+  let rotation = 0;
+  const hasHoleOffset = "hole_offset_x" in platedHole || "hole_offset_y" in platedHole;
+  let drillOffset;
+  if (hasHoleOffset) {
+    const rawOffset = {
+      x: platedHole.hole_offset_x ?? 0,
+      y: platedHole.hole_offset_y ?? 0
+    };
+    if (rawOffset.x !== 0 || rawOffset.y !== 0) {
+      const rotatedOffset = applyToPoint62(rotationMatrix, {
+        x: -rawOffset.x,
+        y: rawOffset.y
+      });
+      drillOffset = rotatedOffset;
+    }
+  }
+  if (platedHole.shape === "circle") {
+    padShape = "circle";
+    padSize = [platedHole.outer_diameter, platedHole.outer_diameter];
+    drill = new PadDrill({
+      diameter: platedHole.hole_diameter,
+      offset: drillOffset
+    });
+  } else if (platedHole.shape === "pill" || platedHole.shape === "oval") {
+    padShape = "oval";
+    padSize = [
+      platedHole.outer_width,
+      platedHole.outer_height
+    ];
+    drill = new PadDrill({
+      oval: true,
+      diameter: platedHole.hole_width,
+      width: platedHole.hole_height,
+      offset: drillOffset
+    });
+  } else if (platedHole.shape === "pill_hole_with_rect_pad") {
+    padShape = "rect";
+    padSize = [
+      platedHole.rect_pad_width,
+      platedHole.rect_pad_height
+    ];
+    drill = new PadDrill({
+      oval: true,
+      diameter: platedHole.hole_width,
+      width: platedHole.hole_height,
+      offset: drillOffset
+    });
+  } else if (platedHole.shape === "circular_hole_with_rect_pad") {
+    padShape = "rect";
+    padSize = [
+      platedHole.rect_pad_width,
+      platedHole.rect_pad_height
+    ];
+    drill = new PadDrill({
+      diameter: platedHole.hole_diameter,
+      offset: drillOffset
+    });
+  } else if (platedHole.shape === "rotated_pill_hole_with_rect_pad") {
+    padShape = "rect";
+    padSize = [
+      platedHole.rect_pad_width,
+      platedHole.rect_pad_height
+    ];
+    drill = new PadDrill({
+      oval: true,
+      diameter: platedHole.hole_width,
+      width: platedHole.hole_height,
+      offset: drillOffset
+    });
+    rotation = platedHole.rect_ccw_rotation || 0;
+  } else {
+    padShape = "circle";
+    padSize = [1.6, 1.6];
+    drill = new PadDrill({ diameter: 0.8, offset: drillOffset });
+  }
+  const padData = `thruhole:${componentId}:${padNumber}:${rotatedPos.x},${rotatedPos.y}`;
+  const pad = new FootprintPad2({
+    number: String(padNumber),
+    padType: "thru_hole",
+    shape: padShape,
+    at: [rotatedPos.x, rotatedPos.y, rotation],
+    size: padSize,
+    drill,
+    layers: ["*.Cu", "*.Mask"],
+    removeUnusedLayers: false,
+    uuid: generateDeterministicUuid(padData)
+  });
+  if (netInfo) {
+    pad.net = new PadNet2(netInfo.id, netInfo.name);
+  }
+  return pad;
+}
+function createNpthPadFromCircuitJson({
+  pcbHole,
+  componentCenter,
+  componentRotation = 0
+}) {
+  if (!(("x" in pcbHole) && ("y" in pcbHole))) {
+    return null;
+  }
+  const relativeX = pcbHole.x - componentCenter.x;
+  const relativeY = -(pcbHole.y - componentCenter.y);
+  const rotationMatrix = componentRotation !== 0 ? rotate3(componentRotation * Math.PI / 180) : identity2();
+  const rotatedPos = applyToPoint72(rotationMatrix, {
+    x: relativeX,
+    y: relativeY
+  });
+  let padShape = "circle";
+  let padSize;
+  let drill;
+  if (pcbHole.hole_shape === "circle") {
+    padShape = "circle";
+    const diameter = pcbHole.hole_diameter;
+    padSize = [diameter, diameter];
+    drill = new PadDrill2({
+      diameter
+    });
+  } else if (pcbHole.hole_shape === "oval") {
+    padShape = "oval";
+    const width = pcbHole.hole_width;
+    const height = pcbHole.hole_height;
+    padSize = [width, height];
+    drill = new PadDrill2({
+      oval: true,
+      diameter: width,
+      width: height
+    });
+  } else {
+    padShape = "circle";
+    const diameter = "hole_diameter" in pcbHole ? pcbHole.hole_diameter : 1;
+    padSize = [diameter, diameter];
+    drill = new PadDrill2({ diameter });
+  }
+  return new FootprintPad3({
+    number: "",
+    padType: "np_thru_hole",
+    shape: padShape,
+    at: [rotatedPos.x, rotatedPos.y, 0],
+    size: padSize,
+    drill,
+    layers: ["*.Cu", "*.Mask"],
+    removeUnusedLayers: false,
+    uuid: crypto.randomUUID()
+  });
+}
+function createFpTextFromCircuitJson({
+  textElement,
+  componentCenter,
+  componentRotation = 0
+}) {
+  if (!textElement.text || !textElement.anchor_position) {
+    return null;
+  }
+  const relativeX = textElement.anchor_position.x - componentCenter.x;
+  const relativeY = -(textElement.anchor_position.y - componentCenter.y);
+  const rotationMatrix = componentRotation !== 0 ? rotate4(componentRotation * Math.PI / 180) : identity3();
+  const rotatedPos = applyToPoint8(rotationMatrix, {
+    x: relativeX,
+    y: relativeY
+  });
+  const relativePosition = {
+    x: rotatedPos.x,
+    y: rotatedPos.y
+  };
+  const layerMap = {
+    top: "F.SilkS",
+    bottom: "B.SilkS"
+  };
+  const kicadLayer = layerMap[textElement.layer] || textElement.layer || "F.SilkS";
+  const fontSize = (textElement.font_size || 1) / 1.5;
+  const font = new TextEffectsFont4;
+  font.size = { width: fontSize, height: fontSize };
+  const textEffects = new TextEffects4({
+    font
+  });
+  const rotation = textElement.ccw_rotation || 0;
+  return new FpText({
+    type: "user",
+    text: textElement.text,
+    position: {
+      x: relativePosition.x,
+      y: relativePosition.y,
+      angle: rotation
+    },
+    layer: kicadLayer,
+    effects: textEffects
+  });
+}
 var AddFootprintsStage = class extends ConverterStage {
   componentsProcessed = 0;
   pcbComponents = [];
+  getNetInfoForPcbPort(pcbPortId) {
+    if (!pcbPortId)
+      return;
+    const pcbPort = this.ctx.db.pcb_port?.get(pcbPortId);
+    if (!pcbPort)
+      return;
+    const sourcePortId = pcbPort.source_port_id;
+    if (!sourcePortId)
+      return;
+    const sourcePort = this.ctx.db.source_port?.get(sourcePortId);
+    if (!sourcePort)
+      return;
+    const connectivityKey = sourcePort.subcircuit_connectivity_map_key;
+    if (!connectivityKey)
+      return;
+    return this.ctx.pcbNetMap?.get(connectivityKey);
+  }
+  getCadComponentForPcbComponent(pcbComponentId) {
+    const cadComponents = this.ctx.db.cad_component?.list() || [];
+    return cadComponents.find((cad) => cad.pcb_component_id === pcbComponentId);
+  }
+  create3DModelsFromCadComponent(cadComponent, componentCenter) {
+    const models = [];
+    const modelUrl = cadComponent.model_step_url || cadComponent.model_wrl_url;
+    if (!modelUrl)
+      return models;
+    const model = new FootprintModel(modelUrl);
+    if (cadComponent.position) {
+      model.offset = {
+        x: (cadComponent.position.x || 0) - componentCenter.x,
+        y: -((cadComponent.position.y || 0) - componentCenter.y),
+        z: cadComponent.position.z || 0
+      };
+    }
+    if (cadComponent.rotation) {
+      model.rotate = {
+        x: cadComponent.rotation.x || 0,
+        y: cadComponent.rotation.y || 0,
+        z: cadComponent.rotation.z || 0
+      };
+    }
+    if (cadComponent.model_unit_to_mm_scale_factor) {
+      const scale42 = cadComponent.model_unit_to_mm_scale_factor;
+      model.scale = { x: scale42, y: scale42, z: scale42 };
+    }
+    models.push(model);
+    return models;
+  }
   constructor(input, ctx) {
     super(input, ctx);
     this.pcbComponents = this.ctx.db.pcb_component.list();
@@ -82485,74 +83283,81 @@ var AddFootprintsStage = class extends ConverterStage {
     const component = this.pcbComponents[this.componentsProcessed];
     const sourceComponent = component.source_component_id ? this.ctx.db.source_component.get(component.source_component_id) : null;
     const footprintName = sourceComponent?.ftype || "Unknown";
-    const componentName = sourceComponent?.name || `Component_${this.componentsProcessed}`;
-    const transformedPos = applyToPoint32(c2kMatPcb, {
+    const transformedPos = applyToPoint92(c2kMatPcb, {
       x: component.center.x,
       y: component.center.y
     });
+    const footprintData = `footprint:${component.pcb_component_id}:${transformedPos.x},${transformedPos.y}`;
     const footprint = new Footprint({
       libraryLink: `tscircuit:${footprintName}`,
       layer: "F.Cu",
       at: [transformedPos.x, transformedPos.y, component.rotation || 0],
-      uuid: crypto.randomUUID()
-    });
-    const refText = new FpText({
-      type: "reference",
-      text: componentName,
-      position: [0, -1.5, 0],
-      layer: "F.SilkS",
-      uuid: crypto.randomUUID()
-    });
-    const valueText = new FpText({
-      type: "value",
-      text: footprintName,
-      position: [0, 1.5, 0],
-      layer: "F.Fab",
-      uuid: crypto.randomUUID()
+      uuid: generateDeterministicUuid(footprintData)
     });
     const fpTexts = footprint.fpTexts;
-    fpTexts.push(refText);
-    fpTexts.push(valueText);
+    const pcbSilkscreenTexts = this.ctx.db.pcb_silkscreen_text?.list().filter((text) => text.pcb_component_id === component.pcb_component_id) || [];
+    for (const textElement of pcbSilkscreenTexts) {
+      const fpText = createFpTextFromCircuitJson({
+        textElement,
+        componentCenter: component.center,
+        componentRotation: component.rotation || 0
+      });
+      if (fpText) {
+        fpTexts.push(fpText);
+      }
+    }
     footprint.fpTexts = fpTexts;
     const pcbPads = this.ctx.db.pcb_smtpad?.list().filter((pad) => pad.pcb_component_id === component.pcb_component_id) || [];
     const fpPads = footprint.fpPads;
     let padNumber = 1;
     for (const pcbPad of pcbPads) {
-      if (!(("x" in pcbPad) && ("y" in pcbPad))) {
-        throw new Error("no support for polygon pads (or any pads w/o X/Y) yet");
-      }
-      const relativeX = pcbPad.x - component.center.x;
-      const relativeY = pcbPad.y - component.center.y;
-      const layerMap = {
-        top: "F.Cu",
-        bottom: "B.Cu"
-      };
-      const padLayer = layerMap[pcbPad.layer] || "F.Cu";
-      const padShape = pcbPad.shape === "circle" ? "circle" : "rect";
-      const padSize = pcbPad.shape === "circle" ? [
-        "radius" in pcbPad ? pcbPad.radius * 2 : 0.5,
-        "radius" in pcbPad ? pcbPad.radius * 2 : 0.5
-      ] : [
-        "width" in pcbPad ? pcbPad.width : 0.5,
-        "height" in pcbPad ? pcbPad.height : 0.5
-      ];
-      const pad = new FootprintPad({
-        number: String(padNumber),
-        padType: "smd",
-        shape: padShape,
-        at: [relativeX, relativeY, 0],
-        size: padSize,
-        layers: [
-          `${padLayer}`,
-          `${padLayer === "F.Cu" ? "F" : "B"}.Paste`,
-          `${padLayer === "F.Cu" ? "F" : "B"}.Mask`
-        ],
-        uuid: crypto.randomUUID()
+      const netInfo = this.getNetInfoForPcbPort(pcbPad.pcb_port_id);
+      const pad = createSmdPadFromCircuitJson({
+        pcbPad,
+        componentCenter: component.center,
+        padNumber,
+        componentRotation: component.rotation || 0,
+        netInfo,
+        componentId: component.pcb_component_id
       });
       fpPads.push(pad);
       padNumber++;
     }
+    const pcbPlatedHoles = this.ctx.db.pcb_plated_hole?.list().filter((hole) => hole.pcb_component_id === component.pcb_component_id) || [];
+    for (const platedHole of pcbPlatedHoles) {
+      const netInfo = this.getNetInfoForPcbPort(platedHole.pcb_port_id);
+      const pad = createThruHolePadFromCircuitJson({
+        platedHole,
+        componentCenter: component.center,
+        padNumber,
+        componentRotation: component.rotation || 0,
+        netInfo,
+        componentId: component.pcb_component_id
+      });
+      if (pad) {
+        fpPads.push(pad);
+        padNumber++;
+      }
+    }
+    const pcbHoles = this.ctx.db.pcb_hole?.list().filter((hole) => hole.subcircuit_id === component.subcircuit_id) || [];
+    for (const pcbHole of pcbHoles) {
+      const pad = createNpthPadFromCircuitJson({
+        pcbHole,
+        componentCenter: component.center,
+        componentRotation: component.rotation || 0
+      });
+      if (pad) {
+        fpPads.push(pad);
+      }
+    }
     footprint.fpPads = fpPads;
+    const cadComponent = this.getCadComponentForPcbComponent(component.pcb_component_id);
+    if (cadComponent) {
+      const models = this.create3DModelsFromCadComponent(cadComponent, component.center);
+      if (models.length > 0) {
+        footprint.models = models;
+      }
+    }
     const footprints = kicadPcb.footprints;
     footprints.push(footprint);
     kicadPcb.footprints = footprints;
@@ -82589,30 +83394,55 @@ var AddTracesStage = class extends ConverterStage {
     for (let i = 0;i < trace.route.length - 1; i++) {
       const startPoint = trace.route[i];
       const endPoint = trace.route[i + 1];
-      const transformedStart = applyToPoint42(c2kMatPcb, {
+      const transformedStart = applyToPoint102(c2kMatPcb, {
         x: startPoint.x,
         y: startPoint.y
       });
-      const transformedEnd = applyToPoint42(c2kMatPcb, {
+      const transformedEnd = applyToPoint102(c2kMatPcb, {
         x: endPoint.x,
         y: endPoint.y
       });
-      let netNumber = 0;
+      let netInfo;
       if (pcbNetMap) {
-        const netName = `Net-${trace.pcb_trace_id}`;
-        netNumber = pcbNetMap.get(netName) ?? 0;
+        let connectivityKey = trace.subcircuit_connectivity_map_key;
+        if (!connectivityKey && trace.source_trace_id) {
+          const sourceTrace = this.ctx.db.source_trace?.get(trace.source_trace_id);
+          if (sourceTrace) {
+            connectivityKey = sourceTrace.subcircuit_connectivity_map_key;
+            if (!connectivityKey && sourceTrace.connected_source_net_ids?.length) {
+              for (const sourceNetId of sourceTrace.connected_source_net_ids) {
+                const sourceNet = this.ctx.db.source_net?.get(sourceNetId);
+                if (sourceNet?.subcircuit_connectivity_map_key) {
+                  connectivityKey = sourceNet.subcircuit_connectivity_map_key;
+                  break;
+                }
+              }
+            }
+          }
+        }
+        if (!connectivityKey && typeof trace.connection_name === "string") {
+          const sourceNet = this.ctx.db.source_net?.get(trace.connection_name);
+          if (sourceNet?.subcircuit_connectivity_map_key) {
+            connectivityKey = sourceNet.subcircuit_connectivity_map_key;
+          }
+        }
+        if (connectivityKey) {
+          netInfo = pcbNetMap.get(connectivityKey);
+        }
       }
       const layerMap = {
         top: "F.Cu",
         bottom: "B.Cu"
       };
       const kicadLayer = layerMap[startPoint.layer] || startPoint.layer || "F.Cu";
+      const segmentData = `segment:${transformedStart.x},${transformedStart.y}:${transformedEnd.x},${transformedEnd.y}:${kicadLayer}:${netInfo?.id ?? 0}`;
       const segment = new Segment({
         start: { x: transformedStart.x, y: transformedStart.y },
         end: { x: transformedEnd.x, y: transformedEnd.y },
         layer: kicadLayer,
         width: trace.width || 0.25,
-        net: new SegmentNet(netNumber)
+        net: new SegmentNet(netInfo?.id ?? 0),
+        uuid: generateDeterministicUuid(segmentData)
       });
       const segments = kicadPcb.segments;
       segments.push(segment);
@@ -82644,20 +83474,56 @@ var AddViasStage = class extends ConverterStage {
       return;
     }
     const via = this.pcbVias[this.viasProcessed];
-    const transformedPos = applyToPoint52(c2kMatPcb, {
+    const transformedPos = applyToPoint11(c2kMatPcb, {
       x: via.x,
       y: via.y
     });
-    let netNumber = 0;
-    if (pcbNetMap && via.net_name) {
-      netNumber = pcbNetMap.get(via.net_name) ?? 0;
+    let netInfo;
+    if (pcbNetMap) {
+      let connectivityKey = via.subcircuit_connectivity_map_key;
+      if (!connectivityKey && via.pcb_trace_id) {
+        const pcbTrace = this.ctx.db.pcb_trace?.get(via.pcb_trace_id);
+        if (pcbTrace) {
+          if ("subcircuit_connectivity_map_key" in pcbTrace) {
+            connectivityKey = pcbTrace.subcircuit_connectivity_map_key;
+          }
+          if (!connectivityKey && pcbTrace.source_trace_id) {
+            const sourceTrace = this.ctx.db.source_trace?.get(pcbTrace.source_trace_id);
+            if (sourceTrace) {
+              if ("subcircuit_connectivity_map_key" in sourceTrace) {
+                connectivityKey = sourceTrace.subcircuit_connectivity_map_key;
+              }
+              if (!connectivityKey && sourceTrace.connected_source_net_ids?.length) {
+                for (const sourceNetId of sourceTrace.connected_source_net_ids) {
+                  const sourceNet = this.ctx.db.source_net?.get(sourceNetId);
+                  if (sourceNet?.subcircuit_connectivity_map_key) {
+                    connectivityKey = sourceNet.subcircuit_connectivity_map_key;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (!connectivityKey && via.connection_name) {
+        const sourceNet = this.ctx.db.source_net?.get(via.connection_name);
+        if (sourceNet?.subcircuit_connectivity_map_key) {
+          connectivityKey = sourceNet.subcircuit_connectivity_map_key;
+        }
+      }
+      if (connectivityKey) {
+        netInfo = pcbNetMap.get(connectivityKey);
+      }
     }
+    const viaData = `via:${transformedPos.x},${transformedPos.y}:${via.outer_diameter || 0.8}:${via.hole_diameter || 0.4}:${netInfo?.id ?? 0}`;
     const kicadVia = new Via({
       at: [transformedPos.x, transformedPos.y],
       size: via.outer_diameter || 0.8,
       drill: via.hole_diameter || 0.4,
       layers: ["F.Cu", "B.Cu"],
-      net: new ViaNet(netNumber)
+      net: new ViaNet(netInfo?.id ?? 0),
+      uuid: generateDeterministicUuid(viaData)
     });
     const vias = kicadPcb.vias;
     vias.push(kicadVia);
@@ -82668,6 +83534,63 @@ var AddViasStage = class extends ConverterStage {
     return this.ctx.kicadPcb;
   }
 };
+function createGrTextFromCircuitJson({
+  textElement,
+  c2kMatPcb
+}) {
+  if (!textElement.text || !textElement.anchor_position) {
+    return null;
+  }
+  const transformedPos = applyToPoint122(c2kMatPcb, {
+    x: textElement.anchor_position.x,
+    y: textElement.anchor_position.y
+  });
+  const layerMap = {
+    top: "F.SilkS",
+    bottom: "B.SilkS"
+  };
+  const kicadLayer = layerMap[textElement.layer] || textElement.layer || "F.SilkS";
+  const fontSize = (textElement.font_size || 1) / 1.5;
+  const font = new TextEffectsFont5;
+  font.size = { width: fontSize, height: fontSize };
+  const justify = new TextEffectsJustify3;
+  const anchorAlignment = textElement.anchor_alignment || "center";
+  switch (anchorAlignment) {
+    case "top_left":
+      justify.horizontal = "left";
+      justify.vertical = "top";
+      break;
+    case "top_right":
+      justify.horizontal = "right";
+      justify.vertical = "top";
+      break;
+    case "bottom_left":
+      justify.horizontal = "left";
+      justify.vertical = "bottom";
+      break;
+    case "bottom_right":
+      justify.horizontal = "right";
+      justify.vertical = "bottom";
+      break;
+    case "center":
+      break;
+  }
+  const textEffects = new TextEffects5({
+    font
+  });
+  if (anchorAlignment !== "center") {
+    textEffects.justify = justify;
+  }
+  const rotation = textElement.ccw_rotation || 0;
+  const position = new At([transformedPos.x, transformedPos.y, rotation]);
+  const grText = new GrText({
+    text: textElement.text,
+    layer: kicadLayer,
+    effects: textEffects
+  });
+  grText.position = position;
+  return grText;
+}
 var AddGraphicsStage = class extends ConverterStage {
   _step() {
     const { kicadPcb, c2kMatPcb } = this.ctx;
@@ -82686,11 +83609,11 @@ var AddGraphicsStage = class extends ConverterStage {
         const endPoint = path27.route[i + 1];
         if (!startPoint || !endPoint)
           continue;
-        const transformedStart = applyToPoint62(c2kMatPcb, {
+        const transformedStart = applyToPoint13(c2kMatPcb, {
           x: startPoint.x,
           y: startPoint.y
         });
-        const transformedEnd = applyToPoint62(c2kMatPcb, {
+        const transformedEnd = applyToPoint13(c2kMatPcb, {
           x: endPoint.x,
           y: endPoint.y
         });
@@ -82710,6 +83633,18 @@ var AddGraphicsStage = class extends ConverterStage {
         kicadPcb.graphicLines = graphicLines;
       }
     }
+    const standaloneSilkscreenTexts = this.ctx.db.pcb_silkscreen_text?.list().filter((text) => !text.pcb_component_id) || [];
+    for (const textElement of standaloneSilkscreenTexts) {
+      const grText = createGrTextFromCircuitJson({
+        textElement,
+        c2kMatPcb
+      });
+      if (grText) {
+        const graphicTexts = kicadPcb.graphicTexts;
+        graphicTexts.push(grText);
+        kicadPcb.graphicTexts = graphicTexts;
+      }
+    }
     const pcbBoards = this.ctx.db.pcb_board?.list() || [];
     if (pcbBoards.length > 0) {
       const board = pcbBoards[0];
@@ -82721,8 +83656,8 @@ var AddGraphicsStage = class extends ConverterStage {
       if (board.outline && board.outline.length > 0) {
         corners = board.outline;
       } else {
-        const halfWidth = board.width / 2;
-        const halfHeight = board.height / 2;
+        const halfWidth = board.width ? board.width / 2 : 0;
+        const halfHeight = board.height ? board.height / 2 : 0;
         corners = [
           { x: board.center.x - halfWidth, y: board.center.y - halfHeight },
           { x: board.center.x + halfWidth, y: board.center.y - halfHeight },
@@ -82730,7 +83665,7 @@ var AddGraphicsStage = class extends ConverterStage {
           { x: board.center.x - halfWidth, y: board.center.y + halfHeight }
         ];
       }
-      const transformedCorners = corners.map((corner) => applyToPoint62(c2kMatPcb, corner));
+      const transformedCorners = corners.map((corner) => applyToPoint13(c2kMatPcb, corner));
       for (let i = 0;i < transformedCorners.length; i++) {
         const start = transformedCorners[i];
         const end = transformedCorners[(i + 1) % transformedCorners.length];
@@ -82772,7 +83707,7 @@ var CircuitJsonToKicadPcbConverter = class {
         generator: "circuit-json-to-kicad",
         generatorVersion: "0.0.1"
       }),
-      c2kMatPcb: compose2(translate2(KICAD_PCB_CENTER_X, KICAD_PCB_CENTER_Y), scale22(CIRCUIT_JSON_TO_MM_SCALE, -CIRCUIT_JSON_TO_MM_SCALE))
+      c2kMatPcb: compose3(translate3(KICAD_PCB_CENTER_X, KICAD_PCB_CENTER_Y), scale32(CIRCUIT_JSON_TO_MM_SCALE, -CIRCUIT_JSON_TO_MM_SCALE))
     };
     this.pipeline = [
       new InitializePcbStage(circuitJson, this.ctx),
@@ -82811,8 +83746,8 @@ var import_jszip2 = __toESM2(require_lib4(), 1);
 
 // lib/shared/generate-circuit-json.tsx
 var import_make_vfs2 = __toESM2(require_dist8(), 1);
-import path27 from "node:path";
-import fs25 from "node:fs";
+import path28 from "node:path";
+import fs26 from "node:fs";
 import { pathToFileURL } from "node:url";
 import Debug11 from "debug";
 
@@ -82831,20 +83766,32 @@ var abbreviateStringifyObject = (obj) => {
 };
 
 // lib/shared/importFromUserLand.ts
-import { resolve as resolve10 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import fs25 from "node:fs";
+import path27 from "node:path";
 async function importFromUserLand(moduleName) {
+  const userModulePath = path27.join(process.cwd(), "node_modules", moduleName);
+  if (fs25.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path27.join(process.cwd(), "noop.js"));
+    try {
+      const resolvedUserPath = userRequire.resolve(moduleName);
+      return await import(resolvedUserPath);
+    } catch (error) {
+      if (error?.code !== "MODULE_NOT_FOUND") {
+        throw error;
+      }
+    }
+  }
+  const cliRequire = createRequire2(import.meta.url);
   try {
-    const resolvedPath = import.meta.resolve(moduleName, resolve10(process.cwd(), "dummy.js"));
-    return await import(resolvedPath);
+    const resolvedCliPath = cliRequire.resolve(moduleName);
+    return await import(resolvedCliPath);
   } catch (error) {
-    try {
-      const modulePath = await Bun.resolve(moduleName, process.cwd());
-      return await import(modulePath);
-    } catch (error2) {
-      const module2 = await import(moduleName);
-      return module2;
+    if (error?.code !== "MODULE_NOT_FOUND") {
+      throw error;
     }
   }
+  return import(moduleName);
 }
 
 // lib/shared/generate-circuit-json.tsx
@@ -82875,12 +83822,12 @@ async function generateCircuitJson({
   const runner = new userLandTscircuit.RootCircuit({
     platform: platformConfig
   });
-  const absoluteFilePath = path27.isAbsolute(filePath) ? filePath : path27.resolve(process.cwd(), filePath);
-  const projectDir = path27.dirname(absoluteFilePath);
+  const absoluteFilePath = path28.isAbsolute(filePath) ? filePath : path28.resolve(process.cwd(), filePath);
+  const projectDir = path28.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path27.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path27.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path27.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path28.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path28.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path28.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug11(`Project directory: ${projectDir}`);
   debug11(`Relative component path: ${relativeComponentPath}`);
   debug11(`Output path: ${outputPath}`);
@@ -82900,7 +83847,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path27.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path28.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -82918,7 +83865,7 @@ async function generateCircuitJson({
   const circuitJson = await runner.getCircuitJson();
   if (saveToFile) {
     debug11(`Saving circuit JSON to ${outputPath}`);
-    fs25.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs26.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -82927,9 +83874,9 @@ async function generateCircuitJson({
 }
 
 // cli/build/generate-kicad-footprint-library.ts
-import fs26 from "node:fs";
-import path28 from "node:path";
-import { At, KicadPcb as KicadPcb2, parseKicadSexpr } from "kicadts";
+import fs27 from "node:fs";
+import path29 from "node:path";
+import { At as At2, KicadPcb as KicadPcb2, parseKicadSexpr } from "kicadts";
 var sanitizeLibraryAndFootprintName = (libraryLink) => {
   if (!libraryLink) {
     return {
@@ -82954,7 +83901,7 @@ var sanitizeLibraryAndFootprintName = (libraryLink) => {
 var sanitizeFootprint = (footprint) => {
   const { libraryName, footprintName } = sanitizeLibraryAndFootprintName(footprint.libraryLink);
   footprint.libraryLink = footprintName;
-  footprint.position = At.from([0, 0, 0]);
+  footprint.position = At2.from([0, 0, 0]);
   footprint.locked = false;
   footprint.placed = false;
   footprint.uuid = undefined;
@@ -82988,8 +83935,8 @@ var generateKicadFootprintLibrary = async ({
   projects,
   distDir
 }) => {
-  const libraryRoot = path28.join(distDir, "kicad-footprints");
-  fs26.mkdirSync(libraryRoot, { recursive: true });
+  const libraryRoot = path29.join(distDir, "kicad-footprints");
+  fs27.mkdirSync(libraryRoot, { recursive: true });
   const uniqueFootprints = new Map;
   for (const project of projects) {
     try {
@@ -83012,10 +83959,10 @@ var generateKicadFootprintLibrary = async ({
   const libraryNames = new Set;
   for (const entry of uniqueFootprints.values()) {
     libraryNames.add(entry.libraryName);
-    const libraryDir = path28.join(libraryRoot, `${entry.libraryName}.pretty`);
-    fs26.mkdirSync(libraryDir, { recursive: true });
-    const footprintPath = path28.join(libraryDir, `${entry.footprintName}.kicad_mod`);
-    fs26.writeFileSync(footprintPath, `${entry.content}
+    const libraryDir = path29.join(libraryRoot, `${entry.libraryName}.pretty`);
+    fs27.mkdirSync(libraryDir, { recursive: true });
+    const footprintPath = path29.join(libraryDir, `${entry.footprintName}.kicad_mod`);
+    fs27.writeFileSync(footprintPath, `${entry.content}
 `);
   }
   if (libraryNames.size > 0) {
@@ -83025,7 +83972,7 @@ ${libTableEntries.join(`
 `)}
 )
 `;
-    fs26.writeFileSync(path28.join(libraryRoot, "fp-lib-table"), libTableContent);
+    fs27.writeFileSync(path29.join(libraryRoot, "fp-lib-table"), libTableContent);
   }
 };
 var extractFootprintsFromPcb = (pcbContent) => {
@@ -83050,7 +83997,7 @@ var extractFootprintsFromPcb = (pcbContent) => {
 };
 
 // lib/shared/export-snippet.ts
-var writeFileAsync = promisify3(fs27.writeFile);
+var writeFileAsync = promisify3(fs28.writeFile);
 var ALLOWED_EXPORT_FORMATS = [
   "json",
   "circuit-json",
@@ -83095,10 +84042,10 @@ var exportSnippet = async ({
     onError(`Invalid format: ${format}`);
     return onExit(1);
   }
-  const projectDir = path29.dirname(filePath);
-  const outputBaseName = path29.basename(filePath).replace(/\.[^.]+$/, "");
+  const projectDir = path30.dirname(filePath);
+  const outputBaseName = path30.basename(filePath).replace(/\.[^.]+$/, "");
   const outputFileName = `${outputBaseName}${OUTPUT_EXTENSIONS[format]}`;
-  const outputDestination = path29.join(projectDir, outputPath ?? outputFileName);
+  const outputDestination = path30.join(projectDir, outputPath ?? outputFileName);
   const circuitData = await generateCircuitJson({
     filePath,
     saveToFile: format === "circuit-json",
@@ -83310,12 +84257,12 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 };
 
 // lib/eecircuit-engine/run-simulation.ts
-import { promises as fs28, existsSync as existsSync11 } from "node:fs";
-import path30 from "node:path";
+import { promises as fs29, existsSync as existsSync11 } from "node:fs";
+import path31 from "node:path";
 import os4 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path30.join(os4.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  const tempFilePath = path31.join(os4.tmpdir(), "eecircuit-engine-1.5.2.mjs");
   if (!existsSync11(tempFilePath)) {
     const url = "https://cdn.jsdelivr.net/npm/eecircuit-engine@1.5.2/+esm";
     const response = await fetch(url);
@@ -83323,7 +84270,7 @@ var fetchSimulation = async () => {
       throw new Error(`Failed to fetch eecircuit-engine from ${url}: ${response.statusText}`);
     }
     const scriptContent = await response.text();
-    await fs28.writeFile(tempFilePath, scriptContent);
+    await fs29.writeFile(tempFilePath, scriptContent);
   }
   const module2 = await import(tempFilePath);
   return module2.Simulation;
@@ -83412,8 +84359,8 @@ var resultToCsv = (result) => {
 };
 
 // cli/export/register.ts
-import path31 from "node:path";
-import { promises as fs29 } from "node:fs";
+import path32 from "node:path";
+import { promises as fs30 } from "node:fs";
 var registerExport = (program3) => {
   program3.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";
@@ -83425,12 +84372,12 @@ var registerExport = (program3) => {
       });
       if (circuitJson) {
         const spiceString = getSpiceWithPaddedSim(circuitJson);
-        const outputSpicePath = options.output ?? path31.join(path31.dirname(file), `${path31.basename(file, path31.extname(file))}.spice.cir`);
-        await fs29.writeFile(outputSpicePath, spiceString);
+        const outputSpicePath = options.output ?? path32.join(path32.dirname(file), `${path32.basename(file, path32.extname(file))}.spice.cir`);
+        await fs30.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
         const outputCsvPath = outputSpicePath.replace(/\.spice\.cir$/, ".csv");
-        await fs29.writeFile(outputCsvPath, csvContent);
+        await fs30.writeFile(outputCsvPath, csvContent);
         console.log(`Exported to ${outputSpicePath} and ${outputCsvPath} (simulation results)!`);
       }
       process.exit(0);
@@ -83654,14 +84601,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path32 = null;
+  let path33 = null;
   let id = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path32 = createKeyPath(key);
+    path33 = createKeyPath(key);
     id = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -83675,11 +84622,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path32 = createKeyPath(name);
+    path33 = createKeyPath(name);
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path32, id, weight, src, getFn };
+  return { path: path33, id, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -83687,34 +84634,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path32) {
+function get(obj, path33) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path33, index) => {
+  const deepGet = (obj2, path34, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path33[index]) {
+    if (!path34[index]) {
       list.push(obj2);
     } else {
-      let key = path33[index];
+      let key = path34[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path33.length - 1 && (isString2(value) || isNumber(value) || isBoolean(value))) {
+      if (index === path34.length - 1 && (isString2(value) || isNumber(value) || isBoolean(value))) {
         list.push(toString(value));
       } else if (isArray(value)) {
         arr = true;
         for (let i = 0, len = value.length;i < len; i += 1) {
-          deepGet(value[i], path33, index + 1);
+          deepGet(value[i], path34, index + 1);
         }
-      } else if (path33.length) {
-        deepGet(value, path33, index + 1);
+      } else if (path34.length) {
+        deepGet(value, path34, index + 1);
       }
     }
   };
-  deepGet(obj, isString2(path32) ? path32.split(".") : path32, 0);
+  deepGet(obj, isString2(path33) ? path33.split(".") : path33, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -84906,8 +85853,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path32, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path32.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path33, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path33.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (!onlyKicad && results.packages.length) {
@@ -85839,7 +86786,7 @@ var require_svgson_umd = __commonJS2({
     });
   }
 });
-function applyToPoint8(matrix, point2) {
+function applyToPoint14(matrix, point2) {
   return Array.isArray(point2) ? [
     matrix.a * point2[0] + matrix.c * point2[1] + matrix.e,
     matrix.b * point2[0] + matrix.d * point2[1] + matrix.f
@@ -85848,7 +86795,7 @@ function applyToPoint8(matrix, point2) {
     y: matrix.b * point2.x + matrix.d * point2.y + matrix.f
   };
 }
-function translate3(tx2, ty2 = 0) {
+function translate4(tx2, ty2 = 0) {
   return {
     a: 1,
     c: 0,
@@ -85884,14 +86831,14 @@ function transform(...matrices) {
     }
   }
 }
-function compose3(...matrices) {
+function compose4(...matrices) {
   return transform(...matrices);
 }
 function isUndefined2(val) {
   return typeof val === "undefined";
 }
 var { cos, sin, PI } = Math;
-function rotate(angle, cx2, cy2) {
+function rotate5(angle, cx2, cy2) {
   const cosAngle = cos(angle);
   const sinAngle = sin(angle);
   const rotationMatrix = {
@@ -85906,9 +86853,9 @@ function rotate(angle, cx2, cy2) {
     return rotationMatrix;
   }
   return transform([
-    translate3(cx2, cy2),
+    translate4(cx2, cy2),
     rotationMatrix,
-    translate3(-cx2, -cy2)
+    translate4(-cx2, -cy2)
   ]);
 }
 function scale8(sx2, sy2 = undefined, cx2 = undefined, cy2 = undefined) {
@@ -85926,12 +86873,12 @@ function scale8(sx2, sy2 = undefined, cx2 = undefined, cy2 = undefined) {
     return scaleMatrix;
   }
   return transform([
-    translate3(cx2, cy2),
+    translate4(cx2, cy2),
     scaleMatrix,
-    translate3(-cx2, -cy2)
+    translate4(-cx2, -cy2)
   ]);
 }
-function identity() {
+function identity4() {
   return {
     a: 1,
     c: 0,
@@ -86072,12 +87019,12 @@ peg$SyntaxError.buildMessage = function(expected, found) {
 function decomposeTSR2(matrix, flipX = false, flipY2 = false) {
   if (flipX) {
     if (flipY2) {
-      matrix = compose3(matrix, scale8(-1, -1));
+      matrix = compose4(matrix, scale8(-1, -1));
     } else {
-      matrix = compose3(matrix, scale8(1, -1));
+      matrix = compose4(matrix, scale8(1, -1));
     }
   } else if (flipY2) {
-    matrix = compose3(matrix, scale8(-1, 1));
+    matrix = compose4(matrix, scale8(-1, 1));
   }
   const a = matrix.a;
   const b3 = matrix.b;
@@ -88155,7 +89102,7 @@ function buildSubtree(soup, opts) {
   }
   return soup.filter((e3) => included.has(e3));
 }
-var cju3 = (circuitJsonInput, options = {}) => {
+var cju4 = (circuitJsonInput, options = {}) => {
   const circuitJson = circuitJsonInput;
   let internalStore = circuitJson._internal_store;
   if (!internalStore) {
@@ -88187,7 +89134,7 @@ var cju3 = (circuitJsonInput, options = {}) => {
         return internalStore.editCount;
       }
       if (prop === "subtree") {
-        return (opts) => cju3(buildSubtree(circuitJson, opts), options);
+        return (opts) => cju4(buildSubtree(circuitJson, opts), options);
       }
       const component_type = prop;
       return {
@@ -88269,9 +89216,9 @@ var cju3 = (circuitJsonInput, options = {}) => {
   });
   return su22;
 };
-cju3.unparsed = cju3;
-var su6 = cju3;
-var cju_default = cju3;
+cju4.unparsed = cju4;
+var su6 = cju4;
+var cju_default = cju4;
 function createIdKey(element) {
   const type = element.type;
   return `${type}:${element[`${type}_id`]}`;
@@ -88739,20 +89686,20 @@ var transformPCBElement = (elm, matrix) => {
   const tsr = decomposeTSR2(matrix);
   const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
   if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
-    const { x, y } = applyToPoint8(matrix, {
+    const { x, y } = applyToPoint14(matrix, {
       x: Number(elm.x),
       y: Number(elm.y)
     });
     elm.x = x;
     elm.y = y;
   } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
-    elm.center = applyToPoint8(matrix, elm.center);
+    elm.center = applyToPoint14(matrix, elm.center);
   } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
-    elm.anchor_position = applyToPoint8(matrix, elm.anchor_position);
+    elm.anchor_position = applyToPoint14(matrix, elm.anchor_position);
   } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect") {
-    elm.center = applyToPoint8(matrix, elm.center);
+    elm.center = applyToPoint14(matrix, elm.center);
   } else if (elm.type === "pcb_component") {
-    elm.center = applyToPoint8(matrix, elm.center);
+    elm.center = applyToPoint14(matrix, elm.center);
     elm.rotation = elm.rotation + tsr.rotation.angle / Math.PI * 180;
     elm.rotation = elm.rotation % 360;
     if (flipPadWidthHeight) {
@@ -88760,7 +89707,7 @@ var transformPCBElement = (elm, matrix) => {
     }
   } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
     elm.route = elm.route.map((rp2) => {
-      const tp2 = applyToPoint8(matrix, rp2);
+      const tp2 = applyToPoint14(matrix, rp2);
       rp2.x = tp2.x;
       rp2.y = tp2.y;
       return rp2;
@@ -88768,14 +89715,14 @@ var transformPCBElement = (elm, matrix) => {
   } else if (elm.type === "pcb_silkscreen_line") {
     const p12 = { x: elm.x1, y: elm.y1 };
     const p2 = { x: elm.x2, y: elm.y2 };
-    const p1t = applyToPoint8(matrix, p12);
-    const p2t = applyToPoint8(matrix, p2);
+    const p1t = applyToPoint14(matrix, p12);
+    const p2t = applyToPoint14(matrix, p2);
     elm.x1 = p1t.x;
     elm.y1 = p1t.y;
     elm.x2 = p2t.x;
     elm.y2 = p2t.y;
   } else if (elm.type === "cad_component") {
-    const newPos = applyToPoint8(matrix, {
+    const newPos = applyToPoint14(matrix, {
       x: elm.position.x,
       y: elm.position.y
     });
@@ -88808,7 +89755,7 @@ var getElementById = (soup, id2) => {
   return soup.find((elm) => getElementId(elm) === id2) ?? null;
 };
 function getReadableNameForPcbTrace(soup, pcb_trace_id) {
-  const pcbTrace = cju3(soup).pcb_trace.get(pcb_trace_id);
+  const pcbTrace = cju4(soup).pcb_trace.get(pcb_trace_id);
   if (!pcbTrace) {
     return `trace[${pcb_trace_id}]`;
   }
@@ -88817,16 +89764,16 @@ function getReadableNameForPcbTrace(soup, pcb_trace_id) {
     return `trace[${pcb_trace_id}]`;
   }
   function getComponentAndPortInfo(pcb_port_id) {
-    const pcbPort = cju3(soup).pcb_port.get(pcb_port_id);
+    const pcbPort = cju4(soup).pcb_port.get(pcb_port_id);
     if (!pcbPort)
       return null;
-    const pcbComponent = cju3(soup).pcb_component.get(pcbPort.pcb_component_id);
+    const pcbComponent = cju4(soup).pcb_component.get(pcbPort.pcb_component_id);
     if (!pcbComponent)
       return null;
-    const sourceComponent = cju3(soup).source_component.get(pcbComponent.source_component_id);
+    const sourceComponent = cju4(soup).source_component.get(pcbComponent.source_component_id);
     if (!sourceComponent)
       return null;
-    const sourcePort = cju3(soup).source_port.get(pcbPort.source_port_id);
+    const sourcePort = cju4(soup).source_port.get(pcbPort.source_port_id);
     const portHint = sourcePort?.port_hints ? sourcePort.port_hints[1] : "";
     return {
       componentName: sourceComponent.name,
@@ -88843,19 +89790,19 @@ function getReadableNameForPcbTrace(soup, pcb_trace_id) {
   return `trace[${selectorParts.join(", ")}]`;
 }
 var getReadableNameForPcbPort = (soup, pcb_port_id) => {
-  const pcbPort = cju3(soup).pcb_port.get(pcb_port_id);
+  const pcbPort = cju4(soup).pcb_port.get(pcb_port_id);
   if (!pcbPort) {
     return `pcb_port[#${pcb_port_id}]`;
   }
-  const pcbComponent = cju3(soup).pcb_component.get(pcbPort?.pcb_component_id);
+  const pcbComponent = cju4(soup).pcb_component.get(pcbPort?.pcb_component_id);
   if (!pcbComponent) {
     return `pcb_port[#${pcb_port_id}]`;
   }
-  const sourceComponent = cju3(soup).source_component.get(pcbComponent.source_component_id);
+  const sourceComponent = cju4(soup).source_component.get(pcbComponent.source_component_id);
   if (!sourceComponent) {
     return `pcb_port[#${pcb_port_id}]`;
   }
-  const sourcePort = cju3(soup).source_port.get(pcbPort.source_port_id);
+  const sourcePort = cju4(soup).source_port.get(pcbPort.source_port_id);
   if (!sourcePort) {
     return `pcb_port[#${pcb_port_id}]`;
   }
@@ -88870,7 +89817,7 @@ var getReadableNameForPcbPort = (soup, pcb_port_id) => {
   return `pcb_port[.${sourceComponent.name} > .${padIdentifier}]`;
 };
 function getReadableNameForPcbSmtpad(soup, pcb_smtpad_id) {
-  const pcbSmtpad = cju3(soup).pcb_smtpad.get(pcb_smtpad_id);
+  const pcbSmtpad = cju4(soup).pcb_smtpad.get(pcb_smtpad_id);
   if (!pcbSmtpad || !pcbSmtpad.pcb_port_id) {
     return `smtpad[${pcb_smtpad_id}]`;
   }
@@ -89172,7 +90119,7 @@ var repositionPcbComponentTo = (circuitJson, pcb_component_id, newCenter) => {
       return true;
     return false;
   });
-  const matrix = translate3(dx2, dy2);
+  const matrix = translate4(dx2, dy2);
   transformPCBElements(elementsToMove, matrix);
 };
 var getCircuitJsonTree = (circuitJson, opts) => {
@@ -89858,8 +90805,8 @@ var Ty = E(Fe);
 var R = { paths: { path11: { type: "path", points: [{ x: -0.54, y: 0.04 }, { x: -0.22, y: 0.04 }], color: "primary", fill: false }, path12: { type: "path", points: [{ x: 0.14, y: 0.05 }, { x: 0.46, y: 0.05 }], color: "primary", fill: false }, "path12-6": { type: "path", points: [{ x: 0.14, y: -0.15 }, { x: 0.14, y: 0.25 }], color: "primary", fill: false }, "path11-0-9": { type: "path", points: [{ x: -0.22, y: 0.25 }, { x: -0.21, y: -0.15 }, { x: 0.14, y: 0.05 }, { x: -0.22, y: 0.25 }], color: "primary", fill: true } }, texts: { top1: { type: "text", text: "{REF}", x: -0.09, y: 0.38 }, bottom1: { type: "text", text: "{VAL}", x: -0.07, y: -0.38 }, right1: { type: "text", text: "", x: 0.59, y: -0.33 } }, refblocks: { left1: { x: -0.56, y: 0.04 }, right1: { x: 0.48, y: 0.05 } }, bounds: { minX: -0.59, maxX: 0.59, minY: -0.38, maxY: 0.38, width: 1.18, height: 0.76, centerX: 0, centerY: 0 }, circles: {} };
 var { paths: fc, texts: O7, bounds: Re, refblocks: Ey, circles: hc } = R;
 var Yy = e({ primitives: [...Object.values(fc), ...Object.values(hc), { type: "text", text: "{REF}", x: -0.15, y: 0.3294553499999995 }, { type: "text", text: "{VAL}", x: 0.15, y: 0.3294553499999995 }], ports: [{ ...Ey.left1, labels: ["1"] }, { ...Ey.right1, labels: ["2"] }], size: { width: Re.width, height: Re.height }, center: { x: Re.centerX, y: Re.centerY } }).rotateRightFacingSymbol("down").labelPort("left1", ["1"]).labelPort("right1", ["2"]).changeTextAnchor("{REF}", "middle_left").changeTextAnchor("{VAL}", "middle_left").build();
-var { paths: cc, texts: C7, bounds: Te, refblocks: Xy3, circles: dc } = R;
-var Ly = e({ primitives: [...Object.values(cc), ...Object.values(dc), { type: "text", text: "{REF}", x: -0, y: 0.4094553499999995 }, { type: "text", text: "{VAL}", x: 0, y: -0.4094553499999995 }], ports: [{ ...Xy3.left1, labels: ["1"] }, { ...Xy3.right1, labels: ["2"] }], size: { width: Te.width, height: Te.height }, center: { x: Te.centerX, y: Te.centerY } }).changeTextAnchor("{VAL}", "middle_top").rotateRightFacingSymbol("right").labelPort("left1", ["1"]).labelPort("right1", ["2"]).changeTextAnchor("{REF}", "middle_bottom").build();
+var { paths: cc, texts: C7, bounds: Te, refblocks: Xy4, circles: dc } = R;
+var Ly = e({ primitives: [...Object.values(cc), ...Object.values(dc), { type: "text", text: "{REF}", x: -0, y: 0.4094553499999995 }, { type: "text", text: "{VAL}", x: 0, y: -0.4094553499999995 }], ports: [{ ...Xy4.left1, labels: ["1"] }, { ...Xy4.right1, labels: ["2"] }], size: { width: Te.width, height: Te.height }, center: { x: Te.centerX, y: Te.centerY } }).changeTextAnchor("{VAL}", "middle_top").rotateRightFacingSymbol("right").labelPort("left1", ["1"]).labelPort("right1", ["2"]).changeTextAnchor("{REF}", "middle_bottom").build();
 var { paths: bc, texts: q7, bounds: Ee, refblocks: Vy, circles: _c } = R;
 var jy = e({ primitives: [...Object.values(bc), ...Object.values(_c), { type: "text", text: "{REF}", x: -0, y: -0.3094553499999995 }, { type: "text", text: "{VAL}", x: 0, y: 0.4094553499999995 }], ports: [{ ...Vy.left1, labels: ["1"] }, { ...Vy.right1, labels: ["2"] }], size: { width: Ee.width, height: Ee.height }, center: { x: Ee.centerX, y: Ee.centerY } }).changeTextAnchor("{VAL}", "middle_bottom").rotateRightFacingSymbol("left").labelPort("left1", ["1"]).labelPort("right1", ["2"]).changeTextAnchor("{REF}", "middle_bottom").build();
 var { paths: gc, texts: W7, bounds: Ye, refblocks: ky2, circles: uc } = R;
@@ -89870,12 +90817,12 @@ var { paths: Ac, texts: ov, bounds: Le, refblocks: $y, circles: Pc } = R;
 var My = e({ primitives: [...Object.values(Ac), ...Object.values(Pc), { type: "text", text: "{REF}", x: 0.15, y: -0.2894553499999995 }, { type: "text", text: "{VAL}", x: -0.15, y: -0.2894553499999995 }], ports: [{ ...$y.left1, labels: ["1"] }, { ...$y.right1, labels: ["2"] }], size: { width: Le.width, height: Le.height }, center: { x: Le.centerX, y: Le.centerY } }).rotateRightFacingSymbol("up").labelPort("left1", ["1"]).labelPort("right1", ["2"]).changeTextAnchor("{REF}", "middle_left").changeTextAnchor("{VAL}", "middle_left").build();
 var Cy = { paths: { path11: { type: "path", points: [{ x: -0.53, y: 0 }, { x: -0.3, y: 0 }], color: "primary", fill: false }, path12: { type: "path", points: [{ x: 0.29, y: 0 }, { x: 0.53, y: 0 }], color: "primary", fill: false } }, texts: { top1: { type: "text", text: "{REF}", x: -0.18, y: -0.36 }, bottom1: { type: "text", text: "{VAL}", x: -0.01, y: 0.43 }, left1: { type: "text", text: "Hz", x: 0, y: -0.04 } }, refblocks: { left1: { x: -0.54, y: 0 }, right1: { x: 0.54, y: 0 } }, bounds: { minX: -0.53, maxX: 0.53, minY: 0, maxY: 0, width: 1.06, height: 1, centerX: 0, centerY: 0 }, circles: { path1: { type: "circle", x: -0.01, y: -0.01, radius: 0.29, color: "primary", fill: false } } };
 var { paths: Fc, texts: Rc, bounds: Ve, refblocks: Ny, circles: Tc } = Cy;
-var At2 = s({ primitives: [...Object.values(Fc), ...Object.values(Tc), { type: "text", text: "{REF}", x: 0, y: -0.3594553499999995, anchor: "middle_top" }, { type: "text", text: "{VAL}", x: 0, y: 0.35, anchor: "middle_bottom" }, { ...Rc.left1, x: 0, y: 0.01, anchor: "center", fontSize: 0.2 }], ports: [{ ...Ny.left1, labels: ["1"] }, { ...Ny.right1, labels: ["2"] }], size: { width: Ve.width, height: Ve.height }, center: { x: Ve.centerX, y: Ve.centerY } });
-var { 5: Ec, ...Yc } = At2.primitives;
+var At3 = s({ primitives: [...Object.values(Fc), ...Object.values(Tc), { type: "text", text: "{REF}", x: 0, y: -0.3594553499999995, anchor: "middle_top" }, { type: "text", text: "{VAL}", x: 0, y: 0.35, anchor: "middle_bottom" }, { ...Rc.left1, x: 0, y: 0.01, anchor: "center", fontSize: 0.2 }], ports: [{ ...Ny.left1, labels: ["1"] }, { ...Ny.right1, labels: ["2"] }], size: { width: Ve.width, height: Ve.height }, center: { x: Ve.centerX, y: Ve.centerY } });
+var { 5: Ec, ...Yc } = At3.primitives;
 function Xc(t2) {
   return typeof t2 == "object";
 }
-var Iy = r({ ...At2, primitives: Object.values(Yc).filter(Xc) });
+var Iy = r({ ...At3, primitives: Object.values(Yc).filter(Xc) });
 var By = { ...Iy, primitives: [...Iy.primitives, Ec] };
 var qy = { paths: { path10: { type: "path", points: [{ x: -0.53, y: 0.04 }, { x: 0.53, y: 0.04 }], color: "primary", fill: false }, path14: { type: "path", points: [{ x: 0, y: 0.17 }, { x: 0.27, y: 0.17 }, { x: 0.27, y: -0.1 }, { x: -0.26, y: -0.1 }, { x: -0.26, y: 0.17 }, { x: 0, y: 0.17 }], color: "primary", fill: false } }, texts: { top1: { type: "text", text: "{REF}", x: -0.01, y: 0.24 }, bottom1: { type: "text", text: "{VAL}", x: -0.17, y: -0.24 } }, refblocks: { left1: { x: -0.53, y: 0.04 }, right1: { x: 0.53, y: 0.04 } }, bounds: { minX: -0.56, maxX: 0.56, minY: -0.24, maxY: 0.24, width: 1.13, height: 0.47, centerX: 0, centerY: 0 }, circles: {} };
 var { paths: Vc, texts: jc, bounds: je, refblocks: Dy } = qy;
@@ -90086,7 +91033,7 @@ var { paths: Ad, bounds: ss, refblocks: Pd } = xs;
 var U = e({ primitives: [...Object.values(Ad)], ports: [{ ...Pd.left1, labels: ["1"] }], center: { x: ss.centerX, y: ss.centerY } }).rotateRightFacingSymbol("right").labelPort("left1", ["1"]).build();
 var ms = r(U, "down");
 var ns = r(U, "left");
-var fs30 = r(U, "up");
+var fs31 = r(U, "up");
 var g = { paths: { path11: { type: "path", points: [{ x: -0.39, 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.54 }], color: "primary", fill: false }, "path12-1-5-3": { type: "path", points: [{ x: 0.29, y: -0.54 }, { 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 } } };
 var { paths: Fd, texts: XA, bounds: e0, refblocks: Mo, circles: Rd } = g;
 var hs = e({ primitives: [...Object.values(Fd), ...Object.values(Rd), { type: "text", text: "{REF}", x: -0.1, y: 0.3094553499999995 }, { type: "text", text: "{VAL}", x: -0.1, y: -0.3094553499999995 }], ports: [{ ...Mo.top1, labels: ["1", "collector"] }, { ...Mo.bottom1, labels: ["2", "emitter"] }, { ...Mo.left1, labels: ["3", "base"] }], size: { width: e0.width, height: e0.height }, center: { x: e0.centerX, y: e0.centerY } }).rotateRightFacingSymbol("right").changeTextAnchor("{REF}", "middle_right").changeTextAnchor("{VAL}", "middle_right").build();
@@ -90655,7 +91602,7 @@ var mb = Cl.primitives.find((t3) => t3.type === "text" && t3.text === "{VAL}");
 sb.anchor = "middle_left";
 mb.anchor = "middle_right";
 var B1 = Cl;
-var q1 = { ac_voltmeter_down: Ul, ac_voltmeter_horz: Wl, ac_voltmeter_left: Zl, ac_voltmeter_right: Kl, ac_voltmeter_up: ep, ac_voltmeter_vert: op, avalanche_diode_down: lp, avalanche_diode_horz: pp, avalanche_diode_left: yp, avalanche_diode_right: xp, avalanche_diode_up: mp, avalanche_diode_vert: fp, backward_diode_down: cp, backward_diode_left: Dt, backward_diode_right: _p, backward_diode_up: gp, battery_horz: Wt, battery_vert: Ap, boxresistor_down: Fp, boxresistor_left: Ep, boxresistor_right: Lp, boxresistor_small_down: jp, boxresistor_small_left: zp, boxresistor_small_right: Jp, boxresistor_small_up: Mp, boxresistor_up: Ip, bridged_ground_down: Dp, bridged_ground_left: Wp, bridged_ground_right: te, bridged_ground_up: Qp, capacitor_down: ta, capacitor_left: ea, capacitor_polarized_down: oa, capacitor_polarized_left: ia, capacitor_polarized_right: pa, capacitor_polarized_up: ya, capacitor_right: xa, capacitor_up: ma, constant_current_diode_down: fa, constant_current_diode_horz: ha, constant_current_diode_left: da, constant_current_diode_right: ba, constant_current_diode_up: ga, constant_current_diode_vert: va, crystal_4pin_down: wa, crystal_4pin_left: Aa, crystal_4pin_right: Pa, crystal_4pin_up: Sa, crystal_down: Ra, crystal_left: Ta, crystal_right: Ea, crystal_up: Xa, darlington_pair_transistor_down: La, darlington_pair_transistor_horz: Va, darlington_pair_transistor_left: ja, darlington_pair_transistor_right: ka, darlington_pair_transistor_up: za, darlington_pair_transistor_vert: Oa, dc_ammeter_horz: wt, dc_ammeter_vert: Ca, dc_voltmeter_down: Ia, dc_voltmeter_horz: qa, dc_voltmeter_left: Ua, dc_voltmeter_right: Wa, dc_voltmeter_up: Za, dc_voltmeter_vert: Ka, diac_down: ty, diac_horz: ey, diac_left: ry, diac_right: oy, diac_up: iy, diac_vert: ly, diode_down: ay, diode_left: yy, diode_right: $2, diode_up: xy, dpdt_normally_closed_switch_down: my, dpdt_normally_closed_switch_left: ny, dpdt_normally_closed_switch_right: M, dpdt_normally_closed_switch_up: fy, dpdt_switch_down: cy, dpdt_switch_left: dy, dpdt_switch_right: C, dpdt_switch_up: by, dpst_normally_closed_switch_down: gy, dpst_normally_closed_switch_left: uy, dpst_normally_closed_switch_right: N, dpst_normally_closed_switch_up: vy, dpst_switch_down: Ay, dpst_switch_left: Py, dpst_switch_right: I, dpst_switch_up: Sy, ferrite_bead_down: Ry, ferrite_bead_left: Ty, ferrite_bead_right: Fe, ferrite_bead_up: Se, filled_diode_down: Yy, filled_diode_horz: Ly, filled_diode_left: jy, filled_diode_right: zy, filled_diode_up: Jy, filled_diode_vert: My, frequency_meter_horz: At2, frequency_meter_vert: By, fuse_horz: ke, fuse_vert: Uy, ground_down: Gy, ground_horz: Wy, ground_left: Hy, ground_right: Zy, ground_up: Qy, ground_vert: Ky2, ground2_down: ex, ground2_left: ox, ground2_right: lx, ground2_up: ax, gunn_diode_horz: yx, gunn_diode_vert: xx, icled_down: mx, icled_left: nx, icled_right: q, icled_up: fx, igbt_transistor_horz: ze, igbt_transistor_vert: dx, illuminated_push_button_normally_open_horz: Oe, illuminated_push_button_normally_open_vert: ux, inductor_down: Px, inductor_left: Sx, inductor_right: _t, inductor_up: $e, laser_diode_down: Fx, laser_diode_left: Rx, laser_diode_right: D, laser_diode_up: Tx, led_down: Lx, led_left: Vx, led_right: gt, led_up: Ce, light_dependent_resistor_horz: Ie, light_dependent_resistor_vert: $x, mosfet_depletion_normally_on_horz: qe, mosfet_depletion_normally_on_vert: Ix, mushroom_head_normally_open_momentary_horz: Ue, mushroom_head_normally_open_momentary_vert: Ux, n_channel_d_mosfet_transistor_horz: He, n_channel_d_mosfet_transistor_vert: Qx, n_channel_e_mosfet_transistor_horz: Qe, n_channel_e_mosfet_transistor_vert: os5, njfet_transistor_horz: t0, njfet_transistor_vert: ys, not_connected_down: ms, not_connected_left: ns, not_connected_right: U, not_connected_up: fs30, npn_bipolar_transistor_down: hs, npn_bipolar_transistor_horz: cs, npn_bipolar_transistor_left: ds, npn_bipolar_transistor_right: bs, npn_bipolar_transistor_up: _s, npn_bipolar_transistor_vert: gs, opamp_no_power_down: vs, opamp_no_power_left: ws, opamp_no_power_right: G, opamp_no_power_up: As, opamp_with_power_down: Ss, opamp_with_power_left: Fs, opamp_with_power_right: W, opamp_with_power_up: Rs, p_channel_d_mosfet_transistor_horz: a0, p_channel_d_mosfet_transistor_vert: Ls, p_channel_e_mosfet_transistor_horz: x0, p_channel_e_mosfet_transistor_vert: Os, photodiode_horz: s0, photodiode_vert: Cs, pjfet_transistor_horz: n0, pjfet_transistor_vert: Ds, pnp_bipolar_transistor_down: Us, pnp_bipolar_transistor_horz: Gs, pnp_bipolar_transistor_left: Ws, pnp_bipolar_transistor_right: Hs, pnp_bipolar_transistor_up: Zs, pnp_bipolar_transistor_vert: Qs, potentiometer_horz: g0, potentiometer_vert: rm, potentiometer2_down: pm, potentiometer2_left: am, potentiometer2_right: H, potentiometer2_up: ym, potentiometer3_down: xm, potentiometer3_left: sm, potentiometer3_right: mm, potentiometer3_up: nm, power_factor_meter_horz: S0, power_factor_meter_vert: dm, push_button_normally_closed_momentary_horz: R0, push_button_normally_closed_momentary_vert: um, push_button_normally_open_momentary_horz: E0, push_button_normally_open_momentary_vert: Pm, rectifier_diode_horz: L0, rectifier_diode_vert: Rm, resistor_down: Em, resistor_left: Xm, resistor_right: Vm, resistor_up: km, resonator_down: Om, resonator_horz: M0, resonator_left: Jm, resonator_right: K, resonator_up: $m, resonator_vert: Mm, schottky_diode_down: Nm, schottky_diode_left: Im, schottky_diode_right: tt, schottky_diode_up: Bm, silicon_controlled_rectifier_horz: C0, silicon_controlled_rectifier_vert: Um, solderjumper2_bridged12_down: Gm, solderjumper2_bridged12_left: Wm, solderjumper2_bridged12_right: Hm, solderjumper2_bridged12_up: Zm, solderjumper2_down: Qm, solderjumper2_left: Km, solderjumper2_right: tn, solderjumper2_up: en, solderjumper3_bridged12_down: rn, solderjumper3_bridged12_left: on2, solderjumper3_bridged12_right: ln, solderjumper3_bridged12_up: pn, solderjumper3_bridged123_down: an, solderjumper3_bridged123_left: yn, solderjumper3_bridged123_right: xn, solderjumper3_bridged123_up: sn, solderjumper3_bridged23_down: mn, solderjumper3_bridged23_left: nn, solderjumper3_bridged23_right: fn, solderjumper3_bridged23_up: hn, solderjumper3_down: cn, solderjumper3_left: dn, solderjumper3_right: bn, solderjumper3_up: _n, spdt_normally_closed_switch_down: un, spdt_normally_closed_switch_left: vn, spdt_normally_closed_switch_right: at, spdt_normally_closed_switch_up: wn, spdt_switch_down: Pn, spdt_switch_left: Sn, spdt_switch_right: yt, spdt_switch_up: Fn, spst_normally_closed_switch_down: Rn, spst_normally_closed_switch_left: Tn, spst_normally_closed_switch_right: xt, spst_normally_closed_switch_up: En, spst_switch_down: Yn, spst_switch_left: Xn, spst_switch_right: st, spst_switch_up: Ln, square_wave_down: Vn, square_wave_left: jn, square_wave_right: kn, square_wave_up: zn, step_recovery_diode_horz: N0, step_recovery_diode_vert: On, tachometer_horz: Tt, tachometer_vert: Cn, testpoint_down: Bn, testpoint_left: qn, testpoint_right: nt, testpoint_up: Gn, tilted_ground_down: Hn, tilted_ground_left: Zn, tilted_ground_right: ut, tilted_ground_up: B0, triac_horz: q0, triac_vert: t1, tunnel_diode_horz: U0, tunnel_diode_vert: i1, unijunction_transistor_horz: W0, unijunction_transistor_vert: s1, usbc: n1, var_meter_horz: Z0, var_meter_vert: c1, varactor_diode_horz: K0, varactor_diode_vert: g1, varistor_horz: er, varistor_vert: A1, varmeter_horz: Et, varmeter_vert: R1, vcc_down: T1, vcc_left: E1, vcc_right: Y1, vcc_up: X1, volt_meter_horz: or, volt_meter_vert: L1, watt_hour_meter_horz: Yt, watt_hour_meter_vert: z1, wattmeter_horz: Xt, wattmeter_vert: M1, zener_diode_horz: ar, zener_diode_vert: B1 };
+var q1 = { ac_voltmeter_down: Ul, ac_voltmeter_horz: Wl, ac_voltmeter_left: Zl, ac_voltmeter_right: Kl, ac_voltmeter_up: ep, ac_voltmeter_vert: op, avalanche_diode_down: lp, avalanche_diode_horz: pp, avalanche_diode_left: yp, avalanche_diode_right: xp, avalanche_diode_up: mp, avalanche_diode_vert: fp, backward_diode_down: cp, backward_diode_left: Dt, backward_diode_right: _p, backward_diode_up: gp, battery_horz: Wt, battery_vert: Ap, boxresistor_down: Fp, boxresistor_left: Ep, boxresistor_right: Lp, boxresistor_small_down: jp, boxresistor_small_left: zp, boxresistor_small_right: Jp, boxresistor_small_up: Mp, boxresistor_up: Ip, bridged_ground_down: Dp, bridged_ground_left: Wp, bridged_ground_right: te, bridged_ground_up: Qp, capacitor_down: ta, capacitor_left: ea, capacitor_polarized_down: oa, capacitor_polarized_left: ia, capacitor_polarized_right: pa, capacitor_polarized_up: ya, capacitor_right: xa, capacitor_up: ma, constant_current_diode_down: fa, constant_current_diode_horz: ha, constant_current_diode_left: da, constant_current_diode_right: ba, constant_current_diode_up: ga, constant_current_diode_vert: va, crystal_4pin_down: wa, crystal_4pin_left: Aa, crystal_4pin_right: Pa, crystal_4pin_up: Sa, crystal_down: Ra, crystal_left: Ta, crystal_right: Ea, crystal_up: Xa, darlington_pair_transistor_down: La, darlington_pair_transistor_horz: Va, darlington_pair_transistor_left: ja, darlington_pair_transistor_right: ka, darlington_pair_transistor_up: za, darlington_pair_transistor_vert: Oa, dc_ammeter_horz: wt, dc_ammeter_vert: Ca, dc_voltmeter_down: Ia, dc_voltmeter_horz: qa, dc_voltmeter_left: Ua, dc_voltmeter_right: Wa, dc_voltmeter_up: Za, dc_voltmeter_vert: Ka, diac_down: ty, diac_horz: ey, diac_left: ry, diac_right: oy, diac_up: iy, diac_vert: ly, diode_down: ay, diode_left: yy, diode_right: $2, diode_up: xy, dpdt_normally_closed_switch_down: my, dpdt_normally_closed_switch_left: ny, dpdt_normally_closed_switch_right: M, dpdt_normally_closed_switch_up: fy, dpdt_switch_down: cy, dpdt_switch_left: dy, dpdt_switch_right: C, dpdt_switch_up: by, dpst_normally_closed_switch_down: gy, dpst_normally_closed_switch_left: uy, dpst_normally_closed_switch_right: N, dpst_normally_closed_switch_up: vy, dpst_switch_down: Ay, dpst_switch_left: Py, dpst_switch_right: I, dpst_switch_up: Sy, ferrite_bead_down: Ry, ferrite_bead_left: Ty, ferrite_bead_right: Fe, ferrite_bead_up: Se, filled_diode_down: Yy, filled_diode_horz: Ly, filled_diode_left: jy, filled_diode_right: zy, filled_diode_up: Jy, filled_diode_vert: My, frequency_meter_horz: At3, frequency_meter_vert: By, fuse_horz: ke, fuse_vert: Uy, ground_down: Gy, ground_horz: Wy, ground_left: Hy, ground_right: Zy, ground_up: Qy, ground_vert: Ky2, ground2_down: ex, ground2_left: ox, ground2_right: lx, ground2_up: ax, gunn_diode_horz: yx, gunn_diode_vert: xx, icled_down: mx, icled_left: nx, icled_right: q, icled_up: fx, igbt_transistor_horz: ze, igbt_transistor_vert: dx, illuminated_push_button_normally_open_horz: Oe, illuminated_push_button_normally_open_vert: ux, inductor_down: Px, inductor_left: Sx, inductor_right: _t, inductor_up: $e, laser_diode_down: Fx, laser_diode_left: Rx, laser_diode_right: D, laser_diode_up: Tx, led_down: Lx, led_left: Vx, led_right: gt, led_up: Ce, light_dependent_resistor_horz: Ie, light_dependent_resistor_vert: $x, mosfet_depletion_normally_on_horz: qe, mosfet_depletion_normally_on_vert: Ix, mushroom_head_normally_open_momentary_horz: Ue, mushroom_head_normally_open_momentary_vert: Ux, n_channel_d_mosfet_transistor_horz: He, n_channel_d_mosfet_transistor_vert: Qx, n_channel_e_mosfet_transistor_horz: Qe, n_channel_e_mosfet_transistor_vert: os5, njfet_transistor_horz: t0, njfet_transistor_vert: ys, not_connected_down: ms, not_connected_left: ns, not_connected_right: U, not_connected_up: fs31, npn_bipolar_transistor_down: hs, npn_bipolar_transistor_horz: cs, npn_bipolar_transistor_left: ds, npn_bipolar_transistor_right: bs, npn_bipolar_transistor_up: _s, npn_bipolar_transistor_vert: gs, opamp_no_power_down: vs, opamp_no_power_left: ws, opamp_no_power_right: G, opamp_no_power_up: As, opamp_with_power_down: Ss, opamp_with_power_left: Fs, opamp_with_power_right: W, opamp_with_power_up: Rs, p_channel_d_mosfet_transistor_horz: a0, p_channel_d_mosfet_transistor_vert: Ls, p_channel_e_mosfet_transistor_horz: x0, p_channel_e_mosfet_transistor_vert: Os, photodiode_horz: s0, photodiode_vert: Cs, pjfet_transistor_horz: n0, pjfet_transistor_vert: Ds, pnp_bipolar_transistor_down: Us, pnp_bipolar_transistor_horz: Gs, pnp_bipolar_transistor_left: Ws, pnp_bipolar_transistor_right: Hs, pnp_bipolar_transistor_up: Zs, pnp_bipolar_transistor_vert: Qs, potentiometer_horz: g0, potentiometer_vert: rm, potentiometer2_down: pm, potentiometer2_left: am, potentiometer2_right: H, potentiometer2_up: ym, potentiometer3_down: xm, potentiometer3_left: sm, potentiometer3_right: mm, potentiometer3_up: nm, power_factor_meter_horz: S0, power_factor_meter_vert: dm, push_button_normally_closed_momentary_horz: R0, push_button_normally_closed_momentary_vert: um, push_button_normally_open_momentary_horz: E0, push_button_normally_open_momentary_vert: Pm, rectifier_diode_horz: L0, rectifier_diode_vert: Rm, resistor_down: Em, resistor_left: Xm, resistor_right: Vm, resistor_up: km, resonator_down: Om, resonator_horz: M0, resonator_left: Jm, resonator_right: K, resonator_up: $m, resonator_vert: Mm, schottky_diode_down: Nm, schottky_diode_left: Im, schottky_diode_right: tt, schottky_diode_up: Bm, silicon_controlled_rectifier_horz: C0, silicon_controlled_rectifier_vert: Um, solderjumper2_bridged12_down: Gm, solderjumper2_bridged12_left: Wm, solderjumper2_bridged12_right: Hm, solderjumper2_bridged12_up: Zm, solderjumper2_down: Qm, solderjumper2_left: Km, solderjumper2_right: tn, solderjumper2_up: en, solderjumper3_bridged12_down: rn, solderjumper3_bridged12_left: on2, solderjumper3_bridged12_right: ln, solderjumper3_bridged12_up: pn, solderjumper3_bridged123_down: an, solderjumper3_bridged123_left: yn, solderjumper3_bridged123_right: xn, solderjumper3_bridged123_up: sn, solderjumper3_bridged23_down: mn, solderjumper3_bridged23_left: nn, solderjumper3_bridged23_right: fn, solderjumper3_bridged23_up: hn, solderjumper3_down: cn, solderjumper3_left: dn, solderjumper3_right: bn, solderjumper3_up: _n, spdt_normally_closed_switch_down: un, spdt_normally_closed_switch_left: vn, spdt_normally_closed_switch_right: at, spdt_normally_closed_switch_up: wn, spdt_switch_down: Pn, spdt_switch_left: Sn, spdt_switch_right: yt, spdt_switch_up: Fn, spst_normally_closed_switch_down: Rn, spst_normally_closed_switch_left: Tn, spst_normally_closed_switch_right: xt, spst_normally_closed_switch_up: En, spst_switch_down: Yn, spst_switch_left: Xn, spst_switch_right: st, spst_switch_up: Ln, square_wave_down: Vn, square_wave_left: jn, square_wave_right: kn, square_wave_up: zn, step_recovery_diode_horz: N0, step_recovery_diode_vert: On, tachometer_horz: Tt, tachometer_vert: Cn, testpoint_down: Bn, testpoint_left: qn, testpoint_right: nt, testpoint_up: Gn, tilted_ground_down: Hn, tilted_ground_left: Zn, tilted_ground_right: ut, tilted_ground_up: B0, triac_horz: q0, triac_vert: t1, tunnel_diode_horz: U0, tunnel_diode_vert: i1, unijunction_transistor_horz: W0, unijunction_transistor_vert: s1, usbc: n1, var_meter_horz: Z0, var_meter_vert: c1, varactor_diode_horz: K0, varactor_diode_vert: g1, varistor_horz: er, varistor_vert: A1, varmeter_horz: Et, varmeter_vert: R1, vcc_down: T1, vcc_left: E1, vcc_right: Y1, vcc_up: X1, volt_meter_horz: or, volt_meter_vert: L1, watt_hour_meter_horz: Yt, watt_hour_meter_vert: z1, wattmeter_horz: Xt, wattmeter_vert: M1, zener_diode_horz: ar, zener_diode_vert: B1 };
 var Y$ = Object.fromEntries(Object.keys(q1).map((t3) => [t3, t3]));
 function doesLineIntersectLine([a12, a22], [b12, b22], {
   lineThickness = 0
@@ -92685,11 +93632,11 @@ var require_react_reconciler_development = __commonJS2({
           fiber = fiber.next, id2--;
         return fiber;
       }
-      function copyWithSetImpl(obj, path32, index, value) {
-        if (index >= path32.length)
+      function copyWithSetImpl(obj, path33, index, value) {
+        if (index >= path33.length)
           return value;
-        var key = path32[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        updated[key] = copyWithSetImpl(obj[key], path32, index + 1, value);
+        var key = path33[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        updated[key] = copyWithSetImpl(obj[key], path33, index + 1, value);
         return updated;
       }
       function copyWithRename(obj, oldPath, newPath) {
@@ -92709,11 +93656,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, path32, index) {
-        var key = path32[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        if (index + 1 === path32.length)
+      function copyWithDeleteImpl(obj, path33, index) {
+        var key = path33[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        if (index + 1 === path33.length)
           return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-        updated[key] = copyWithDeleteImpl(obj[key], path32, index + 1);
+        updated[key] = copyWithDeleteImpl(obj[key], path33, index + 1);
         return updated;
       }
       function shouldSuspendImpl() {
@@ -101744,29 +102691,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, id2, path32, value) {
+      overrideHookState = function(fiber, id2, path33, value) {
         id2 = findHook(fiber, id2);
-        id2 !== null && (path32 = copyWithSetImpl(id2.memoizedState, path32, 0, value), id2.memoizedState = path32, id2.baseState = path32, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path32 = enqueueConcurrentRenderForLane(fiber, 2), path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2));
+        id2 !== null && (path33 = copyWithSetImpl(id2.memoizedState, path33, 0, value), id2.memoizedState = path33, id2.baseState = path33, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path33 = enqueueConcurrentRenderForLane(fiber, 2), path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2));
       };
-      overrideHookStateDeletePath = function(fiber, id2, path32) {
+      overrideHookStateDeletePath = function(fiber, id2, path33) {
         id2 = findHook(fiber, id2);
-        id2 !== null && (path32 = copyWithDeleteImpl(id2.memoizedState, path32, 0), id2.memoizedState = path32, id2.baseState = path32, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path32 = enqueueConcurrentRenderForLane(fiber, 2), path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2));
+        id2 !== null && (path33 = copyWithDeleteImpl(id2.memoizedState, path33, 0), id2.memoizedState = path33, id2.baseState = path33, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path33 = enqueueConcurrentRenderForLane(fiber, 2), path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2));
       };
       overrideHookStateRenamePath = function(fiber, id2, oldPath, newPath) {
         id2 = findHook(fiber, id2);
         id2 !== null && (oldPath = copyWithRename(id2.memoizedState, oldPath, newPath), id2.memoizedState = oldPath, id2.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
       };
-      overrideProps = function(fiber, path32, value) {
-        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path32, 0, value);
+      overrideProps = function(fiber, path33, value) {
+        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path33, 0, value);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path32 = enqueueConcurrentRenderForLane(fiber, 2);
-        path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2);
+        path33 = enqueueConcurrentRenderForLane(fiber, 2);
+        path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2);
       };
-      overridePropsDeletePath = function(fiber, path32) {
-        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path32, 0);
+      overridePropsDeletePath = function(fiber, path33) {
+        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path33, 0);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path32 = enqueueConcurrentRenderForLane(fiber, 2);
-        path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2);
+        path33 = enqueueConcurrentRenderForLane(fiber, 2);
+        path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2);
       };
       overridePropsRenamePath = function(fiber, oldPath, newPath) {
         fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -117103,10 +118050,10 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
         var setErrorHandler = null;
         var setSuspenseHandler = null;
         {
-          var copyWithDeleteImpl = function(obj, path32, index2) {
-            var key = path32[index2];
+          var copyWithDeleteImpl = function(obj, path33, index2) {
+            var key = path33[index2];
             var updated = isArray2(obj) ? obj.slice() : assign2({}, obj);
-            if (index2 + 1 === path32.length) {
+            if (index2 + 1 === path33.length) {
               if (isArray2(updated)) {
                 updated.splice(key, 1);
               } else {
@@ -117114,11 +118061,11 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               }
               return updated;
             }
-            updated[key] = copyWithDeleteImpl(obj[key], path32, index2 + 1);
+            updated[key] = copyWithDeleteImpl(obj[key], path33, index2 + 1);
             return updated;
           };
-          var copyWithDelete = function(obj, path32) {
-            return copyWithDeleteImpl(obj, path32, 0);
+          var copyWithDelete = function(obj, path33) {
+            return copyWithDeleteImpl(obj, path33, 0);
           };
           var copyWithRenameImpl = function(obj, oldPath, newPath, index2) {
             var oldKey = oldPath[index2];
@@ -117150,17 +118097,17 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
             }
             return copyWithRenameImpl(obj, oldPath, newPath, 0);
           };
-          var copyWithSetImpl = function(obj, path32, index2, value) {
-            if (index2 >= path32.length) {
+          var copyWithSetImpl = function(obj, path33, index2, value) {
+            if (index2 >= path33.length) {
               return value;
             }
-            var key = path32[index2];
+            var key = path33[index2];
             var updated = isArray2(obj) ? obj.slice() : assign2({}, obj);
-            updated[key] = copyWithSetImpl(obj[key], path32, index2 + 1, value);
+            updated[key] = copyWithSetImpl(obj[key], path33, index2 + 1, value);
             return updated;
           };
-          var copyWithSet = function(obj, path32, value) {
-            return copyWithSetImpl(obj, path32, 0, value);
+          var copyWithSet = function(obj, path33, value) {
+            return copyWithSetImpl(obj, path33, 0, value);
           };
           var findHook = function(fiber, id2) {
             var currentHook2 = fiber.memoizedState;
@@ -117170,10 +118117,10 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
             }
             return currentHook2;
           };
-          overrideHookState = function(fiber, id2, path32, value) {
+          overrideHookState = function(fiber, id2, path33, value) {
             var hook = findHook(fiber, id2);
             if (hook !== null) {
-              var newState = copyWithSet(hook.memoizedState, path32, value);
+              var newState = copyWithSet(hook.memoizedState, path33, value);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign2({}, fiber.memoizedProps);
@@ -117183,10 +118130,10 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               }
             }
           };
-          overrideHookStateDeletePath = function(fiber, id2, path32) {
+          overrideHookStateDeletePath = function(fiber, id2, path33) {
             var hook = findHook(fiber, id2);
             if (hook !== null) {
-              var newState = copyWithDelete(hook.memoizedState, path32);
+              var newState = copyWithDelete(hook.memoizedState, path33);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign2({}, fiber.memoizedProps);
@@ -117209,8 +118156,8 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               }
             }
           };
-          overrideProps = function(fiber, path32, value) {
-            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path32, value);
+          overrideProps = function(fiber, path33, value) {
+            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path33, value);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -117219,8 +118166,8 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
             }
           };
-          overridePropsDeletePath = function(fiber, path32) {
-            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path32);
+          overridePropsDeletePath = function(fiber, path33) {
+            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path33);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -123271,7 +124218,7 @@ var parsePin = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path32 = pathMatch ? pathMatch[1] : "";
+  const path33 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r3 = Number.parseFloat(rotation2);
@@ -123285,7 +124232,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r3) ? 0 : r3,
     label,
     labelColor,
-    path: path32,
+    path: path33,
     arrow
   };
 };
@@ -123725,15 +124672,15 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path32 = [];
+  const path33 = [];
   for (let i = 0;i <= numPoints; i++) {
     const t3 = i / numPoints;
     const angle2 = startAngle + t3 * (endAngle - startAngle);
     const x = centerX + radius * Math.cos(angle2);
     const y = centerY + radius * Math.sin(angle2);
-    path32.push({ x, y });
+    path33.push({ x, y });
   }
-  return path32;
+  return path33;
 }
 var __defProp4 = Object.defineProperty;
 var __export22 = (target, all) => {
@@ -125151,7 +126098,7 @@ var platedHoleWithRectPad = (pn2, x, y, holeDiameter, rectPadWidth, rectPadHeigh
   };
 };
 var silkscreenPin = ({
-  fs: fs31,
+  fs: fs32,
   pn: pn2,
   anchor_x,
   anchor_y,
@@ -125194,7 +126141,7 @@ var silkscreenPin = ({
     type: "pcb_silkscreen_text",
     pcb_silkscreen_text_id: "silkscreen_text_1",
     font: "tscircuit2024",
-    font_size: fs31,
+    font_size: fs32,
     pcb_component_id: "pcb_component_1",
     text: `{PIN${pn2}}`,
     layer,
@@ -129801,7 +130748,7 @@ var m2host = (raw_params) => {
   }
   const centerX = (minX + maxX) / 2;
   const centerY = (minY + maxY) / 2;
-  const translate4 = (el2) => {
+  const translate42 = (el2) => {
     if (typeof el2.x === "number")
       el2.x -= centerX;
     if (typeof el2.y === "number")
@@ -129818,9 +130765,9 @@ var m2host = (raw_params) => {
     }
   };
   for (const pad2 of pads)
-    translate4(pad2);
-  translate4(cutout);
-  translate4(pin1Marker);
+    translate42(pad2);
+  translate42(cutout);
+  translate42(pin1Marker);
   return {
     circuitJson: [
       ...pads,
@@ -132810,17 +133757,17 @@ var ObstacleList = class {
     return obstacles;
   }
 };
-function removePathLoops(path32) {
-  if (path32.length < 4)
-    return path32;
-  const result = [{ ...path32[0] }];
-  let currentLayer = path32[0].layer;
-  for (let i = 1;i < path32.length; i++) {
-    const currentSegment = { start: path32[i - 1], end: path32[i] };
-    const isVia = path32[i].route_type === "via" || path32[i - 1].route_type === "via";
-    if (path32[i].layer !== currentLayer || isVia) {
-      result.push({ ...path32[i] });
-      currentLayer = path32[i].layer;
+function removePathLoops(path33) {
+  if (path33.length < 4)
+    return path33;
+  const result = [{ ...path33[0] }];
+  let currentLayer = path33[0].layer;
+  for (let i = 1;i < path33.length; i++) {
+    const currentSegment = { start: path33[i - 1], end: path33[i] };
+    const isVia = path33[i].route_type === "via" || path33[i - 1].route_type === "via";
+    if (path33[i].layer !== currentLayer || isVia) {
+      result.push({ ...path33[i] });
+      currentLayer = path33[i].layer;
       continue;
     }
     let intersectionFound = false;
@@ -132849,8 +133796,8 @@ function removePathLoops(path32) {
       result.push(intersectionPoint);
     }
     const lastPoint = result[result.length - 1];
-    if (lastPoint.x !== path32[i].x || lastPoint.y !== path32[i].y) {
-      result.push(path32[i]);
+    if (lastPoint.x !== path33[i].x || lastPoint.y !== path33[i].y) {
+      result.push(path33[i]);
     }
   }
   return result;
@@ -133339,10 +134286,10 @@ var GeneralizedAstarAutorouter = class {
       });
     }
     if (current2.parent) {
-      const path32 = [];
+      const path33 = [];
       let p = current2;
       while (p) {
-        path32.unshift(p);
+        path33.unshift(p);
         p = p.parent;
       }
       debugSolution.push({
@@ -133350,7 +134297,7 @@ var GeneralizedAstarAutorouter = class {
         pcb_component_id: "",
         pcb_fabrication_note_path_id: `note_path_${current2.x}_${current2.y}`,
         layer: "top",
-        route: path32,
+        route: path33,
         stroke_width: 0.01
       });
     }
@@ -138272,13 +139219,13 @@ var RBush = class {
       return this;
     let node = this.data;
     const bbox = this.toBBox(item);
-    const path32 = [];
+    const path33 = [];
     const indexes = [];
     let i, parent, goingUp;
-    while (node || path32.length) {
+    while (node || path33.length) {
       if (!node) {
-        node = path32.pop();
-        parent = path32[path32.length - 1];
+        node = path33.pop();
+        parent = path33[path33.length - 1];
         i = indexes.pop();
         goingUp = true;
       }
@@ -138286,13 +139233,13 @@ var RBush = class {
         const index = findItem(item, node.children, equalsFn);
         if (index !== -1) {
           node.children.splice(index, 1);
-          path32.push(node);
-          this._condense(path32);
+          path33.push(node);
+          this._condense(path33);
           return this;
         }
       }
       if (!goingUp && !node.leaf && contains(node, bbox)) {
-        path32.push(node);
+        path33.push(node);
         indexes.push(i);
         i = 0;
         parent = node;
@@ -138363,10 +139310,10 @@ var RBush = class {
     calcBBox(node, this.toBBox);
     return node;
   }
-  _chooseSubtree(bbox, node, level, path32) {
+  _chooseSubtree(bbox, node, level, path33) {
     while (true) {
-      path32.push(node);
-      if (node.leaf || path32.length - 1 === level)
+      path33.push(node);
+      if (node.leaf || path33.length - 1 === level)
         break;
       let minArea = Infinity;
       let minEnlargement = Infinity;
@@ -138475,21 +139422,21 @@ var RBush = class {
     }
     return margin;
   }
-  _adjustParentBBoxes(bbox, path32, level) {
+  _adjustParentBBoxes(bbox, path33, level) {
     for (let i = level;i >= 0; i--) {
-      extend(path32[i], bbox);
+      extend(path33[i], bbox);
     }
   }
-  _condense(path32) {
-    for (let i = path32.length - 1, siblings;i >= 0; i--) {
-      if (path32[i].children.length === 0) {
+  _condense(path33) {
+    for (let i = path33.length - 1, siblings;i >= 0; i--) {
+      if (path33[i].children.length === 0) {
         if (i > 0) {
-          siblings = path32[i - 1].children;
-          siblings.splice(siblings.indexOf(path32[i]), 1);
+          siblings = path33[i - 1].children;
+          siblings.splice(siblings.indexOf(path33[i]), 1);
         } else
           this.clear();
       } else
-        calcBBox(path32[i], this.toBBox);
+        calcBBox(path33[i], this.toBBox);
     }
   }
 };
@@ -139634,7 +140581,7 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
     this.capacityPaths = capacityPaths;
     this.colorMap = colorMap ?? {};
     this.unprocessedNodeIds = [
-      ...new Set(capacityPaths.flatMap((path32) => path32.nodeIds))
+      ...new Set(capacityPaths.flatMap((path33) => path33.nodeIds))
     ];
     this.nodePortSegments = /* @__PURE__ */ new Map;
   }
@@ -139645,17 +140592,17 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
       return;
     }
     const pathsGoingThroughNode = [];
-    for (const path32 of this.capacityPaths) {
-      const indexOfNodeInPath = path32.nodeIds.indexOf(nodeId);
+    for (const path33 of this.capacityPaths) {
+      const indexOfNodeInPath = path33.nodeIds.indexOf(nodeId);
       if (indexOfNodeInPath !== -1) {
-        pathsGoingThroughNode.push({ path: path32, indexOfNodeInPath });
+        pathsGoingThroughNode.push({ path: path33, indexOfNodeInPath });
       }
     }
     const node = this.nodeMap.get(nodeId);
     const nodePortSegments = [];
-    for (const { path: path32, indexOfNodeInPath } of pathsGoingThroughNode) {
-      const entryNodeId = path32.nodeIds[indexOfNodeInPath - 1];
-      const exitNodeId = path32.nodeIds[indexOfNodeInPath + 1];
+    for (const { path: path33, indexOfNodeInPath } of pathsGoingThroughNode) {
+      const entryNodeId = path33.nodeIds[indexOfNodeInPath - 1];
+      const exitNodeId = path33.nodeIds[indexOfNodeInPath + 1];
       for (const adjNodeId of [entryNodeId, exitNodeId]) {
         const adjNode = this.nodeMap.get(adjNodeId);
         if (!adjNode)
@@ -139668,7 +140615,7 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
           capacityMeshNodeId: nodeId,
           start: segment2.start,
           end: segment2.end,
-          connectionNames: [path32.connectionName],
+          connectionNames: [path33.connectionName],
           availableZ: mutuallyAvailableZ
         };
         nodePortSegments.push(portSegment);
@@ -140474,37 +141421,37 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     return neighbors;
   }
   getNodePath(node) {
-    const path32 = [];
+    const path33 = [];
     while (node) {
-      path32.push(node);
+      path33.push(node);
       node = node.parent;
     }
-    return path32;
+    return path33;
   }
   getViasInNodePath(node) {
-    const path32 = this.getNodePath(node);
+    const path33 = this.getNodePath(node);
     const vias = [];
-    for (let i = 0;i < path32.length - 1; i++) {
-      if (path32[i].z !== path32[i + 1].z) {
-        vias.push({ x: path32[i].x, y: path32[i].y });
+    for (let i = 0;i < path33.length - 1; i++) {
+      if (path33[i].z !== path33[i + 1].z) {
+        vias.push({ x: path33[i].x, y: path33[i].y });
       }
     }
     return vias;
   }
   setSolvedPath(node) {
-    const path32 = this.getNodePath(node);
-    path32.reverse();
+    const path33 = this.getNodePath(node);
+    path33.reverse();
     const vias = [];
-    for (let i = 0;i < path32.length - 1; i++) {
-      if (path32[i].z !== path32[i + 1].z) {
-        vias.push({ x: path32[i].x, y: path32[i].y });
+    for (let i = 0;i < path33.length - 1; i++) {
+      if (path33[i].z !== path33[i + 1].z) {
+        vias.push({ x: path33[i].x, y: path33[i].y });
       }
     }
     this.solvedPath = {
       connectionName: this.connectionName,
       traceThickness: this.traceThickness,
       viaDiameter: this.viaDiameter,
-      route: path32.map((node2) => ({ x: node2.x, y: node2.y, z: node2.z })).concat([this.B]),
+      route: path33.map((node2) => ({ x: node2.x, y: node2.y, z: node2.z })).concat([this.B]),
       vias
     };
   }
@@ -141312,12 +142259,12 @@ function computeDumbbellPaths({
       specialType: circleCenter === A3 ? "A" : "B"
     };
   };
-  const subdivideOptimalPath = (path32, numSubdivisions) => {
-    if (path32.length < 2)
-      return path32;
-    const result = [path32[0]];
-    for (let i = 0;i < path32.length - 1; i++) {
-      const segment2 = { start: path32[i], end: path32[i + 1] };
+  const subdivideOptimalPath = (path33, numSubdivisions) => {
+    if (path33.length < 2)
+      return path33;
+    const result = [path33[0]];
+    for (let i = 0;i < path33.length - 1; i++) {
+      const segment2 = { start: path33[i], end: path33[i + 1] };
       const segmentMidpoint = {
         x: (segment2.start.x + segment2.end.x) / 2,
         y: (segment2.start.y + segment2.end.y) / 2
@@ -141379,7 +142326,7 @@ function computeDumbbellPaths({
         }
         subdivisionPoints.forEach((p) => result.push(p));
       }
-      result.push(path32[i + 1]);
+      result.push(path33[i + 1]);
     }
     if (result.length > 1) {
       const filteredResult = [result[0]];
@@ -141614,13 +142561,13 @@ function computeDumbbellPaths({
     ].map((l, index) => ({ ...l, index }));
   };
   const subdivideJLinePath = (jLine, oppositePoint, r3, m2, numSubdivisions) => {
-    const path32 = jLine.points;
-    if (path32.length < 2)
-      return path32;
+    const path33 = jLine.points;
+    if (path33.length < 2)
+      return path33;
     const minDistThreshold = r3 + m2;
-    const result = [path32[0]];
-    for (let i = 0;i < path32.length - 1; i++) {
-      const segment2 = { start: path32[i], end: path32[i + 1] };
+    const result = [path33[0]];
+    for (let i = 0;i < path33.length - 1; i++) {
+      const segment2 = { start: path33[i], end: path33[i + 1] };
       const distToOpposite = pointToSegmentDistance22(oppositePoint, segment2.start, segment2.end);
       if (distToOpposite < minDistThreshold) {
         const closestPt = closestPointOnSegment(segment2, oppositePoint);
@@ -141689,26 +142636,26 @@ function computeDumbbellPaths({
       return { index: 0, path: [] };
     }
     const optimalPath2 = validPaths.sort((a, b3) => a.length - b3.length)[0];
-    const path32 = [...optimalPath2.path];
-    const firstPoint = path32[0];
-    const dist3 = distance3(firstPoint, path32[2]);
-    const dist4 = distance3(firstPoint, path32[3]);
+    const path33 = [...optimalPath2.path];
+    const firstPoint = path33[0];
+    const dist3 = distance3(firstPoint, path33[2]);
+    const dist4 = distance3(firstPoint, path33[3]);
     const closerIdx = dist3 < dist4 ? 2 : 3;
-    if (dist3 < distance3(firstPoint, path32[1]) || dist4 < distance3(firstPoint, path32[1])) {
-      path32.splice(1, closerIdx - 1);
+    if (dist3 < distance3(firstPoint, path33[1]) || dist4 < distance3(firstPoint, path33[1])) {
+      path33.splice(1, closerIdx - 1);
     }
-    const lastPoint = path32[path32.length - 1];
-    const distM3 = distance3(lastPoint, path32[path32.length - 3]);
-    const distM4 = distance3(lastPoint, path32[path32.length - 4]);
-    const closerLastIdx = distM3 < distM4 ? path32.length - 3 : path32.length - 4;
-    if (distM3 < distance3(lastPoint, path32[path32.length - 2]) || distM4 < distance3(lastPoint, path32[path32.length - 2])) {
-      path32.splice(closerLastIdx + 1, path32.length - closerLastIdx - 2);
+    const lastPoint = path33[path33.length - 1];
+    const distM3 = distance3(lastPoint, path33[path33.length - 3]);
+    const distM4 = distance3(lastPoint, path33[path33.length - 4]);
+    const closerLastIdx = distM3 < distM4 ? path33.length - 3 : path33.length - 4;
+    if (distM3 < distance3(lastPoint, path33[path33.length - 2]) || distM4 < distance3(lastPoint, path33[path33.length - 2])) {
+      path33.splice(closerLastIdx + 1, path33.length - closerLastIdx - 2);
     }
     return {
       index: optimalPath2.index,
-      path: path32,
-      startsAt: path32[0] === C2 ? "C" : "D",
-      goesTo: path32[path32.length - 1] === C2 ? "C" : "D"
+      path: path33,
+      startsAt: path33[0] === C2 ? "C" : "D",
+      goesTo: path33[path33.length - 1] === C2 ? "C" : "D"
     };
   };
   const optimalPath = findOptimalPath();
@@ -143128,9 +144075,9 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
     let closestIntersection = null;
     let intersectedSegmentZ = null;
     const checkIntersectionsWithPathMap = (pathMap) => {
-      for (const path32 of pathMap.values()) {
-        for (let i = 0;i < path32.length - 1; i++) {
-          const segment2 = [path32[i], path32[i + 1]];
+      for (const path33 of pathMap.values()) {
+        for (let i = 0;i < path33.length - 1; i++) {
+          const segment2 = [path33[i], path33[i + 1]];
           if (segment2[0].x === segment2[1].x && segment2[0].y === segment2[1].y) {
             continue;
           }
@@ -143260,11 +144207,11 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
       });
     }
     const drawPath = (pathMap, labelPrefix) => {
-      for (const [connectionName, path32] of pathMap.entries()) {
+      for (const [connectionName, path33] of pathMap.entries()) {
         const color = colorMap[connectionName] ?? "black";
-        for (let i = 0;i < path32.length - 1; i++) {
-          const p12 = path32[i];
-          const p2 = path32[i + 1];
+        for (let i = 0;i < path33.length - 1; i++) {
+          const p12 = path33[i];
+          const p2 = path33[i + 1];
           if (p12.x === p2.x && p12.y === p2.y && p12.z !== p2.z) {
             graphics.circles.push({
               center: { x: p12.x, y: p12.y },
@@ -143862,10 +144809,10 @@ function detectMultiConnectionClosedFacesWithoutVias(polyLines, bounds) {
   const allSegments = [];
   const viaPoints = /* @__PURE__ */ new Map;
   for (const polyLine of polyLines) {
-    const path32 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
-    for (let i = 0;i < path32.length - 1; i++) {
-      const p12 = path32[i];
-      const p2 = path32[i + 1];
+    const path33 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
+    for (let i = 0;i < path33.length - 1; i++) {
+      const p12 = path33[i];
+      const p2 = path33[i + 1];
       const layer = p12.z2;
       allSegments.push({
         start: { x: p12.x, y: p12.y },
@@ -143883,7 +144830,7 @@ function detectMultiConnectionClosedFacesWithoutVias(polyLines, bounds) {
         }
       }
     }
-    const lastPoint = path32[path32.length - 1];
+    const lastPoint = path33[path33.length - 1];
     if (lastPoint.z1 !== lastPoint.z2) {
       const key = pointKey2(lastPoint);
       if (!viaPoints.has(key)) {
@@ -144182,14 +145129,14 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     const polyLineVias = [];
     for (let i = 0;i < polyLines.length; i++) {
       const polyLine = polyLines[i];
-      const path32 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
+      const path33 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
       const segmentsByLayer = new Map(this.availableZ.map((z852) => [z852, []]));
-      for (let i22 = 0;i22 < path32.length - 1; i22++) {
-        const segment2 = [path32[i22], path32[i22 + 1]];
+      for (let i22 = 0;i22 < path33.length - 1; i22++) {
+        const segment2 = [path33[i22], path33[i22 + 1]];
         segmentsByLayer.get(segment2[0].z2).push(segment2);
       }
       polyLineSegmentsByLayer.push(segmentsByLayer);
-      polyLineVias.push(path32.filter((p) => p.z1 !== p.z2));
+      polyLineVias.push(path33.filter((p) => p.z1 !== p.z2));
     }
     for (let i = 0;i < polyLines.length; i++) {
       const path1SegmentsByLayer = polyLineSegmentsByLayer[i];
@@ -145618,7 +146565,7 @@ var HighDensitySolver = class extends BaseSolver {
       if (this.failedSolvers.length > 0) {
         this.solved = false;
         this.failed = true;
-        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs31) => fs31.nodeWithPortPoints.capacityMeshNodeId)}. err0: ${this.failedSolvers[0].error}.`;
+        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs32) => fs32.nodeWithPortPoints.capacityMeshNodeId)}. err0: ${this.failedSolvers[0].error}.`;
         return;
       }
       this.solved = true;
@@ -148399,13 +149346,13 @@ var CapacityPathingSolver = class extends BaseSolver {
     return this.getDistanceBetweenNodes(node, endGoal);
   }
   getBacktrackedPath(candidate) {
-    const path32 = [];
+    const path33 = [];
     let currentCandidate = candidate;
     while (currentCandidate) {
-      path32.push(currentCandidate.node);
+      path33.push(currentCandidate.node);
       currentCandidate = currentCandidate.prevCandidate;
     }
-    return path32;
+    return path33;
   }
   getNeighboringNodes(node) {
     return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap((edge) => edge.nodeIds.filter((n3) => n3 !== node.capacityMeshNodeId)).map((n3) => this.nodeMap.get(n3));
@@ -148413,12 +149360,12 @@ var CapacityPathingSolver = class extends BaseSolver {
   getCapacityPaths() {
     const capacityPaths = [];
     for (const connection of this.connectionsWithNodes) {
-      const path32 = connection.path;
-      if (path32) {
+      const path33 = connection.path;
+      if (path33) {
         capacityPaths.push({
           capacityPathId: connection.connection.name,
           connectionName: connection.connection.name,
-          nodeIds: path32.map((node) => node.capacityMeshNodeId)
+          nodeIds: path33.map((node) => node.capacityMeshNodeId)
         });
       }
     }
@@ -149103,10 +150050,10 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
     return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
   }
   getBacktrackedPath(candidate) {
-    const path32 = [];
+    const path33 = [];
     let currentCandidate = candidate;
     while (currentCandidate) {
-      path32.push(currentCandidate.node);
+      path33.push(currentCandidate.node);
       if (this.nodeMap.has(currentCandidate.node.capacityMeshNodeId)) {
         currentCandidate = currentCandidate.prevCandidate;
       } else {
@@ -149114,7 +150061,7 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
         break;
       }
     }
-    return path32.reverse();
+    return path33.reverse();
   }
   getNeighboringNodes(node) {
     if (!this.nodeMap.has(node.capacityMeshNodeId))
@@ -149129,8 +150076,8 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   doesNodeHaveCapacityForTrace(node, prevNode) {
     return true;
   }
-  reduceCapacityAlongPath(path32) {
-    for (const pathNode of path32) {
+  reduceCapacityAlongPath(path33) {
+    for (const pathNode of path33) {
       if (this.usedNodeCapacityMap.has(pathNode.capacityMeshNodeId)) {
         const nodeId = pathNode.capacityMeshNodeId;
         const nodeInSection = this.nodeMap.get(nodeId);
@@ -149259,9 +150206,9 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
     this.queuedNodes = null;
   }
   _handleGoalReached(currentCandidate, currentTerminal, endNode) {
-    const path32 = this.getBacktrackedPath(currentCandidate);
-    currentTerminal.path = path32;
-    this.reduceCapacityAlongPath(path32);
+    const path33 = this.getBacktrackedPath(currentCandidate);
+    currentTerminal.path = path33;
+    this.reduceCapacityAlongPath(path33);
     this.currentConnectionIndex++;
     this.candidates = null;
     this.visitedNodes = null;
@@ -149310,10 +150257,10 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
       const connectionColor = this.colorMap[connectionName] ?? "purple";
       topCandidates.forEach((candidate, index) => {
         const opacity = 0.8 * (1 - index / 5);
-        const path32 = this.getBacktrackedPath(candidate);
-        if (path32.length > 0) {
+        const path33 = this.getBacktrackedPath(candidate);
+        if (path33.length > 0) {
           baseGraphics.lines.push({
-            points: path32.map(({ center: { x, y } }) => ({ x, y })),
+            points: path33.map(({ center: { x, y } }) => ({ x, y })),
             strokeColor: safeTransparentize(connectionColor, 1 - opacity),
             strokeWidth: 0.05
           });
@@ -150002,12 +150949,12 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   getCapacityPaths() {
     const capacityPaths = [];
     for (const connection of this.connectionsWithNodes) {
-      const path32 = connection.path;
-      if (path32) {
+      const path33 = connection.path;
+      if (path33) {
         capacityPaths.push({
           capacityPathId: connection.connection.name,
           connectionName: connection.connection.name,
-          nodeIds: path32.map((node) => node.capacityMeshNodeId)
+          nodeIds: path33.map((node) => node.capacityMeshNodeId)
         });
       }
     }
@@ -151028,22 +151975,22 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       return null;
     }
     const possiblePaths = calculate45DegreePaths({ x: start.x, y: start.y }, { x: end.x, y: end.y });
-    for (const path32 of possiblePaths) {
-      const fullPath = path32.map((p) => ({ x: p.x, y: p.y, z: start.z }));
+    for (const path33 of possiblePaths) {
+      const fullPath = path33.map((p) => ({ x: p.x, y: p.y, z: start.z }));
       if (this.isValidPath(fullPath)) {
         return fullPath;
       }
     }
     return null;
   }
-  addPathToResult(path32) {
-    if (path32.length === 0)
+  addPathToResult(path33) {
+    if (path33.length === 0)
       return;
-    for (let i = 0;i < path32.length; i++) {
-      if (i === 0 && this.newRoute.length > 0 && this.arePointsEqual(this.newRoute[this.newRoute.length - 1], path32[i])) {
+    for (let i = 0;i < path33.length; i++) {
+      if (i === 0 && this.newRoute.length > 0 && this.arePointsEqual(this.newRoute[this.newRoute.length - 1], path33[i])) {
         continue;
       }
-      this.newRoute.push(path32[i]);
+      this.newRoute.push(path33[i]);
     }
     this.currentStepSize = this.maxStepSize;
   }
@@ -166713,11 +167660,11 @@ var SchematicPartitionProcessor = class {
         continue;
       const stroke = getColorByIndex(partitionIdx, this.wipPartitions.length, 1);
       const { x, y } = getPinPosition(this.lastGraph, boxId, pinId);
-      const scale32 = 1 + 0.1 * partitionIdx;
+      const scale33 = 1 + 0.1 * partitionIdx;
       graphics.rects.push({
         center: { x, y },
-        width: unexploredRectBaseSize * scale32,
-        height: unexploredRectBaseSize * scale32,
+        width: unexploredRectBaseSize * scale33,
+        height: unexploredRectBaseSize * scale33,
         fill: "none",
         stroke
       });
@@ -174463,14 +175410,14 @@ var PrimitiveComponent2 = class extends Renderable {
   }
   computePcbPropsTransform() {
     const { _parsedProps: props } = this;
-    const matrix2 = compose3(translate3(props.pcbX ?? 0, props.pcbY ?? 0), rotate((props.pcbRotation ?? 0) * Math.PI / 180));
+    const matrix2 = compose4(translate4(props.pcbX ?? 0, props.pcbY ?? 0), rotate5((props.pcbRotation ?? 0) * Math.PI / 180));
     return matrix2;
   }
   _computePcbGlobalTransformBeforeLayout() {
     const { _parsedProps: props } = this;
     const manualPlacement = this.getSubcircuit()._getPcbManualPlacementForComponent(this);
     if (manualPlacement && this.props.pcbX === undefined && this.props.pcbY === undefined) {
-      return compose3(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity(), compose3(translate3(manualPlacement.x, manualPlacement.y), rotate((props.pcbRotation ?? 0) * Math.PI / 180)));
+      return compose4(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity4(), compose4(translate4(manualPlacement.x, manualPlacement.y), rotate5((props.pcbRotation ?? 0) * Math.PI / 180)));
     }
     if (this.isPcbPrimitive) {
       const primitiveContainer = this.getPrimitiveContainer();
@@ -174478,12 +175425,12 @@ var PrimitiveComponent2 = class extends Renderable {
         const isFlipped = primitiveContainer._parsedProps.layer === "bottom";
         const containerCenter = primitiveContainer._getGlobalPcbPositionBeforeLayout();
         if (isFlipped) {
-          const flipOperation = compose3(translate3(containerCenter.x, containerCenter.y), flipY(), translate3(-containerCenter.x, -containerCenter.y));
-          return compose3(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity(), flipY(), this.computePcbPropsTransform());
+          const flipOperation = compose4(translate4(containerCenter.x, containerCenter.y), flipY(), translate4(-containerCenter.x, -containerCenter.y));
+          return compose4(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity4(), flipY(), this.computePcbPropsTransform());
         }
       }
     }
-    return compose3(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity(), this.computePcbPropsTransform());
+    return compose4(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity4(), this.computePcbPropsTransform());
   }
   getPrimitiveContainer() {
     if (this.isPrimitiveContainer)
@@ -174514,13 +175461,13 @@ var PrimitiveComponent2 = class extends Renderable {
   }
   computeSchematicPropsTransform() {
     const { _parsedProps: props } = this;
-    return compose3(translate3(props.schX ?? 0, props.schY ?? 0));
+    return compose4(translate4(props.schX ?? 0, props.schY ?? 0));
   }
   computeSchematicGlobalTransform() {
     const manualPlacementTransform = this._getSchematicGlobalManualPlacementTransform(this);
     if (manualPlacementTransform)
       return manualPlacementTransform;
-    return compose3(this.parent?.computeSchematicGlobalTransform?.() ?? identity(), this.computeSchematicPropsTransform());
+    return compose4(this.parent?.computeSchematicGlobalTransform?.() ?? identity4(), this.computeSchematicPropsTransform());
   }
   _getSchematicSymbolName() {
     const { _parsedProps: props } = this;
@@ -174606,7 +175553,7 @@ var PrimitiveComponent2 = class extends Renderable {
       return null;
     for (const position2 of placementConfigPositions) {
       if (isMatchingSelector(component, position2.selector) || component.props.name === position2.selector) {
-        const center2 = applyToPoint8(this._computePcbGlobalTransformBeforeLayout(), position2.center);
+        const center2 = applyToPoint14(this._computePcbGlobalTransformBeforeLayout(), position2.center);
         return center2;
       }
     }
@@ -174623,7 +175570,7 @@ var PrimitiveComponent2 = class extends Renderable {
       return null;
     for (const position2 of placementConfigPositions) {
       if (isMatchingSelector(component, position2.selector) || component.props.name === position2.selector) {
-        const center2 = applyToPoint8(this.computeSchematicGlobalTransform(), position2.center);
+        const center2 = applyToPoint14(this.computeSchematicGlobalTransform(), position2.center);
         return center2;
       }
     }
@@ -174636,20 +175583,20 @@ var PrimitiveComponent2 = class extends Renderable {
     for (const position2 of manualEdits.schematic_placements ?? []) {
       if (isMatchingSelector(component, position2.selector) || component.props.name === position2.selector) {
         if (position2.relative_to === "group_center") {
-          return compose3(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity(), translate3(position2.center.x, position2.center.y));
+          return compose4(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity4(), translate4(position2.center.x, position2.center.y));
         }
       }
     }
     return null;
   }
   _getGlobalPcbPositionBeforeLayout() {
-    return applyToPoint8(this._computePcbGlobalTransformBeforeLayout(), {
+    return applyToPoint14(this._computePcbGlobalTransformBeforeLayout(), {
       x: 0,
       y: 0
     });
   }
   _getGlobalSchematicPositionBeforeLayout() {
-    return applyToPoint8(this.computeSchematicGlobalTransform(), { x: 0, y: 0 });
+    return applyToPoint14(this.computeSchematicGlobalTransform(), { x: 0, y: 0 });
   }
   get root() {
     return this.parent?.root ?? null;
@@ -175080,7 +176027,7 @@ var createInstanceFromReactElement = (reactElm) => {
       this.children.push(instance);
     },
     computePcbGlobalTransform() {
-      return identity();
+      return identity4();
     }
   };
   const containerErrors = [];
@@ -175615,7 +176562,7 @@ var SilkscreenPath = class extends PrimitiveComponent2 {
       pcb_component_id,
       layer,
       route: props.route.map((p) => {
-        const transformedPosition = applyToPoint8(transform2, {
+        const transformedPosition = applyToPoint14(transform2, {
           x: p.x,
           y: p.y
         });
@@ -175698,7 +176645,7 @@ var PcbTrace = class extends PrimitiveComponent2 {
     const parentTransform = this._computePcbGlobalTransformBeforeLayout();
     const transformedRoute = props.route.map((point5) => {
       const { x, y, ...restOfPoint } = point5;
-      const transformedPoint = applyToPoint8(parentTransform, { x, y });
+      const transformedPoint = applyToPoint14(parentTransform, { x, y });
       if (point5.route_type === "wire" && point5.layer) {
         return {
           ...transformedPoint,
@@ -176145,7 +177092,7 @@ var Cutout = class extends PrimitiveComponent2 {
       inserted_pcb_cutout = db.pcb_cutout.insert(circleData);
     } else if (props.shape === "polygon") {
       const transform2 = this._computePcbGlobalTransformBeforeLayout();
-      const transformedPoints = props.points.map((p) => applyToPoint8(transform2, p));
+      const transformedPoints = props.points.map((p) => applyToPoint14(transform2, p));
       const polygonData = {
         shape: "polygon",
         points: transformedPoints,
@@ -176616,8 +177563,8 @@ var Port = class extends PrimitiveComponent2 {
           throw new Error(`Couldn't find schematicSymbolPortDef for port ${this.getString()}, searched internally connected ports and none had a schematicSymbolPortDef. Why are we trying to get the schematic position of this port?`);
         }
       }
-      const transform2 = compose3(this.parent.computeSchematicGlobalTransform(), translate3(-symbol.center.x, -symbol.center.y));
-      return applyToPoint8(transform2, schematicSymbolPortDef);
+      const transform2 = compose4(this.parent.computeSchematicGlobalTransform(), translate4(-symbol.center.x, -symbol.center.y));
+      return applyToPoint14(transform2, schematicSymbolPortDef);
     }
     const parentBoxDim = this?.parent?._getSchematicBoxDimensions();
     if (parentBoxDim && this.props.pinNumber !== undefined) {
@@ -176625,7 +177572,7 @@ var Port = class extends PrimitiveComponent2 {
       if (!localPortPosition) {
         throw new Error(`Couldn't find position for schematic_port for port ${this.getString()} inside of the schematic box`);
       }
-      return applyToPoint8(this.parent.computeSchematicGlobalTransform(), localPortPosition);
+      return applyToPoint14(this.parent.computeSchematicGlobalTransform(), localPortPosition);
     }
     throw new Error(`Couldn't find position for schematic_port for port ${this.getString()}`);
   }
@@ -178450,7 +179397,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
     for (let i = 0;i < portsWithPosition.length - 1; i++) {
       const start = portsWithPosition[i];
       const end = portsWithPosition[i + 1];
-      const path32 = calculateElbow({
+      const path33 = calculateElbow({
         x: start.position.x,
         y: start.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(start.facingDirection)
@@ -178459,8 +179406,8 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         y: end.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(end.facingDirection)
       });
-      for (let j4 = 0;j4 < path32.length - 1; j4++) {
-        elbowEdges.push({ from: path32[j4], to: path32[j4 + 1] });
+      for (let j4 = 0;j4 < path33.length - 1; j4++) {
+        elbowEdges.push({ from: path33[j4], to: path33[j4 + 1] });
       }
     }
     const doesSegmentIntersectRect = (edge, rect) => {
@@ -180192,7 +181139,7 @@ var TraceHint = class extends PrimitiveComponent2 {
       return [];
     const globalTransform = this._computePcbGlobalTransformBeforeLayout();
     return offsets.map((offset) => ({
-      ...applyToPoint8(globalTransform, offset),
+      ...applyToPoint14(globalTransform, offset),
       via: offset.via,
       to_layer: offset.to_layer,
       trace_width: offset.trace_width
@@ -180913,7 +181860,7 @@ function Group_doInitialPcbLayoutGrid(group) {
       const newCenter = { x: targetCellCenterX, y: targetCellCenterY };
       const deltaX = newCenter.x - oldCenter.x;
       const deltaY = newCenter.y - oldCenter.y;
-      const mat = translate3(deltaX, deltaY);
+      const mat = translate4(deltaX, deltaY);
       const related = db.toArray().filter((e3) => e3.pcb_component_id === child.pcb_component_id);
       const moved = transformPCBElements(related, mat);
       for (const elm of moved) {
@@ -181008,7 +181955,7 @@ var Group_doInitialPcbLayoutPack = (group) => {
     const pcbComponent = db.pcb_component.get(componentId);
     if (pcbComponent) {
       const originalCenter2 = pcbComponent.center;
-      const transformMatrix2 = compose3(group._computePcbGlobalTransformBeforeLayout(), translate3(center2.x, center2.y), rotate(ccwRotationOffset || 0), translate3(-originalCenter2.x, -originalCenter2.y));
+      const transformMatrix2 = compose4(group._computePcbGlobalTransformBeforeLayout(), translate4(center2.x, center2.y), rotate5(ccwRotationOffset || 0), translate4(-originalCenter2.x, -originalCenter2.y));
       const related = db.toArray().filter((elm) => ("pcb_component_id" in elm) && elm.pcb_component_id === componentId);
       transformPCBElements(related, transformMatrix2);
       continue;
@@ -181017,7 +181964,7 @@ var Group_doInitialPcbLayoutPack = (group) => {
     if (!pcbGroup)
       continue;
     const originalCenter = pcbGroup.center;
-    const transformMatrix = compose3(group._computePcbGlobalTransformBeforeLayout(), translate3(center2.x, center2.y), rotate(ccwRotationOffset || 0), translate3(-originalCenter.x, -originalCenter.y));
+    const transformMatrix = compose4(group._computePcbGlobalTransformBeforeLayout(), translate4(center2.x, center2.y), rotate5(ccwRotationOffset || 0), translate4(-originalCenter.x, -originalCenter.y));
     const subtree = buildSubtree(db.toArray(), { source_group_id: componentId });
     transformPCBElements(subtree, transformMatrix);
     db.pcb_group.update(pcbGroup.pcb_group_id, { center: center2 });
@@ -181918,7 +182865,7 @@ var Board = class extends Group {
     this.pcb_board_id = null;
   }
   _computePcbGlobalTransformBeforeLayout() {
-    return identity();
+    return identity4();
   }
   doInitialPcbDesignRuleChecks() {
     if (this.root?.pcbDisabled)
@@ -182599,7 +183546,7 @@ var FabricationNotePath = class extends PrimitiveComponent2 {
       layer,
       color: props.color,
       route: props.route.map((p) => {
-        const transformedPosition = applyToPoint8(transform2, {
+        const transformedPosition = applyToPoint14(transform2, {
           x: p.x,
           y: p.y
         });
@@ -182817,8 +183764,8 @@ var NetLabel = class extends PrimitiveComponent2 {
       const connectedPorts = this._getConnectedPorts();
       if (connectedPorts.length > 0) {
         const portPos = connectedPorts[0]._getGlobalSchematicPositionBeforeLayout();
-        const parentCenter = applyToPoint8(this.parent?.computeSchematicGlobalTransform?.() ?? identity(), { x: 0, y: 0 });
-        return translate3(portPos.x - parentCenter.x, portPos.y - parentCenter.y);
+        const parentCenter = applyToPoint14(this.parent?.computeSchematicGlobalTransform?.() ?? identity4(), { x: 0, y: 0 });
+        return translate4(portPos.x - parentCenter.x, portPos.y - parentCenter.y);
       }
     }
     return super.computeSchematicPropsTransform();
@@ -184348,25 +185295,25 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecente
     const elementsForBounds = circuitElements.filter((e3) => e3.type !== "pcb_component" && e3.type !== "cad_component");
     const bounds = findBoundsAndCenter(elementsForBounds);
     if (Number.isFinite(bounds.center.x) && Number.isFinite(bounds.center.y)) {
-      const matrix2 = compose3(translate3(-bounds.center.x, bounds.center.y), scale8(1, -1));
+      const matrix2 = compose4(translate4(-bounds.center.x, bounds.center.y), scale8(1, -1));
       const elementsForTransform = circuitElements.filter((e3) => !(e3.type === "pcb_smtpad" && e3.shape === "polygon") && e3.type !== "cad_component");
       transformPCBElements(elementsForTransform, matrix2);
       for (const e3 of circuitElements) {
         if (e3.type === "pcb_cutout") {
           if (e3.shape === "polygon") {
-            e3.points = e3.points.map((p) => applyToPoint8(matrix2, p));
+            e3.points = e3.points.map((p) => applyToPoint14(matrix2, p));
           } else {
-            e3.center = applyToPoint8(matrix2, e3.center);
+            e3.center = applyToPoint14(matrix2, e3.center);
           }
         } else if (e3.type === "pcb_smtpad" && e3.shape === "polygon") {
-          e3.points = e3.points.map((p) => applyToPoint8(matrix2, p));
+          e3.points = e3.points.map((p) => applyToPoint14(matrix2, p));
         }
       }
       const cad = circuitElements.find((e3) => e3.type === "cad_component");
       if (cad) {
         if (!cad.rotation)
           cad.rotation = { x: 0, y: 0, z: 0 };
-        const p = applyToPoint8(matrix2, { x: cad.position.x, y: cad.position.y });
+        const p = applyToPoint14(matrix2, { x: cad.position.x, y: cad.position.y });
         cad.position.x = p.x;
         cad.position.y = p.y;
         const side = pcb_component2.layer ?? "top";
@@ -184648,8 +185595,8 @@ react/cjs/react-jsx-runtime.development.js:
 */
 
 // lib/import/import-component-from-jlcpcb.ts
-import fs31 from "node:fs/promises";
-import path32 from "node:path";
+import fs32 from "node:fs/promises";
+import path33 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd()) => {
   const component = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const tsx = await convertRawEasyToTsx(component);
@@ -184657,10 +185604,10 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
   if (!fileName) {
     throw new Error("Could not determine file name of converted component");
   }
-  const importsDir = path32.join(projectDir, "imports");
-  await fs31.mkdir(importsDir, { recursive: true });
-  const filePath = path32.join(importsDir, `${fileName}.tsx`);
-  await fs31.writeFile(filePath, tsx);
+  const importsDir = path33.join(projectDir, "imports");
+  await fs32.mkdir(importsDir, { recursive: true });
+  const filePath = path33.join(importsDir, `${fileName}.tsx`);
+  await fs32.writeFile(filePath, tsx);
   return { filePath };
 };
 
@@ -186025,12 +186972,12 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path40 from "node:path";
-import fs39 from "node:fs";
+import path41 from "node:path";
+import fs40 from "node:fs";
 
 // cli/build/build-file.ts
-import path33 from "node:path";
-import fs32 from "node:fs";
+import path34 from "node:path";
+import fs33 from "node:fs";
 
 // lib/shared/circuit-json-diagnostics.ts
 function analyzeCircuitJson(circuitJson) {
@@ -186092,9 +187039,9 @@ var buildFile = async (input, output, projectDir, options) => {
       filePath: input,
       platformConfig: completePlatformConfig
     });
-    fs32.mkdirSync(path33.dirname(output), { recursive: true });
-    fs32.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
-    console.log(`Circuit JSON written to ${path33.relative(projectDir, output)}`);
+    fs33.mkdirSync(path34.dirname(output), { recursive: true });
+    fs33.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
+    console.log(`Circuit JSON written to ${path34.relative(projectDir, output)}`);
     const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
     if (!options?.ignoreWarnings) {
       for (const warn of warnings) {
@@ -186132,7 +187079,7 @@ var logTypeReexportHint = (error, entryFilePath) => {
   if (!match)
     return;
   const [, exportName, fromSpecifier] = match;
-  const entryFileName = path33.basename(entryFilePath);
+  const entryFileName = path34.basename(entryFilePath);
   console.error([
     "",
     `It looks like "${entryFileName}" re-exports the type-only symbol "${exportName}" from "${fromSpecifier}" without the "type" modifier.`,
@@ -186145,20 +187092,20 @@ var logTypeReexportHint = (error, entryFilePath) => {
 };
 
 // cli/build/get-build-entrypoints.ts
-import fs33 from "node:fs";
-import path34 from "node:path";
+import fs34 from "node:fs";
+import path35 from "node:path";
 var isSubPath2 = (maybeChild, maybeParent) => {
-  const relative9 = path34.relative(maybeParent, maybeChild);
-  return relative9 === "" || !relative9.startsWith("..") && !path34.isAbsolute(relative9);
+  const relative9 = path35.relative(maybeParent, maybeChild);
+  return relative9 === "" || !relative9.startsWith("..") && !path35.isAbsolute(relative9);
 };
 var findProjectRoot = (startDir) => {
   let currentDir = startDir;
-  while (currentDir !== path34.dirname(currentDir)) {
-    const packageJsonPath = path34.join(currentDir, "package.json");
-    if (fs33.existsSync(packageJsonPath)) {
+  while (currentDir !== path35.dirname(currentDir)) {
+    const packageJsonPath = path35.join(currentDir, "package.json");
+    if (fs34.existsSync(packageJsonPath)) {
       return currentDir;
     }
-    currentDir = path34.dirname(currentDir);
+    currentDir = path35.dirname(currentDir);
   }
   return startDir;
 };
@@ -186167,7 +187114,7 @@ async function getBuildEntrypoints({
   rootDir = process.cwd(),
   includeBoardFiles = true
 }) {
-  const resolvedRoot = path34.resolve(rootDir);
+  const resolvedRoot = path35.resolve(rootDir);
   const includeBoardFilePatterns = includeBoardFiles ? getBoardFilePatterns(resolvedRoot) : [];
   const buildFromProjectDir = async () => {
     if (includeBoardFiles) {
@@ -186201,8 +187148,8 @@ async function getBuildEntrypoints({
     };
   };
   if (fileOrDir) {
-    const resolved = path34.resolve(resolvedRoot, fileOrDir);
-    if (fs33.existsSync(resolved) && fs33.statSync(resolved).isDirectory()) {
+    const resolved = path35.resolve(resolvedRoot, fileOrDir);
+    if (fs34.existsSync(resolved) && fs34.statSync(resolved).isDirectory()) {
       if (includeBoardFiles) {
         const circuitFiles = findBoardFiles({
           projectDir: resolvedRoot,
@@ -186232,7 +187179,7 @@ async function getBuildEntrypoints({
         circuitFiles: mainEntrypoint ? [mainEntrypoint] : []
       };
     }
-    const fileDir = path34.dirname(resolved);
+    const fileDir = path35.dirname(resolved);
     const projectDir = findProjectRoot(fileDir);
     return { projectDir, circuitFiles: [resolved] };
   }
@@ -186269,8 +187216,8 @@ ${scriptBlock}      <script src="https://cdn.tailwindcss.com"></script>
 };
 
 // cli/build/build-preview-images.ts
-import fs34 from "node:fs";
-import path35 from "node:path";
+import fs35 from "node:fs";
+import path36 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg2,
@@ -186343,21 +187290,21 @@ var generatePreviewAssets = async ({
   outputDir,
   distDir
 }) => {
-  const prefixRelative = path35.relative(distDir, outputDir) || ".";
+  const prefixRelative = path36.relative(distDir, outputDir) || ".";
   const prefix = prefixRelative === "." ? "" : `[${prefixRelative}] `;
   let circuitJson;
   try {
-    const circuitJsonRaw = fs34.readFileSync(build.outputPath, "utf-8");
+    const circuitJsonRaw = fs35.readFileSync(build.outputPath, "utf-8");
     circuitJson = JSON.parse(circuitJsonRaw);
   } catch (error) {
     console.error(`${prefix}Failed to read circuit JSON:`, error);
     return;
   }
-  fs34.mkdirSync(outputDir, { recursive: true });
+  fs35.mkdirSync(outputDir, { recursive: true });
   try {
     console.log(`${prefix}Generating PCB SVG...`);
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson);
-    fs34.writeFileSync(path35.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs35.writeFileSync(path36.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
     console.log(`${prefix}Written pcb.svg`);
   } catch (error) {
     console.error(`${prefix}Failed to generate PCB SVG:`, error);
@@ -186365,7 +187312,7 @@ var generatePreviewAssets = async ({
   try {
     console.log(`${prefix}Generating schematic SVG...`);
     const schematicSvg = convertCircuitJsonToSchematicSvg2(circuitJson);
-    fs34.writeFileSync(path35.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs35.writeFileSync(path36.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
     console.log(`${prefix}Written schematic.svg`);
   } catch (error) {
     console.error(`${prefix}Failed to generate schematic SVG:`, error);
@@ -186382,7 +187329,7 @@ var generatePreviewAssets = async ({
       camPos: [10, 10, 10],
       lookAt: [0, 0, 0]
     });
-    fs34.writeFileSync(path35.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
+    fs35.writeFileSync(path36.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
     console.log(`${prefix}Written 3d.png`);
   } catch (error) {
     console.error(`${prefix}Failed to generate 3D PNG:`, error);
@@ -186395,14 +187342,14 @@ var buildPreviewImages = async ({
   allImages
 }) => {
   const successfulBuilds = builtFiles.filter((file) => file.ok);
-  const normalizedMainEntrypoint = mainEntrypoint ? path35.resolve(mainEntrypoint) : undefined;
+  const normalizedMainEntrypoint = mainEntrypoint ? path36.resolve(mainEntrypoint) : undefined;
   if (allImages) {
     if (successfulBuilds.length === 0) {
       console.warn("No successful build output available for preview image generation.");
       return;
     }
     for (const build of successfulBuilds) {
-      const outputDir = path35.dirname(build.outputPath);
+      const outputDir = path36.dirname(build.outputPath);
       await generatePreviewAssets({
         build,
         outputDir,
@@ -186413,7 +187360,7 @@ var buildPreviewImages = async ({
   }
   const previewBuild = (() => {
     if (normalizedMainEntrypoint) {
-      const match = successfulBuilds.find((built) => path35.resolve(built.sourcePath) === normalizedMainEntrypoint);
+      const match = successfulBuilds.find((built) => path36.resolve(built.sourcePath) === normalizedMainEntrypoint);
       if (match)
         return match;
     }
@@ -186431,8 +187378,8 @@ var buildPreviewImages = async ({
 };
 
 // cli/build/generate-kicad-project.ts
-import fs35 from "node:fs";
-import path36 from "node:path";
+import fs36 from "node:fs";
+import path37 from "node:path";
 var createKicadProContent = ({
   projectName,
   schematicFileName,
@@ -186472,10 +187419,10 @@ var generateKicadProject = async ({
     boardFileName
   });
   if (writeFiles) {
-    fs35.mkdirSync(outputDir, { recursive: true });
-    fs35.writeFileSync(path36.join(outputDir, schematicFileName), schContent);
-    fs35.writeFileSync(path36.join(outputDir, boardFileName), pcbContent);
-    fs35.writeFileSync(path36.join(outputDir, projectFileName), proContent);
+    fs36.mkdirSync(outputDir, { recursive: true });
+    fs36.writeFileSync(path37.join(outputDir, schematicFileName), schContent);
+    fs36.writeFileSync(path37.join(outputDir, boardFileName), pcbContent);
+    fs36.writeFileSync(path37.join(outputDir, projectFileName), proContent);
   }
   return {
     pcbContent,
@@ -186487,8 +187434,8 @@ var generateKicadProject = async ({
 };
 
 // cli/build/transpile/index.ts
-import path38 from "node:path";
-import fs37 from "node:fs";
+import path39 from "node:path";
+import fs38 from "node:fs";
 import { rollup } from "rollup";
 import typescript from "@rollup/plugin-typescript";
 import resolve11 from "@rollup/plugin-node-resolve";
@@ -186497,11 +187444,11 @@ import json from "@rollup/plugin-json";
 import dts from "rollup-plugin-dts";
 
 // cli/build/transpile/static-asset-plugin.ts
-import fs36 from "node:fs";
-import path37 from "node:path";
+import fs37 from "node:fs";
+import path38 from "node:path";
 import { createHash } from "node:crypto";
 function normalizePathSeparators(filePath) {
-  return filePath.split(path37.sep).join("/");
+  return filePath.split(path38.sep).join("/");
 }
 var STATIC_ASSET_EXTENSIONS = new Set([
   ".glb",
@@ -186532,24 +187479,24 @@ var createStaticAssetPlugin = ({
   return {
     name: "tsci-static-assets",
     resolveId(source, importer) {
-      const ext = path37.extname(source).toLowerCase();
+      const ext = path38.extname(source).toLowerCase();
       if (!STATIC_ASSET_EXTENSIONS.has(ext))
         return null;
-      if (path37.isAbsolute(source)) {
-        return fs36.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
+      if (path38.isAbsolute(source)) {
+        return fs37.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
       }
       if (importer) {
-        const importerNative = importer.split("/").join(path37.sep);
-        const resolvedFromImporter = path37.resolve(path37.dirname(importerNative), source);
-        if (fs36.existsSync(resolvedFromImporter)) {
+        const importerNative = importer.split("/").join(path38.sep);
+        const resolvedFromImporter = path38.resolve(path38.dirname(importerNative), source);
+        if (fs37.existsSync(resolvedFromImporter)) {
           return {
             id: normalizePathSeparators(resolvedFromImporter),
             external: true
           };
         }
       }
-      const resolvedFromProject = path37.resolve(resolvedBaseUrl, source);
-      if (fs36.existsSync(resolvedFromProject)) {
+      const resolvedFromProject = path38.resolve(resolvedBaseUrl, source);
+      if (fs37.existsSync(resolvedFromProject)) {
         return {
           id: normalizePathSeparators(resolvedFromProject),
           external: true
@@ -186562,8 +187509,8 @@ var createStaticAssetPlugin = ({
           const wildcard = isWildcard ? source.slice(patternPrefix.length) : "";
           for (const target of targets) {
             const targetPath = isWildcard ? target.replace("*", wildcard) : target;
-            const resolvedTarget = path37.resolve(resolvedBaseUrl, targetPath);
-            if (fs36.existsSync(resolvedTarget)) {
+            const resolvedTarget = path38.resolve(resolvedBaseUrl, targetPath);
+            if (fs37.existsSync(resolvedTarget)) {
               return {
                 id: normalizePathSeparators(resolvedTarget),
                 external: true
@@ -186589,18 +187536,18 @@ var createStaticAssetPlugin = ({
         if (chunk.type !== "chunk")
           continue;
         for (const importedId of chunk.imports) {
-          const ext = path37.extname(importedId).toLowerCase();
+          const ext = path38.extname(importedId).toLowerCase();
           if (!STATIC_ASSET_EXTENSIONS.has(ext))
             continue;
           if (!copiedAssets.has(importedId)) {
-            const assetDir = path37.join(outputDir, "assets");
-            fs36.mkdirSync(assetDir, { recursive: true });
-            const nativePath = importedId.split("/").join(path37.sep);
-            const fileBuffer = fs36.readFileSync(nativePath);
+            const assetDir = path38.join(outputDir, "assets");
+            fs37.mkdirSync(assetDir, { recursive: true });
+            const nativePath = importedId.split("/").join(path38.sep);
+            const fileBuffer = fs37.readFileSync(nativePath);
             const hash = createHash("sha1").update(fileBuffer).digest("hex").slice(0, 8);
-            const fileName = `${path37.basename(importedId, ext)}-${hash}${ext}`;
-            const outputFilePath = path37.join(assetDir, fileName);
-            fs36.writeFileSync(outputFilePath, fileBuffer);
+            const fileName = `${path38.basename(importedId, ext)}-${hash}${ext}`;
+            const outputFilePath = path38.join(assetDir, fileName);
+            fs37.writeFileSync(outputFilePath, fileBuffer);
             copiedAssets.set(importedId, `./assets/${fileName}`);
             assetIdToOutputPath.set(importedId, `./assets/${fileName}`);
           }
@@ -186622,17 +187569,17 @@ function escapeRegExp(string) {
 
 // cli/build/transpile/index.ts
 var createExternalFunction = (projectDir, tsconfigPath) => (id2) => {
-  if (id2.startsWith(".") || id2.startsWith("/") || path38.isAbsolute(id2)) {
+  if (id2.startsWith(".") || id2.startsWith("/") || path39.isAbsolute(id2)) {
     return false;
   }
   let baseUrl = projectDir;
   let pathMappings = {};
-  if (tsconfigPath && fs37.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs38.existsSync(tsconfigPath)) {
     try {
-      const tsconfigContent = fs37.readFileSync(tsconfigPath, "utf-8");
+      const tsconfigContent = fs38.readFileSync(tsconfigPath, "utf-8");
       const tsconfig = JSON.parse(tsconfigContent);
       if (tsconfig.compilerOptions?.baseUrl) {
-        baseUrl = path38.resolve(path38.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+        baseUrl = path39.resolve(path39.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
       }
       if (tsconfig.compilerOptions?.paths) {
         pathMappings = tsconfig.compilerOptions.paths;
@@ -186646,17 +187593,17 @@ var createExternalFunction = (projectDir, tsconfigPath) => (id2) => {
     }
   }
   const potentialPaths = [
-    path38.join(baseUrl, id2),
-    path38.join(baseUrl, `${id2}.ts`),
-    path38.join(baseUrl, `${id2}.tsx`),
-    path38.join(baseUrl, `${id2}.js`),
-    path38.join(baseUrl, `${id2}.jsx`),
-    path38.join(baseUrl, id2, "index.ts"),
-    path38.join(baseUrl, id2, "index.tsx"),
-    path38.join(baseUrl, id2, "index.js"),
-    path38.join(baseUrl, id2, "index.jsx")
+    path39.join(baseUrl, id2),
+    path39.join(baseUrl, `${id2}.ts`),
+    path39.join(baseUrl, `${id2}.tsx`),
+    path39.join(baseUrl, `${id2}.js`),
+    path39.join(baseUrl, `${id2}.jsx`),
+    path39.join(baseUrl, id2, "index.ts"),
+    path39.join(baseUrl, id2, "index.tsx"),
+    path39.join(baseUrl, id2, "index.js"),
+    path39.join(baseUrl, id2, "index.jsx")
   ];
-  if (potentialPaths.some((p) => fs37.existsSync(p))) {
+  if (potentialPaths.some((p) => fs38.existsSync(p))) {
     return false;
   }
   return true;
@@ -186667,17 +187614,17 @@ var transpileFile = async ({
   projectDir
 }) => {
   try {
-    fs37.mkdirSync(outputDir, { recursive: true });
-    const tsconfigPath = path38.join(projectDir, "tsconfig.json");
-    const hasTsConfig = fs37.existsSync(tsconfigPath);
+    fs38.mkdirSync(outputDir, { recursive: true });
+    const tsconfigPath = path39.join(projectDir, "tsconfig.json");
+    const hasTsConfig = fs38.existsSync(tsconfigPath);
     let tsconfigBaseUrl = projectDir;
     let tsconfigPathMappings;
     if (hasTsConfig) {
       try {
-        const tsconfigContent = fs37.readFileSync(tsconfigPath, "utf-8");
+        const tsconfigContent = fs38.readFileSync(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(tsconfigContent);
         if (tsconfig.compilerOptions?.baseUrl) {
-          tsconfigBaseUrl = path38.resolve(path38.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+          tsconfigBaseUrl = path39.resolve(path39.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
         }
         if (tsconfig.compilerOptions?.paths) {
           tsconfigPathMappings = tsconfig.compilerOptions.paths;
@@ -186732,27 +187679,27 @@ var transpileFile = async ({
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const esmOutputPath = path38.join(outputDir, "index.js");
+    const esmOutputPath = path39.join(outputDir, "index.js");
     await esmBundle.write({
       file: esmOutputPath,
       format: "es",
       sourcemap: false
     });
-    console.log(`ESM bundle written to ${path38.relative(projectDir, esmOutputPath)}`);
+    console.log(`ESM bundle written to ${path39.relative(projectDir, esmOutputPath)}`);
     console.log("Building CommonJS bundle...");
     const cjsBundle = await rollup({
       input,
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const cjsOutputPath = path38.join(outputDir, "index.cjs");
+    const cjsOutputPath = path39.join(outputDir, "index.cjs");
     console.log("Writing CJS bundle to:", cjsOutputPath);
     await cjsBundle.write({
       file: cjsOutputPath,
       format: "cjs",
       sourcemap: false
     });
-    console.log(`CommonJS bundle written to ${path38.relative(projectDir, cjsOutputPath)}`);
+    console.log(`CommonJS bundle written to ${path39.relative(projectDir, cjsOutputPath)}`);
     console.log("Generating type declarations...");
     const dtsBundle = await rollup({
       input,
@@ -186777,9 +187724,9 @@ var transpileFile = async ({
     dtsContent = dtsContent.replace(/import \* as [\w_]+ from ['"]react\/jsx-runtime['"];?\s*\n?/g, "");
     dtsContent = dtsContent.replace(/[\w_]+\.JSX\.Element/g, "any");
     dtsContent = dtsContent.replace(/export\s*{\s*};\s*$/gm, "").trim();
-    const dtsOutputPath = path38.join(outputDir, "index.d.ts");
-    fs37.writeFileSync(dtsOutputPath, dtsContent);
-    console.log(`Type declarations written to ${path38.relative(projectDir, dtsOutputPath)}`);
+    const dtsOutputPath = path39.join(outputDir, "index.d.ts");
+    fs38.writeFileSync(dtsOutputPath, dtsContent);
+    console.log(`Type declarations written to ${path39.relative(projectDir, dtsOutputPath)}`);
     console.log(kleur_default.green("Transpilation complete!"));
     return true;
   } catch (err) {
@@ -186792,17 +187739,17 @@ var transpileFile = async ({
 };
 
 // cli/utils/validate-main-in-dist.ts
-import fs38 from "node:fs";
-import path39 from "node:path";
+import fs39 from "node:fs";
+import path40 from "node:path";
 var validateMainInDist = (projectDir, distDir) => {
-  const packageJsonPath = path39.join(projectDir, "package.json");
-  if (!fs38.existsSync(packageJsonPath))
+  const packageJsonPath = path40.join(projectDir, "package.json");
+  if (!fs39.existsSync(packageJsonPath))
     return;
-  const packageJson = JSON.parse(fs38.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs39.readFileSync(packageJsonPath, "utf-8"));
   if (typeof packageJson.main !== "string")
     return;
-  const resolvedMainPath = path39.resolve(projectDir, packageJson.main);
-  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path39.sep}`);
+  const resolvedMainPath = path40.resolve(projectDir, packageJson.main);
+  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path40.sep}`);
   if (!isMainInDist) {
     console.warn('When using transpilation, your package\'s "main" field should point inside the `dist/*` directory, usually to "dist/index.js"');
   }
@@ -186827,8 +187774,8 @@ var registerBuild = (program3) => {
         }
         return config;
       })();
-      const distDir = path40.join(projectDir, "dist");
-      fs39.mkdirSync(distDir, { recursive: true });
+      const distDir = path41.join(projectDir, "dist");
+      fs40.mkdirSync(distDir, { recursive: true });
       console.log(`Building ${circuitFiles.length} file(s)...`);
       let hasErrors = false;
       const staticFileReferences = [];
@@ -186836,10 +187783,10 @@ var registerBuild = (program3) => {
       const kicadProjects = [];
       const shouldGenerateKicad = options?.kicad || options?.kicadFootprintLibrary;
       for (const filePath of circuitFiles) {
-        const relative9 = path40.relative(projectDir, filePath);
+        const relative9 = path41.relative(projectDir, filePath);
         console.log(`Building ${relative9}...`);
         const outputDirName = relative9.replace(/(\.board|\.circuit)?\.tsx$/, "");
-        const outputPath = path40.join(distDir, outputDirName, "circuit.json");
+        const outputPath = path41.join(distDir, outputDirName, "circuit.json");
         const buildOutcome = await buildFile(filePath, outputPath, projectDir, {
           ignoreErrors: options?.ignoreErrors,
           ignoreWarnings: options?.ignoreWarnings,
@@ -186853,17 +187800,17 @@ var registerBuild = (program3) => {
         if (!buildOutcome.ok) {
           hasErrors = true;
         } else if (options?.site) {
-          const normalizedSourcePath = relative9.split(path40.sep).join("/");
-          const relativeOutputPath = path40.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path40.sep).join("/");
+          const normalizedSourcePath = relative9.split(path41.sep).join("/");
+          const relativeOutputPath = path41.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path41.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
           });
         }
         if (buildOutcome.ok && shouldGenerateKicad && buildOutcome.circuitJson) {
-          const projectOutputDir = path40.join(distDir, outputDirName, "kicad");
-          const projectName = path40.basename(outputDirName);
+          const projectOutputDir = path41.join(distDir, outputDirName, "kicad");
+          const projectName = path41.basename(outputDirName);
           const project = await generateKicadProject({
             circuitJson: buildOutcome.circuitJson,
             outputDir: projectOutputDir,
@@ -186916,8 +187863,8 @@ var registerBuild = (program3) => {
           files: staticFileReferences,
           standaloneScriptSrc: "./standalone.min.js"
         });
-        fs39.writeFileSync(path40.join(distDir, "index.html"), indexHtml);
-        fs39.writeFileSync(path40.join(distDir, "standalone.min.js"), standalone_min_default);
+        fs40.writeFileSync(path41.join(distDir, "index.html"), indexHtml);
+        fs40.writeFileSync(path41.join(distDir, "standalone.min.js"), standalone_min_default);
       }
       if (options?.kicadFootprintLibrary) {
         if (kicadProjects.length === 0) {
@@ -186940,8 +187887,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs41 from "node:fs";
-import path41 from "node:path";
+import fs42 from "node:fs";
+import path42 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -186952,7 +187899,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs40 from "node:fs/promises";
+import fs41 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -186968,7 +187915,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs40.writeFile(diffPath, buffer2);
+      await fs41.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -186993,7 +187940,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f) => path41.resolve(projectDir, f));
+  const resolvedPaths = filePaths.map((f) => path42.resolve(projectDir, f));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -187007,7 +187954,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path41.relative(projectDir, file);
+    const relativeFilePath = path42.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -187062,17 +188009,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 = path41.dirname(file);
-          const relativeDir = path41.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path41.join(projectDir, snapshotsDirName, relativeDir) : path41.join(fileDir, "__snapshots__");
-          const base2 = path41.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path41.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs41.existsSync(snap3dPath);
+          const fileDir = path42.dirname(file);
+          const relativeDir = path42.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path42.join(projectDir, snapshotsDirName, relativeDir) : path42.join(fileDir, "__snapshots__");
+          const base2 = path42.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path42.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs42.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: ${path41.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path42.relative(projectDir, snap3dPath)}
 `));
             return onExit2(1);
           } else {
@@ -187088,9 +188035,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path41.join(projectDir, snapshotsDirName, path41.relative(projectDir, path41.dirname(file))) : path41.join(path41.dirname(file), "__snapshots__");
-    fs41.mkdirSync(snapDir, { recursive: true });
-    const base = path41.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path42.join(projectDir, snapshotsDirName, path42.relative(projectDir, path42.dirname(file))) : path42.join(path42.dirname(file), "__snapshots__");
+    fs42.mkdirSync(snapDir, { recursive: true });
+    const base = path42.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -187108,31 +188055,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path41.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs41.existsSync(snapPath);
+      const snapPath = path42.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs42.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs41.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path41.relative(projectDir, snapPath)));
+        fs42.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path42.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs41.readFileSync(snapPath);
+      const oldContentBuffer = fs42.readFileSync(snapPath);
       const diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
       const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath);
       if (update) {
         if (!forceUpdate && equal2) {
-          console.log("✅", kleur_default.gray(path41.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path42.relative(projectDir, snapPath)));
         } else {
-          fs41.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path41.relative(projectDir, snapPath)));
+          fs42.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path42.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path41.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path42.relative(projectDir, snapPath)));
       }
     }
   }
@@ -187171,22 +188118,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs42 from "node:fs";
-import path42 from "node:path";
+import fs43 from "node:fs";
+import path43 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path42.resolve(startDir);
-    while (dir !== path42.parse(dir).root) {
-      if (fs42.existsSync(path42.join(dir, ".git"))) {
+    let dir = path43.resolve(startDir);
+    while (dir !== path43.parse(dir).root) {
+      if (fs43.existsSync(path43.join(dir, ".git"))) {
         return dir;
       }
-      dir = path42.dirname(dir);
+      dir = path43.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path42.join(gitRoot, ".github", "workflows");
-  fs42.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path43.join(gitRoot, ".github", "workflows");
+  fs43.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -187225,8 +188172,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path42.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path42.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path43.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path43.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -187264,8 +188211,8 @@ function registerAuthSetupNpmrc(program3) {
 }
 
 // cli/convert/register.ts
-import fs43 from "node:fs/promises";
-import path43 from "node:path";
+import fs44 from "node:fs/promises";
+import path44 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -187385,15 +188332,15 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program3) => {
   program3.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 = path43.resolve(file);
-      const modContent = await fs43.readFile(inputPath, "utf-8");
+      const inputPath = path44.resolve(file);
+      const modContent = await fs44.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path43.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path44.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path43.resolve(options.output) : path43.join(path43.dirname(inputPath), `${componentName}.tsx`);
-      await fs43.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path44.resolve(options.output) : path44.join(path44.dirname(inputPath), `${componentName}.tsx`);
+      await fs44.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);
@@ -187489,12 +188436,12 @@ var registerSimulate = (program3) => {
 };
 
 // lib/shared/install-project-dependencies.ts
-import fs45 from "node:fs";
-import path45 from "node:path";
+import fs46 from "node:fs";
+import path46 from "node:path";
 
 // lib/shared/collect-tsci-dependencies.ts
-import fs44 from "node:fs";
-import path44 from "node:path";
+import fs45 from "node:fs";
+import path45 from "node:path";
 var DEFAULT_PATTERNS = ["**/*.{ts,tsx,js,jsx}"];
 var DEFAULT_IGNORES = [
   "**/node_modules/**",
@@ -187509,7 +188456,7 @@ function collectTsciDependencies({
   patterns = DEFAULT_PATTERNS,
   ignore = DEFAULT_IGNORES
 } = {}) {
-  const searchRoot = path44.resolve(cwd);
+  const searchRoot = path45.resolve(cwd);
   const files = globbySync(patterns, {
     cwd: searchRoot,
     absolute: true,
@@ -187519,7 +188466,7 @@ function collectTsciDependencies({
   const dependencies2 = new Set;
   for (const filePath of files) {
     try {
-      const fileContents = fs44.readFileSync(filePath, "utf-8");
+      const fileContents = fs45.readFileSync(filePath, "utf-8");
       let match;
       while (true) {
         match = IMPORT_PATTERN.exec(fileContents);
@@ -187536,26 +188483,26 @@ function collectTsciDependencies({
 async function installProjectDependencies({
   cwd = process.cwd()
 } = {}) {
-  const projectRoot = path45.resolve(cwd);
-  const packageJsonPath = path45.join(projectRoot, "package.json");
-  const npmrcPath = path45.join(projectRoot, ".npmrc");
+  const projectRoot = path46.resolve(cwd);
+  const packageJsonPath = path46.join(projectRoot, "package.json");
+  const npmrcPath = path46.join(projectRoot, ".npmrc");
   const packageManager = getPackageManager();
-  if (!fs45.existsSync(projectRoot)) {
+  if (!fs46.existsSync(projectRoot)) {
     throw new Error(`Directory not found: ${projectRoot}`);
   }
   let packageJsonCreated = false;
-  if (!fs45.existsSync(packageJsonPath)) {
+  if (!fs46.existsSync(packageJsonPath)) {
     console.log("No package.json found. Generating a new one.");
     generatePackageJson(projectRoot);
     packageJsonCreated = true;
   } else {
     console.log("Found existing package.json.");
   }
-  if (!fs45.existsSync(npmrcPath)) {
+  if (!fs46.existsSync(npmrcPath)) {
     console.log("Creating .npmrc with tscircuit registry configuration.");
-    fs45.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
+    fs46.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
   }
-  const packageJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
   if (packageJsonCreated) {
     const tsciDependencies = collectTsciDependencies({ cwd: projectRoot });
     if (tsciDependencies.length > 0) {
@@ -187570,7 +188517,7 @@ async function installProjectDependencies({
       console.log("No @tsci dependencies detected in circuit files.");
     }
   }
-  fs45.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  fs46.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `);
   console.log(`Installing dependencies using ${kleur_default.bold(packageManager.name)}...`);
   try {
@@ -187605,7 +188552,7 @@ var registerInstall = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path46 from "node:path";
+import path47 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 {
@@ -187613,7 +188560,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path46.join(projectDir, "dist");
+      const distDir = path47.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];