circuit-json-to-kicad 0.0.1 → 0.0.3

package/dist/index.js

@@ -0,0 +1,1341 @@
+// lib/types.ts
+var ConverterStage = class {
+  MAX_ITERATIONS = 1e3;
+  iteration = 0;
+  finished = false;
+  input;
+  ctx;
+  constructor(input, ctx) {
+    this.input = input;
+    this.ctx = ctx;
+  }
+  step() {
+    this.iteration++;
+    if (this.iteration > this.MAX_ITERATIONS) {
+      throw new Error("Max iterations reached");
+    }
+    this._step();
+  }
+  _step() {
+    throw new Error("Not implemented");
+  }
+  runUntilFinished() {
+    while (!this.finished) {
+      this.step();
+    }
+  }
+  getOutput() {
+    throw new Error("Not implemented");
+  }
+};
+
+// lib/schematic/CircuitJsonToKicadSchConverter.ts
+import { KicadSch } from "kicadts";
+import { cju } from "@tscircuit/circuit-json-util";
+import { compose, translate, scale } from "transformation-matrix";
+
+// lib/schematic/stages/InitializeSchematicStage.ts
+import { Paper, Uuid } from "kicadts";
+var InitializeSchematicStage = class extends ConverterStage {
+  _step() {
+    const { kicadSch } = this.ctx;
+    if (!kicadSch) {
+      throw new Error("KicadSch instance not initialized in context");
+    }
+    kicadSch.version = 20250114;
+    const paper = new Paper();
+    paper.size = "A4";
+    kicadSch.paper = paper;
+    kicadSch.uuid = new Uuid(crypto.randomUUID());
+    this.finished = true;
+  }
+  getOutput() {
+    return this.ctx.kicadSch;
+  }
+};
+
+// lib/schematic/stages/AddLibrarySymbolsStage.ts
+import {
+  EmbeddedFonts,
+  LibSymbols,
+  Pts,
+  SchematicSymbol,
+  Stroke,
+  SymbolPin,
+  SymbolPinName,
+  SymbolPinNames,
+  SymbolPinNumber,
+  SymbolPinNumbers,
+  SymbolPolyline,
+  SymbolPolylineFill,
+  SymbolProperty,
+  TextEffects,
+  TextEffectsFont,
+  Xy
+} from "kicadts";
+import { symbols } from "schematic-symbols";
+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;
+        }
+        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) {
+      kicadSch.libSymbols = libSymbols;
+    }
+    this.finished = true;
+  }
+  /**
+   * Create generic chip symbol data for chips without a symbol_name
+   */
+  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;
+    const height = schematicComp.size?.height || 1;
+    const boxPath = {
+      type: "path",
+      points: [
+        { x: -width / 2, y: -height / 2 },
+        { x: width / 2, y: -height / 2 },
+        { x: width / 2, y: height / 2 },
+        { x: -width / 2, y: height / 2 },
+        { x: -width / 2, y: -height / 2 }
+      ]
+    };
+    const ports = schematicPorts.map((port) => {
+      const portX = port.center.x - schematicComp.center.x;
+      const portY = port.center.y - schematicComp.center.y;
+      return {
+        x: portX,
+        y: portY,
+        labels: [port.display_pin_label || `${port.pin_number || 1}`],
+        pinNumber: port.pin_number || 1
+      };
+    });
+    return {
+      center: { x: 0, y: 0 },
+      primitives: [boxPath],
+      ports,
+      size: { width, height }
+    };
+  }
+  /**
+   * Convert schematic-symbols data to KiCad library symbol
+   */
+  createLibrarySymbolFromSchematicSymbol(symbolName, symbolData, sourceComp) {
+    const libId = this.getLibraryId(symbolName, sourceComp);
+    const symbol = new SchematicSymbol({
+      libraryId: libId,
+      excludeFromSim: false,
+      inBom: true,
+      onBoard: true
+    });
+    const pinNumbers = new SymbolPinNumbers();
+    pinNumbers.hide = sourceComp?.ftype !== "simple_chip";
+    symbol._sxPinNumbers = pinNumbers;
+    const pinNames = new SymbolPinNames();
+    pinNames.offset = sourceComp?.ftype === "simple_chip" ? 1.27 : 0;
+    symbol._sxPinNames = pinNames;
+    this.addSymbolProperties(symbol, libId, sourceComp);
+    const isChip = sourceComp?.ftype === "simple_chip";
+    const drawingSymbol = this.createDrawingSubsymbol(libId, symbolData, isChip);
+    symbol.subSymbols.push(drawingSymbol);
+    const pinSymbol = this.createPinSubsymbol(libId, symbolData, isChip);
+    symbol.subSymbols.push(pinSymbol);
+    symbol._sxEmbeddedFonts = new EmbeddedFonts(false);
+    return symbol;
+  }
+  /**
+   * Get KiCad library ID for a 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}`;
+  }
+  /**
+   * Add properties to the library symbol
+   */
+  addSymbolProperties(symbol, libId, sourceComp) {
+    const refPrefix = libId.split(":")[1]?.[0] || "U";
+    const properties = [
+      {
+        key: "Reference",
+        value: refPrefix,
+        id: 0,
+        at: [2.032, 0, 90],
+        hide: false
+      },
+      { key: "Value", value: refPrefix, id: 1, at: [0, 0, 90], hide: false },
+      {
+        key: "Footprint",
+        value: "",
+        id: 2,
+        at: [-1.778, 0, 90],
+        hide: true
+      },
+      {
+        key: "Datasheet",
+        value: "~",
+        id: 3,
+        at: [0, 0, 0],
+        hide: true
+      },
+      {
+        key: "Description",
+        value: this.getDescription(sourceComp),
+        id: 4,
+        at: [0, 0, 0],
+        hide: true
+      },
+      {
+        key: "ki_keywords",
+        value: this.getKeywords(sourceComp),
+        id: 5,
+        at: [0, 0, 0],
+        hide: true
+      },
+      {
+        key: "ki_fp_filters",
+        value: this.getFpFilters(sourceComp),
+        id: 6,
+        at: [0, 0, 0],
+        hide: true
+      }
+    ];
+    for (const prop of properties) {
+      symbol.properties.push(
+        new SymbolProperty({
+          key: prop.key,
+          value: prop.value,
+          id: prop.id,
+          at: prop.at,
+          effects: this.createTextEffects(1.27, prop.hide)
+        })
+      );
+    }
+  }
+  getDescription(sourceComp) {
+    if (sourceComp?.ftype === "simple_resistor") return "Resistor";
+    if (sourceComp?.ftype === "simple_capacitor") return "Capacitor";
+    if (sourceComp?.ftype === "simple_chip") return "Integrated Circuit";
+    return "Component";
+  }
+  getKeywords(sourceComp) {
+    if (sourceComp?.ftype === "simple_resistor") return "R res resistor";
+    if (sourceComp?.ftype === "simple_capacitor") return "C cap capacitor";
+    if (sourceComp?.ftype === "simple_chip") return "U IC chip";
+    return "";
+  }
+  getFpFilters(sourceComp) {
+    if (sourceComp?.ftype === "simple_resistor") return "R_*";
+    if (sourceComp?.ftype === "simple_capacitor") return "C_*";
+    if (sourceComp?.ftype === "simple_chip") return "*";
+    return "*";
+  }
+  /**
+   * Create the drawing subsymbol (primitives, no pins)
+   * Converts schematic-symbols primitives to KiCad drawing elements
+   */
+  createDrawingSubsymbol(libId, symbolData, isChip = false) {
+    const drawingSymbol = new SchematicSymbol({
+      libraryId: `${libId.split(":")[1]}_0_1`
+    });
+    const symbolScale = this.ctx.c2kMatSch?.a || 15;
+    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
+        );
+        drawingSymbol.polylines.push(polyline);
+      }
+    }
+    return drawingSymbol;
+  }
+  /**
+   * Create a KiCad polyline from points
+   */
+  createPolylineFromPoints(points, scale3, fillType = "none") {
+    const polyline = new SymbolPolyline();
+    const xyPoints = points.map((p) => new Xy(p.x * scale3, p.y * scale3));
+    const pts = new Pts(xyPoints);
+    polyline.points = pts;
+    const stroke = new Stroke();
+    stroke.width = 0.254;
+    stroke.type = "default";
+    polyline.stroke = stroke;
+    const fill = new SymbolPolylineFill();
+    fill.type = fillType;
+    polyline.fill = fill;
+    return polyline;
+  }
+  /**
+   * Create the pin subsymbol
+   */
+  createPinSubsymbol(libId, symbolData, isChip = false) {
+    const pinSymbol = new SchematicSymbol({
+      libraryId: `${libId.split(":")[1]}_1_1`
+    });
+    for (let i = 0; i < (symbolData.ports?.length || 0); i++) {
+      const port = symbolData.ports[i];
+      const pin = new SymbolPin();
+      pin.pinElectricalType = "passive";
+      pin.pinGraphicStyle = "line";
+      const { x, y, angle } = this.calculatePinPosition(
+        port,
+        symbolData.center,
+        symbolData.size,
+        isChip
+      );
+      pin.at = [x, y, angle];
+      pin.length = isChip ? 2.54 : 1.27;
+      const nameFont = new TextEffectsFont();
+      nameFont.size = { height: 1.27, width: 1.27 };
+      const nameEffects = new TextEffects({ font: nameFont });
+      const pinName = port.labels?.[0] || "~";
+      pin._sxName = new SymbolPinName({ value: pinName, effects: nameEffects });
+      const numFont = new TextEffectsFont();
+      numFont.size = { height: 1.27, width: 1.27 };
+      const numEffects = new TextEffects({ font: numFont });
+      const pinNum = port.pinNumber?.toString() || `${i + 1}`;
+      pin._sxNumber = new SymbolPinNumber({
+        value: pinNum,
+        effects: numEffects
+      });
+      pinSymbol.pins.push(pin);
+    }
+    return pinSymbol;
+  }
+  /**
+   * Calculate KiCad pin position and rotation from schematic-symbols port
+   * Scale pins to match the c2kMatSch transformation scale
+   */
+  calculatePinPosition(port, center, size, isChip) {
+    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;
+    if (isChip && size) {
+      const halfWidth = size.width / 2 * symbolScale;
+      const halfHeight = size.height / 2 * symbolScale;
+      if (Math.abs(dx) > Math.abs(dy)) {
+        x = dx > 0 ? halfWidth : -halfWidth;
+        y = dy * symbolScale;
+      } else {
+        x = dx * symbolScale;
+        y = dy > 0 ? halfHeight : -halfHeight;
+      }
+    }
+    let angle = 0;
+    if (Math.abs(dx) > Math.abs(dy)) {
+      if (dx > 0) {
+        if (isChip) {
+          angle = 180;
+          x = x + chipPinLength;
+        } else {
+          angle = 0;
+        }
+      } else {
+        if (isChip) {
+          angle = 0;
+          x = x - chipPinLength;
+        } else {
+          angle = 180;
+        }
+      }
+    } else {
+      if (dy > 0) {
+        if (isChip) {
+          angle = 270;
+          y = y + chipPinLength;
+        } else {
+          angle = 90;
+        }
+      } else {
+        if (isChip) {
+          angle = 90;
+          y = y - chipPinLength;
+        } else {
+          angle = 270;
+        }
+      }
+    }
+    return { x, y, angle };
+  }
+  /**
+   * Creates text effects for properties
+   */
+  createTextEffects(size, hide) {
+    const font = new TextEffectsFont();
+    font.size = { height: size, width: size };
+    return new TextEffects({
+      font,
+      hiddenText: hide
+    });
+  }
+  getOutput() {
+    if (!this.ctx.kicadSch) {
+      throw new Error("kicadSch is not initialized");
+    }
+    return this.ctx.kicadSch;
+  }
+};
+
+// lib/schematic/stages/AddSchematicSymbolsStage.ts
+import {
+  SchematicSymbol as SchematicSymbol2,
+  SymbolLibId,
+  SymbolProperty as SymbolProperty2,
+  SymbolPin as SymbolPin2,
+  SymbolInstances,
+  SymbolInstancesProject,
+  SymbolInstancePath,
+  TextEffects as TextEffects2,
+  TextEffectsFont as TextEffectsFont2,
+  TextEffectsJustify
+} from "kicadts";
+import { applyToPoint } from "transformation-matrix";
+import { symbols as symbols2 } from "schematic-symbols";
+var AddSchematicSymbolsStage = class extends ConverterStage {
+  _step() {
+    const { kicadSch, db } = this.ctx;
+    const schematicComponents = db.schematic_component.list();
+    if (schematicComponents.length === 0) {
+      this.finished = true;
+      return;
+    }
+    const symbols3 = [];
+    for (const schematicComponent of schematicComponents) {
+      const sourceComponent = schematicComponent.source_component_id ? db.source_component.get(schematicComponent.source_component_id) : null;
+      if (!sourceComponent) continue;
+      if (!this.ctx.c2kMatSch) continue;
+      const { x, y } = applyToPoint(this.ctx.c2kMatSch, {
+        x: schematicComponent.center.x,
+        y: schematicComponent.center.y
+      });
+      const uuid = crypto.randomUUID();
+      const symbol = new SchematicSymbol2({
+        at: [x, y, 0],
+        unit: 1,
+        excludeFromSim: false,
+        inBom: true,
+        onBoard: true,
+        dnp: false,
+        uuid,
+        fieldsAutoplaced: true
+      });
+      const libId = this.getLibraryId(sourceComponent);
+      const symLibId = new SymbolLibId(libId);
+      symbol._sxLibId = symLibId;
+      const { reference, value, description } = this.getComponentMetadata(sourceComponent);
+      const { refTextPos, valTextPos } = this.getTextPositions(
+        schematicComponent,
+        { x, y }
+      );
+      const referenceProperty = new SymbolProperty2({
+        key: "Reference",
+        value: reference,
+        id: 0,
+        at: [refTextPos.x, refTextPos.y, 0],
+        effects: this.createTextEffects(1.27, false)
+      });
+      const hideValue = sourceComponent.ftype === "simple_chip";
+      const valueProperty = new SymbolProperty2({
+        key: "Value",
+        value,
+        id: 1,
+        at: [valTextPos.x, valTextPos.y, 0],
+        effects: this.createTextEffects(1.27, hideValue)
+      });
+      const footprintProperty = new SymbolProperty2({
+        key: "Footprint",
+        value: "",
+        id: 2,
+        at: [x - 1.778, y, 90],
+        effects: this.createTextEffects(1.27, true)
+      });
+      const datasheetProperty = new SymbolProperty2({
+        key: "Datasheet",
+        value: "~",
+        id: 3,
+        at: [x, y, 0],
+        effects: this.createTextEffects(1.27, true)
+      });
+      const descriptionProperty = new SymbolProperty2({
+        key: "Description",
+        value: description,
+        id: 4,
+        at: [x, y, 0],
+        effects: this.createTextEffects(1.27, true)
+      });
+      symbol.properties.push(
+        referenceProperty,
+        valueProperty,
+        footprintProperty,
+        datasheetProperty,
+        descriptionProperty
+      );
+      const schematicPorts = 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));
+      for (const port of schematicPorts) {
+        const pin = new SymbolPin2();
+        pin.numberString = `${port.pin_number || 1}`;
+        pin.uuid = crypto.randomUUID();
+        symbol.pins.push(pin);
+      }
+      const instances = new SymbolInstances();
+      const project = new SymbolInstancesProject("");
+      const path = new SymbolInstancePath(`/${kicadSch?.uuid?.value || ""}`);
+      path.reference = reference;
+      path.unit = 1;
+      project.paths.push(path);
+      instances.projects.push(project);
+      symbol._sxInstances = instances;
+      symbols3.push(symbol);
+    }
+    if (kicadSch) {
+      kicadSch.symbols = symbols3;
+    }
+    this.finished = true;
+  }
+  /**
+   * Get text positions from schematic symbol definition or schematic_text elements
+   */
+  getTextPositions(schematicComponent, symbolKicadPos) {
+    const schematicTexts = this.ctx.db.schematic_text?.list?.()?.filter(
+      (t) => t.schematic_component_id === schematicComponent.schematic_component_id
+    ) || [];
+    const refText = schematicTexts.find((t) => t.text && t.text.length > 0);
+    if (refText && this.ctx.c2kMatSch) {
+      const refTextPos2 = applyToPoint(this.ctx.c2kMatSch, {
+        x: refText.position.x,
+        y: refText.position.y
+      });
+      const valTextPos2 = { x: symbolKicadPos.x, y: symbolKicadPos.y + 6 };
+      return { refTextPos: refTextPos2, valTextPos: valTextPos2 };
+    }
+    const symbolName = schematicComponent.symbol_name;
+    const symbol = symbols2[symbolName];
+    if (!symbol) {
+      return {
+        refTextPos: { x: symbolKicadPos.x, y: symbolKicadPos.y - 6 },
+        valTextPos: { x: symbolKicadPos.x, y: symbolKicadPos.y + 6 }
+      };
+    }
+    let refTextPrimitive = null;
+    let valTextPrimitive = null;
+    for (const primitive of symbol.primitives) {
+      if (primitive.type === "text") {
+        if (primitive.text === "{REF}") {
+          refTextPrimitive = primitive;
+        } else if (primitive.text === "{VAL}") {
+          valTextPrimitive = primitive;
+        }
+      }
+    }
+    const refTextPos = refTextPrimitive && this.ctx.c2kMatSch ? applyToPoint(this.ctx.c2kMatSch, {
+      x: schematicComponent.center.x + refTextPrimitive.x,
+      y: schematicComponent.center.y + refTextPrimitive.y
+    }) : { x: symbolKicadPos.x, y: symbolKicadPos.y - 6 };
+    const valTextPos = valTextPrimitive && this.ctx.c2kMatSch ? applyToPoint(this.ctx.c2kMatSch, {
+      x: schematicComponent.center.x + valTextPrimitive.x,
+      y: schematicComponent.center.y + valTextPrimitive.y
+    }) : { x: symbolKicadPos.x, y: symbolKicadPos.y + 6 };
+    return { refTextPos, valTextPos };
+  }
+  /**
+   * Get KiCad library ID for a component
+   */
+  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";
+  }
+  /**
+   * Get component metadata (reference, value, description)
+   */
+  getComponentMetadata(sourceComp) {
+    const name = sourceComp.name || "?";
+    if (sourceComp.ftype === "simple_resistor") {
+      return {
+        reference: name,
+        value: sourceComp.display_resistance || "R",
+        description: "Resistor"
+      };
+    }
+    if (sourceComp.ftype === "simple_capacitor") {
+      return {
+        reference: name,
+        value: sourceComp.display_capacitance || "C",
+        description: "Capacitor"
+      };
+    }
+    if (sourceComp.ftype === "simple_inductor") {
+      return {
+        reference: name,
+        value: sourceComp.display_inductance || "L",
+        description: "Inductor"
+      };
+    }
+    if (sourceComp.ftype === "simple_diode") {
+      return {
+        reference: name,
+        value: "D",
+        description: "Diode"
+      };
+    }
+    if (sourceComp.ftype === "simple_chip") {
+      return {
+        reference: name,
+        value: name,
+        description: "Integrated Circuit"
+      };
+    }
+    return {
+      reference: name,
+      value: name,
+      description: "Component"
+    };
+  }
+  /**
+   * Creates text effects for properties
+   */
+  createTextEffects(size, hide = false, justify) {
+    const font = new TextEffectsFont2();
+    font.size = { height: size, width: size };
+    const justifyObj = justify ? new TextEffectsJustify({ horizontal: justify }) : void 0;
+    const effects = new TextEffects2({
+      font,
+      hiddenText: hide,
+      justify: justifyObj
+    });
+    return effects;
+  }
+  getOutput() {
+    if (!this.ctx.kicadSch) {
+      throw new Error("kicadSch is not initialized");
+    }
+    return this.ctx.kicadSch;
+  }
+};
+
+// lib/schematic/stages/AddSchematicTracesStage.ts
+import { Wire, Pts as Pts2, Xy as Xy2, Stroke as Stroke2, Junction } from "kicadts";
+import { applyToPoint as applyToPoint2 } from "transformation-matrix";
+var AddSchematicTracesStage = class extends ConverterStage {
+  _step() {
+    const { kicadSch, db } = this.ctx;
+    if (!kicadSch) {
+      throw new Error("KicadSch instance not initialized in context");
+    }
+    const schematicTraces = db.schematic_trace.list();
+    if (schematicTraces.length === 0) {
+      this.finished = true;
+      return;
+    }
+    const wires = [];
+    const junctions = [];
+    for (const schematicTrace of schematicTraces) {
+      for (const edge of schematicTrace.edges) {
+        const wire = this.createWireFromEdge(edge);
+        wires.push(wire);
+      }
+      for (const junction of schematicTrace.junctions) {
+        const kicadJunction = this.createJunction(junction);
+        junctions.push(kicadJunction);
+      }
+    }
+    kicadSch.wires = wires;
+    kicadSch.junctions = junctions;
+    this.finished = true;
+  }
+  /**
+   * Create a KiCad wire from a schematic trace edge
+   */
+  createWireFromEdge(edge) {
+    const wire = new Wire();
+    if (!this.ctx.c2kMatSch) {
+      throw new Error(
+        "Schematic transformation matrix not initialized in context"
+      );
+    }
+    const from = applyToPoint2(this.ctx.c2kMatSch, {
+      x: edge.from.x,
+      y: edge.from.y
+    });
+    const to = applyToPoint2(this.ctx.c2kMatSch, {
+      x: edge.to.x,
+      y: edge.to.y
+    });
+    const x1 = from.x;
+    const y1 = from.y;
+    const x2 = to.x;
+    const y2 = to.y;
+    const pts = new Pts2([new Xy2(x1, y1), new Xy2(x2, y2)]);
+    wire.points = pts;
+    const stroke = new Stroke2();
+    stroke.width = 0;
+    stroke.type = "default";
+    wire.stroke = stroke;
+    wire.uuid = crypto.randomUUID();
+    return wire;
+  }
+  /**
+   * Create a KiCad junction from a circuit-json junction point
+   */
+  createJunction(junction) {
+    if (!this.ctx.c2kMatSch) {
+      throw new Error(
+        "Schematic transformation matrix not initialized in context"
+      );
+    }
+    const { x, y } = applyToPoint2(this.ctx.c2kMatSch, {
+      x: junction.x,
+      y: junction.y
+    });
+    const kicadJunction = new Junction({
+      at: [x, y, 0],
+      diameter: 0
+      // 0 means use default diameter
+    });
+    kicadJunction.uuid = crypto.randomUUID();
+    return kicadJunction;
+  }
+  getOutput() {
+    return this.ctx.kicadSch;
+  }
+};
+
+// lib/schematic/stages/AddSheetInstancesStage.ts
+import {
+  SheetInstances,
+  SheetInstancesRootPath,
+  SheetInstancesRootPage,
+  EmbeddedFonts as EmbeddedFonts3
+} from "kicadts";
+var AddSheetInstancesStage = class extends ConverterStage {
+  _step() {
+    const { kicadSch } = this.ctx;
+    if (!kicadSch) {
+      throw new Error("KicadSch instance not initialized in context");
+    }
+    const sheetInstances = new SheetInstances();
+    const path = new SheetInstancesRootPath();
+    path.value = "/";
+    const page = new SheetInstancesRootPage("1");
+    path.pages = [page];
+    sheetInstances.paths = [path];
+    kicadSch.sheetInstances = sheetInstances;
+    kicadSch.embeddedFonts = new EmbeddedFonts3(false);
+    this.finished = true;
+  }
+  getOutput() {
+    return this.ctx.kicadSch;
+  }
+};
+
+// lib/schematic/CircuitJsonToKicadSchConverter.ts
+var CircuitJsonToKicadSchConverter = class {
+  ctx;
+  pipeline;
+  currentStageIndex = 0;
+  finished = false;
+  get currentStage() {
+    return this.pipeline[this.currentStageIndex];
+  }
+  constructor(circuitJson) {
+    const CIRCUIT_JSON_SCALE_FACTOR = 15;
+    const KICAD_CENTER_X = 95.25;
+    const KICAD_CENTER_Y = 73.66;
+    this.ctx = {
+      db: cju(circuitJson),
+      circuitJson,
+      kicadSch: new KicadSch({
+        generator: "circuit-json-to-kicad",
+        generatorVersion: "0.0.1"
+      }),
+      c2kMatSch: compose(
+        translate(KICAD_CENTER_X, KICAD_CENTER_Y),
+        scale(CIRCUIT_JSON_SCALE_FACTOR, -CIRCUIT_JSON_SCALE_FACTOR)
+      )
+    };
+    this.pipeline = [
+      new InitializeSchematicStage(circuitJson, this.ctx),
+      new AddLibrarySymbolsStage(circuitJson, this.ctx),
+      new AddSchematicSymbolsStage(circuitJson, this.ctx),
+      new AddSchematicTracesStage(circuitJson, this.ctx),
+      new AddSheetInstancesStage(circuitJson, this.ctx)
+    ];
+  }
+  step() {
+    if (!this.currentStage) {
+      this.finished = true;
+      return;
+    }
+    this.currentStage.step();
+    if (this.currentStage.finished) {
+      this.currentStageIndex++;
+    }
+  }
+  runUntilFinished() {
+    while (!this.finished) {
+      this.step();
+    }
+  }
+  getOutput() {
+    return this.ctx.kicadSch;
+  }
+  /**
+   * Get the output as a string
+   */
+  getOutputString() {
+    return this.ctx.kicadSch.getString();
+  }
+};
+
+// lib/pcb/CircuitJsonToKicadPcbConverter.ts
+import { KicadPcb } from "kicadts";
+import { cju as cju2 } from "@tscircuit/circuit-json-util";
+import { compose as compose2, translate as translate2, scale as scale2 } from "transformation-matrix";
+
+// lib/pcb/stages/InitializePcbStage.ts
+import {
+  Paper as Paper2,
+  PcbLayers,
+  PcbLayerDefinition,
+  PcbGeneral,
+  Setup
+} from "kicadts";
+var InitializePcbStage = class extends ConverterStage {
+  _step() {
+    const { kicadPcb } = this.ctx;
+    if (!kicadPcb) {
+      throw new Error("KicadPcb instance not initialized in context");
+    }
+    kicadPcb.version = 20241229;
+    const paper = new Paper2();
+    paper.size = "A4";
+    kicadPcb.paper = paper;
+    const general = new PcbGeneral();
+    general.thickness = 1.6;
+    kicadPcb.general = general;
+    const setup = new Setup();
+    setup.padToMaskClearance = 0;
+    kicadPcb.setup = setup;
+    const layers = new PcbLayers();
+    const layerDefinitions = [
+      // Copper layers (standard KiCad indices)
+      new PcbLayerDefinition({ index: 0, name: "F.Cu", type: "signal" }),
+      new PcbLayerDefinition({ index: 2, name: "B.Cu", type: "signal" }),
+      // Technical layers
+      new PcbLayerDefinition({ index: 9, name: "F.Adhes", type: "user" }),
+      new PcbLayerDefinition({ index: 11, name: "B.Adhes", type: "user" }),
+      new PcbLayerDefinition({ index: 13, name: "F.Paste", type: "user" }),
+      new PcbLayerDefinition({ index: 15, name: "B.Paste", type: "user" }),
+      new PcbLayerDefinition({ index: 5, name: "F.SilkS", type: "user" }),
+      new PcbLayerDefinition({ index: 7, name: "B.SilkS", type: "user" }),
+      new PcbLayerDefinition({ index: 1, name: "F.Mask", type: "user" }),
+      new PcbLayerDefinition({ index: 3, name: "B.Mask", type: "user" }),
+      // Drawing layers
+      new PcbLayerDefinition({ index: 20, name: "Dwgs.User", type: "user" }),
+      new PcbLayerDefinition({ index: 21, name: "Cmts.User", type: "user" }),
+      new PcbLayerDefinition({ index: 22, name: "Eco1.User", type: "user" }),
+      new PcbLayerDefinition({ index: 23, name: "Eco2.User", type: "user" }),
+      new PcbLayerDefinition({ index: 24, name: "Edge.Cuts", type: "user" }),
+      new PcbLayerDefinition({ index: 25, name: "Margin", type: "user" }),
+      // Fabrication layers
+      new PcbLayerDefinition({ index: 17, name: "B.CrtYd", type: "user" }),
+      new PcbLayerDefinition({ index: 16, name: "F.CrtYd", type: "user" }),
+      new PcbLayerDefinition({ index: 19, name: "B.Fab", type: "user" }),
+      new PcbLayerDefinition({ index: 18, name: "F.Fab", type: "user" })
+    ];
+    layers.definitions = layerDefinitions;
+    kicadPcb.layers = layers;
+    this.finished = true;
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+};
+
+// lib/pcb/stages/AddNetsStage.ts
+import { PcbNet } from "kicadts";
+var AddNetsStage = class extends ConverterStage {
+  _step() {
+    const { kicadPcb } = this.ctx;
+    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 net = new PcbNet(netNumber, netName);
+      const nets = kicadPcb.nets;
+      nets.push(net);
+      kicadPcb.nets = nets;
+      this.ctx.pcbNetMap.set(netName, netNumber);
+      netNumber++;
+    }
+    this.finished = true;
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+};
+
+// lib/pcb/stages/AddFootprintsStage.ts
+import { Footprint, FpText, FootprintPad } from "kicadts";
+import { applyToPoint as applyToPoint3 } from "transformation-matrix";
+var AddFootprintsStage = class extends ConverterStage {
+  componentsProcessed = 0;
+  pcbComponents = [];
+  constructor(input, ctx) {
+    super(input, ctx);
+    this.pcbComponents = this.ctx.db.pcb_component.list();
+  }
+  _step() {
+    const { kicadPcb, c2kMatPcb } = this.ctx;
+    if (!kicadPcb) {
+      throw new Error("KicadPcb instance not initialized in context");
+    }
+    if (!c2kMatPcb) {
+      throw new Error("PCB transformation matrix not initialized in context");
+    }
+    if (this.componentsProcessed >= this.pcbComponents.length) {
+      this.finished = true;
+      return;
+    }
+    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 = applyToPoint3(c2kMatPcb, {
+      x: component.center.x,
+      y: component.center.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()
+    });
+    const fpTexts = footprint.fpTexts;
+    fpTexts.push(refText);
+    fpTexts.push(valueText);
+    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()
+      });
+      fpPads.push(pad);
+      padNumber++;
+    }
+    footprint.fpPads = fpPads;
+    const footprints = kicadPcb.footprints;
+    footprints.push(footprint);
+    kicadPcb.footprints = footprints;
+    this.componentsProcessed++;
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+};
+
+// lib/pcb/stages/AddTracesStage.ts
+import { Segment, SegmentNet } from "kicadts";
+import { applyToPoint as applyToPoint4 } from "transformation-matrix";
+var AddTracesStage = class extends ConverterStage {
+  tracesProcessed = 0;
+  pcbTraces = [];
+  constructor(input, ctx) {
+    super(input, ctx);
+    this.pcbTraces = this.ctx.db.pcb_trace.list();
+  }
+  _step() {
+    const { kicadPcb, c2kMatPcb, pcbNetMap } = this.ctx;
+    if (!kicadPcb) {
+      throw new Error("KicadPcb instance not initialized in context");
+    }
+    if (!c2kMatPcb) {
+      throw new Error("PCB transformation matrix not initialized in context");
+    }
+    if (this.tracesProcessed >= this.pcbTraces.length) {
+      this.finished = true;
+      return;
+    }
+    const trace = this.pcbTraces[this.tracesProcessed];
+    if (!trace.route || trace.route.length < 2) {
+      this.tracesProcessed++;
+      return;
+    }
+    for (let i = 0; i < trace.route.length - 1; i++) {
+      const startPoint = trace.route[i];
+      const endPoint = trace.route[i + 1];
+      const transformedStart = applyToPoint4(c2kMatPcb, {
+        x: startPoint.x,
+        y: startPoint.y
+      });
+      const transformedEnd = applyToPoint4(c2kMatPcb, {
+        x: endPoint.x,
+        y: endPoint.y
+      });
+      let netNumber = 0;
+      if (pcbNetMap) {
+        const netName = `Net-${trace.pcb_trace_id}`;
+        netNumber = pcbNetMap.get(netName) ?? 0;
+      }
+      const layerMap = {
+        top: "F.Cu",
+        bottom: "B.Cu"
+      };
+      const kicadLayer = layerMap[startPoint.layer] || startPoint.layer || "F.Cu";
+      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)
+      });
+      const segments = kicadPcb.segments;
+      segments.push(segment);
+      kicadPcb.segments = segments;
+    }
+    this.tracesProcessed++;
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+};
+
+// lib/pcb/stages/AddViasStage.ts
+import { Via, ViaNet } from "kicadts";
+import { applyToPoint as applyToPoint5 } from "transformation-matrix";
+var AddViasStage = class extends ConverterStage {
+  viasProcessed = 0;
+  pcbVias = [];
+  constructor(input, ctx) {
+    super(input, ctx);
+    this.pcbVias = this.ctx.db.pcb_via?.list() || [];
+  }
+  _step() {
+    const { kicadPcb, c2kMatPcb, pcbNetMap } = this.ctx;
+    if (!kicadPcb) {
+      throw new Error("KicadPcb instance not initialized in context");
+    }
+    if (!c2kMatPcb) {
+      throw new Error("PCB transformation matrix not initialized in context");
+    }
+    if (this.viasProcessed >= this.pcbVias.length) {
+      this.finished = true;
+      return;
+    }
+    const via = this.pcbVias[this.viasProcessed];
+    const transformedPos = applyToPoint5(c2kMatPcb, {
+      x: via.x,
+      y: via.y
+    });
+    let netNumber = 0;
+    if (pcbNetMap && via.net_name) {
+      netNumber = pcbNetMap.get(via.net_name) ?? 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)
+    });
+    const vias = kicadPcb.vias;
+    vias.push(kicadVia);
+    kicadPcb.vias = vias;
+    this.viasProcessed++;
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+};
+
+// lib/pcb/stages/AddGraphicsStage.ts
+import { GrLine } from "kicadts";
+import { applyToPoint as applyToPoint6 } from "transformation-matrix";
+var AddGraphicsStage = class extends ConverterStage {
+  _step() {
+    const { kicadPcb, c2kMatPcb } = this.ctx;
+    if (!kicadPcb) {
+      throw new Error("KicadPcb instance not initialized in context");
+    }
+    if (!c2kMatPcb) {
+      throw new Error("PCB transformation matrix not initialized in context");
+    }
+    const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list() || [];
+    for (const path of pcbSilkscreenPaths) {
+      if (!path.route || path.route.length < 2) continue;
+      for (let i = 0; i < path.route.length - 1; i++) {
+        const startPoint = path.route[i];
+        const endPoint = path.route[i + 1];
+        if (!startPoint || !endPoint) continue;
+        const transformedStart = applyToPoint6(c2kMatPcb, {
+          x: startPoint.x,
+          y: startPoint.y
+        });
+        const transformedEnd = applyToPoint6(c2kMatPcb, {
+          x: endPoint.x,
+          y: endPoint.y
+        });
+        const layerMap = {
+          top: "F.SilkS",
+          bottom: "B.SilkS"
+        };
+        const kicadLayer = layerMap[path.layer] || path.layer || "F.SilkS";
+        const grLine = new GrLine({
+          start: { x: transformedStart.x, y: transformedStart.y },
+          end: { x: transformedEnd.x, y: transformedEnd.y },
+          layer: kicadLayer,
+          width: path.stroke_width || 0.15
+        });
+        const graphicLines = kicadPcb.graphicLines;
+        graphicLines.push(grLine);
+        kicadPcb.graphicLines = graphicLines;
+      }
+    }
+    const pcbBoards = this.ctx.db.pcb_board?.list() || [];
+    if (pcbBoards.length > 0) {
+      const board = pcbBoards[0];
+      if (!board) {
+        this.finished = true;
+        return;
+      }
+      let corners;
+      if (board.outline && board.outline.length > 0) {
+        corners = board.outline;
+      } else {
+        const halfWidth = board.width / 2;
+        const halfHeight = board.height / 2;
+        corners = [
+          { x: board.center.x - halfWidth, y: board.center.y - halfHeight },
+          { x: board.center.x + halfWidth, y: board.center.y - halfHeight },
+          { x: board.center.x + halfWidth, y: board.center.y + halfHeight },
+          { x: board.center.x - halfWidth, y: board.center.y + halfHeight }
+        ];
+      }
+      const transformedCorners = corners.map(
+        (corner) => applyToPoint6(c2kMatPcb, corner)
+      );
+      for (let i = 0; i < transformedCorners.length; i++) {
+        const start = transformedCorners[i];
+        const end = transformedCorners[(i + 1) % transformedCorners.length];
+        if (!start || !end) continue;
+        const edgeLine = new GrLine({
+          start: { x: start.x, y: start.y },
+          end: { x: end.x, y: end.y },
+          layer: "Edge.Cuts",
+          width: 0.1
+        });
+        const graphicLines = kicadPcb.graphicLines;
+        graphicLines.push(edgeLine);
+        kicadPcb.graphicLines = graphicLines;
+      }
+    }
+    this.finished = true;
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+};
+
+// lib/pcb/CircuitJsonToKicadPcbConverter.ts
+var CircuitJsonToKicadPcbConverter = class {
+  ctx;
+  pipeline;
+  currentStageIndex = 0;
+  finished = false;
+  get currentStage() {
+    return this.pipeline[this.currentStageIndex];
+  }
+  constructor(circuitJson) {
+    const CIRCUIT_JSON_TO_MM_SCALE = 1;
+    const KICAD_PCB_CENTER_X = 100;
+    const KICAD_PCB_CENTER_Y = 100;
+    this.ctx = {
+      db: cju2(circuitJson),
+      circuitJson,
+      kicadPcb: new KicadPcb({
+        generator: "circuit-json-to-kicad",
+        generatorVersion: "0.0.1"
+      }),
+      c2kMatPcb: compose2(
+        translate2(KICAD_PCB_CENTER_X, KICAD_PCB_CENTER_Y),
+        scale2(CIRCUIT_JSON_TO_MM_SCALE, -CIRCUIT_JSON_TO_MM_SCALE)
+      )
+    };
+    this.pipeline = [
+      new InitializePcbStage(circuitJson, this.ctx),
+      new AddNetsStage(circuitJson, this.ctx),
+      new AddFootprintsStage(circuitJson, this.ctx),
+      new AddTracesStage(circuitJson, this.ctx),
+      new AddViasStage(circuitJson, this.ctx),
+      new AddGraphicsStage(circuitJson, this.ctx)
+    ];
+  }
+  step() {
+    if (!this.currentStage) {
+      this.finished = true;
+      return;
+    }
+    this.currentStage.step();
+    if (this.currentStage.finished) {
+      this.currentStageIndex++;
+    }
+  }
+  runUntilFinished() {
+    while (!this.finished) {
+      this.step();
+    }
+  }
+  getOutput() {
+    return this.ctx.kicadPcb;
+  }
+  /**
+   * Get the output as a string
+   */
+  getOutputString() {
+    return this.ctx.kicadPcb.getString();
+  }
+};
+export {
+  CircuitJsonToKicadPcbConverter,
+  CircuitJsonToKicadSchConverter
+};