@tscircuit/cli 0.1.220 → 0.1.221

package/dist/main.js

@@ -63215,7 +63215,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.219";
+var version = "0.1.220";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -63271,7 +63271,8 @@ var package_default = {
     tscircuit: "^0.0.650-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
-    zod: "3"
+    zod: "3",
+    "circuit-json-to-spice": "^0.0.10"
   },
   peerDependencies: {
     tscircuit: "*"
@@ -71588,12 +71589,680 @@ var exportSnippet = async ({
   });
 };
 
+// node_modules/circuit-json-to-spice/dist/index.js
+import { getSourcePortConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+var convertSpiceNetlistToString = (netlist) => {
+  const lines = [];
+  lines.push(netlist.title);
+  if (netlist.models.size > 0) {
+    lines.push(...Array.from(netlist.models.values()));
+  }
+  for (const component of netlist.components) {
+    lines.push(component.toSpiceString());
+  }
+  for (const subcircuit of netlist.subcircuits) {
+    lines.push(subcircuit.toSpiceString());
+  }
+  if (netlist.controls.length > 0) {
+    lines.push(".control");
+    lines.push(...netlist.controls);
+    lines.push(".endc");
+  }
+  lines.push(".END");
+  return lines.join(`
+`);
+};
+var SpiceNetlist = class {
+  title;
+  components;
+  nodes;
+  controls;
+  subcircuits;
+  models;
+  constructor(title = "Circuit Netlist") {
+    this.title = title;
+    this.components = [];
+    this.nodes = /* @__PURE__ */ new Set;
+    this.controls = [];
+    this.subcircuits = [];
+    this.models = /* @__PURE__ */ new Map;
+  }
+  addComponent(component) {
+    this.components.push(component);
+    for (const node of component.nodes) {
+      this.nodes.add(node);
+    }
+  }
+  addSubcircuit(subcircuit) {
+    if (this.subcircuits.find((s) => s.name === subcircuit.name))
+      return;
+    this.subcircuits.push(subcircuit);
+  }
+  toSpiceString() {
+    return convertSpiceNetlistToString(this);
+  }
+};
+var SpiceComponent = class {
+  name;
+  command;
+  nodes;
+  constructor(name, command, nodes) {
+    this.name = name;
+    this.command = command;
+    this.nodes = nodes;
+  }
+  toSpiceString() {
+    return this.command.toSpiceString();
+  }
+};
+var ResistorCommand = class {
+  commandName = "resistor";
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  toSpiceString() {
+    const { name, positiveNode, negativeNode, model, value } = this.props;
+    let spiceString = `R${name} ${positiveNode} ${negativeNode}`;
+    if (model) {
+      spiceString += ` ${model}`;
+    }
+    spiceString += ` ${value}`;
+    return spiceString;
+  }
+};
+var CapacitorCommand = class {
+  commandName = "capacitor";
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  toSpiceString() {
+    const {
+      name,
+      positiveNode,
+      negativeNode,
+      modelName,
+      value,
+      initialCondition
+    } = this.props;
+    let spiceString = `C${name} ${positiveNode} ${negativeNode}`;
+    if (modelName) {
+      spiceString += ` ${modelName}`;
+    }
+    spiceString += ` ${value}`;
+    if (initialCondition) {
+      spiceString += ` IC=${initialCondition}`;
+    }
+    return spiceString;
+  }
+};
+var VoltageSourceCommand = class {
+  commandName = "voltage_source";
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  toSpiceString() {
+    const { name, positiveNode, negativeNode, value, acMagnitude, acPhase } = this.props;
+    let spiceString = `V${name} ${positiveNode} ${negativeNode}`;
+    if (value) {
+      spiceString += ` ${value}`;
+    }
+    if (acMagnitude) {
+      spiceString += ` AC ${acMagnitude}`;
+      if (acPhase) {
+        spiceString += ` ${acPhase}`;
+      }
+    }
+    return spiceString;
+  }
+};
+var DiodeCommand = class {
+  commandName = "diode";
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  toSpiceString() {
+    const { name, positiveNode, negativeNode, model, area } = this.props;
+    let spiceString = `D${name} ${positiveNode} ${negativeNode} ${model}`;
+    if (area) {
+      spiceString += ` ${area}`;
+    }
+    return spiceString;
+  }
+};
+var InductorCommand = class {
+  commandName = "inductor";
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  toSpiceString() {
+    const { name, positiveNode, negativeNode, model, value, initialCondition } = this.props;
+    let spiceString = `L${name} ${positiveNode} ${negativeNode}`;
+    if (model) {
+      spiceString += ` ${model}`;
+    }
+    spiceString += ` ${value}`;
+    if (initialCondition) {
+      spiceString += ` IC=${initialCondition}`;
+    }
+    return spiceString;
+  }
+};
+var VoltageControlledSwitchCommand = class {
+  commandName = "voltage_controlled_switch";
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  toSpiceString() {
+    const {
+      name,
+      positiveNode,
+      negativeNode,
+      positiveControl,
+      negativeControl,
+      model
+    } = this.props;
+    return `S${name} ${positiveNode} ${negativeNode} ${positiveControl} ${negativeControl} ${model}`;
+  }
+};
+function circuitJsonToSpice(circuitJson) {
+  const netlist = new SpiceNetlist("* Circuit JSON to SPICE Netlist");
+  const sourceComponents = su_default(circuitJson).source_component.list();
+  const sourcePorts = su_default(circuitJson).source_port.list();
+  const connMap = getSourcePortConnectivityMapFromCircuitJson(circuitJson);
+  const nodeMap = /* @__PURE__ */ new Map;
+  const netToNodeName = /* @__PURE__ */ new Map;
+  let nodeCounter = 1;
+  const groundNets = /* @__PURE__ */ new Set;
+  const gndSourceNetIds = new Set(su_default(circuitJson).source_net.list().filter((sn) => sn.name?.toLowerCase().includes("gnd")).map((sn) => sn.source_net_id));
+  if (gndSourceNetIds.size > 0) {
+    for (const trace of su_default(circuitJson).source_trace.list()) {
+      if (trace.connected_source_port_ids.length > 0) {
+        const isOnGndNet = trace.connected_source_net_ids.some((netId) => gndSourceNetIds.has(netId));
+        if (isOnGndNet) {
+          const aPortOnGnd = trace.connected_source_port_ids[0];
+          const gndNet = connMap.getNetConnectedToId(aPortOnGnd);
+          if (gndNet) {
+            groundNets.add(gndNet);
+          }
+        }
+      }
+    }
+  }
+  const groundPorts = sourcePorts.filter((p) => p.name?.toLowerCase() === "gnd");
+  for (const groundPort of groundPorts) {
+    const groundNet = connMap.getNetConnectedToId(groundPort.source_port_id);
+    if (groundNet) {
+      groundNets.add(groundNet);
+    }
+  }
+  for (const simSource of su_default(circuitJson).simulation_voltage_source.list()) {
+    const neg_port_id = simSource.negative_source_port_id ?? simSource.terminal2_source_port_id;
+    if (neg_port_id) {
+      const gnd_net = connMap.getNetConnectedToId(neg_port_id);
+      if (gnd_net) {
+        groundNets.add(gnd_net);
+      }
+    }
+  }
+  for (const groundNet of groundNets) {
+    netToNodeName.set(groundNet, "0");
+  }
+  for (const port of sourcePorts) {
+    const portId = port.source_port_id;
+    const net2 = connMap.getNetConnectedToId(portId);
+    if (net2) {
+      if (!netToNodeName.has(net2)) {
+        netToNodeName.set(net2, `N${nodeCounter++}`);
+      }
+      nodeMap.set(portId, netToNodeName.get(net2));
+    }
+  }
+  for (const port of sourcePorts) {
+    const portId = port.source_port_id;
+    if (!nodeMap.has(portId)) {
+      nodeMap.set(portId, `N${nodeCounter++}`);
+    }
+  }
+  for (const component of sourceComponents) {
+    if (component.type !== "source_component")
+      continue;
+    const componentPorts = su_default(circuitJson).source_port.list({
+      source_component_id: component.source_component_id
+    }).sort((a, b) => (a.pin_number ?? 0) - (b.pin_number ?? 0));
+    const nodes = componentPorts.map((port) => {
+      return nodeMap.get(port.source_port_id) || "0";
+    });
+    if ("ftype" in component) {
+      let spiceComponent = null;
+      switch (component.ftype) {
+        case "simple_resistor": {
+          if ("resistance" in component && "name" in component) {
+            const resistorCmd = new ResistorCommand({
+              name: component.name,
+              positiveNode: nodes[0] || "0",
+              negativeNode: nodes[1] || "0",
+              value: formatResistance(component.resistance)
+            });
+            spiceComponent = new SpiceComponent(component.name, resistorCmd, nodes);
+          }
+          break;
+        }
+        case "simple_capacitor": {
+          if ("capacitance" in component && "name" in component) {
+            const capacitorCmd = new CapacitorCommand({
+              name: component.name,
+              positiveNode: nodes[0] || "0",
+              negativeNode: nodes[1] || "0",
+              value: formatCapacitance(component.capacitance)
+            });
+            spiceComponent = new SpiceComponent(component.name, capacitorCmd, nodes);
+          }
+          break;
+        }
+        case "simple_diode": {
+          if ("name" in component) {
+            const anodePort = componentPorts.find((p) => p.name?.toLowerCase() === "anode" || p.port_hints?.includes("anode"));
+            const cathodePort = componentPorts.find((p) => p.name?.toLowerCase() === "cathode" || p.port_hints?.includes("cathode"));
+            const positiveNode = nodeMap.get(anodePort?.source_port_id ?? "") || "0";
+            const negativeNode = nodeMap.get(cathodePort?.source_port_id ?? "") || "0";
+            const modelName = "D";
+            const diodeCmd = new DiodeCommand({
+              name: component.name,
+              positiveNode,
+              negativeNode,
+              model: modelName
+            });
+            netlist.models.set(modelName, `.MODEL ${modelName} D`);
+            spiceComponent = new SpiceComponent(component.name, diodeCmd, [
+              positiveNode,
+              negativeNode
+            ]);
+          }
+          break;
+        }
+        case "simple_inductor": {
+          if ("inductance" in component && "name" in component) {
+            const inductorCmd = new InductorCommand({
+              name: component.name,
+              positiveNode: nodes[0] || "0",
+              negativeNode: nodes[1] || "0",
+              value: formatInductance(component.inductance)
+            });
+            spiceComponent = new SpiceComponent(component.name, inductorCmd, nodes);
+          }
+          break;
+        }
+        case "simple_mosfet": {
+          if ("name" in component) {
+            const drainPort = componentPorts.find((p) => p.name?.toLowerCase() === "drain" || p.port_hints?.includes("drain"));
+            const gatePort = componentPorts.find((p) => p.name?.toLowerCase() === "gate" || p.port_hints?.includes("gate"));
+            const sourcePort = componentPorts.find((p) => p.name?.toLowerCase() === "source" || p.port_hints?.includes("source"));
+            const drainNode = nodeMap.get(drainPort?.source_port_id ?? "") || "0";
+            const gateNode = nodeMap.get(gatePort?.source_port_id ?? "") || "0";
+            const sourceNode = nodeMap.get(sourcePort?.source_port_id ?? "") || "0";
+            const modelName = "SWMOD";
+            const switchCmd = new VoltageControlledSwitchCommand({
+              name: component.name,
+              positiveNode: drainNode,
+              negativeNode: sourceNode,
+              positiveControl: gateNode,
+              negativeControl: sourceNode,
+              model: modelName
+            });
+            netlist.models.set(modelName, `.MODEL ${modelName} SW`);
+            spiceComponent = new SpiceComponent(component.name, switchCmd, [
+              drainNode,
+              gateNode,
+              sourceNode
+            ]);
+          }
+          break;
+        }
+      }
+      if (spiceComponent) {
+        netlist.addComponent(spiceComponent);
+      }
+    }
+  }
+  const simulationVoltageSources = su_default(circuitJson).simulation_voltage_source.list();
+  for (const simSource of simulationVoltageSources) {
+    if (simSource.type !== "simulation_voltage_source")
+      continue;
+    if (simSource.is_dc_source === false) {
+      if ("terminal1_source_port_id" in simSource && "terminal2_source_port_id" in simSource && simSource.terminal1_source_port_id && simSource.terminal2_source_port_id) {
+        const positiveNode = nodeMap.get(simSource.terminal1_source_port_id) || "0";
+        const negativeNode = nodeMap.get(simSource.terminal2_source_port_id) || "0";
+        let value = "";
+        const wave_shape = simSource.wave_shape;
+        if (wave_shape === "sinewave") {
+          const v_offset = 0;
+          const v_peak = simSource.voltage ?? 0;
+          const freq = simSource.frequency ?? 0;
+          const delay3 = 0;
+          const damping_factor = 0;
+          const phase = simSource.phase ?? 0;
+          if (freq > 0) {
+            value = `SIN(${v_offset} ${v_peak} ${freq} ${delay3} ${damping_factor} ${phase})`;
+          } else {
+            value = `DC ${simSource.voltage ?? 0}`;
+          }
+        } else if (wave_shape === "square") {
+          const v_initial = 0;
+          const v_pulsed = simSource.voltage ?? 0;
+          const freq = simSource.frequency ?? 0;
+          const period_from_freq = freq === 0 ? Infinity : 1 / freq;
+          const period = simSource.period ?? period_from_freq;
+          const duty_cycle = simSource.duty_cycle ?? 0.5;
+          const pulse_width = period * duty_cycle;
+          const delay3 = 0;
+          const rise_time = "1n";
+          const fall_time = "1n";
+          value = `PULSE(${v_initial} ${v_pulsed} ${delay3} ${rise_time} ${fall_time} ${pulse_width} ${period})`;
+        } else if (simSource.voltage !== undefined) {
+          value = `DC ${simSource.voltage}`;
+        }
+        if (value) {
+          const voltageSourceCmd = new VoltageSourceCommand({
+            name: simSource.simulation_voltage_source_id,
+            positiveNode,
+            negativeNode,
+            value
+          });
+          const spiceComponent = new SpiceComponent(simSource.simulation_voltage_source_id, voltageSourceCmd, [positiveNode, negativeNode]);
+          netlist.addComponent(spiceComponent);
+        }
+      }
+    } else {
+      const positivePortId = simSource.positive_source_port_id ?? simSource.terminal1_source_port_id;
+      const negativePortId = simSource.negative_source_port_id ?? simSource.terminal2_source_port_id;
+      if (positivePortId && negativePortId && "voltage" in simSource && simSource.voltage !== undefined) {
+        const positiveNode = nodeMap.get(positivePortId) || "0";
+        const negativeNode = nodeMap.get(negativePortId) || "0";
+        const voltageSourceCmd = new VoltageSourceCommand({
+          name: simSource.simulation_voltage_source_id,
+          positiveNode,
+          negativeNode,
+          value: `DC ${simSource.voltage}`
+        });
+        const spiceComponent = new SpiceComponent(simSource.simulation_voltage_source_id, voltageSourceCmd, [positiveNode, negativeNode]);
+        netlist.addComponent(spiceComponent);
+      }
+    }
+  }
+  return netlist;
+}
+function formatResistance(resistance) {
+  if (resistance >= 1e6)
+    return `${resistance / 1e6}MEG`;
+  if (resistance >= 1000)
+    return `${resistance / 1000}K`;
+  return resistance.toString();
+}
+function formatCapacitance(capacitance) {
+  if (capacitance >= 0.001)
+    return `${capacitance * 1000}M`;
+  if (capacitance >= 0.000001)
+    return `${capacitance * 1e6}U`;
+  if (capacitance >= 0.000000001)
+    return `${capacitance * 1e9}N`;
+  if (capacitance >= 0.000000000001)
+    return `${capacitance * 1000000000000}P`;
+  return capacitance.toString();
+}
+function formatInductance(inductance) {
+  if (inductance >= 1)
+    return inductance.toString();
+  if (inductance >= 0.001)
+    return `${inductance * 1000}m`;
+  if (inductance >= 0.000001)
+    return `${inductance * 1e6}u`;
+  if (inductance >= 0.000000001)
+    return `${inductance * 1e9}n`;
+  if (inductance >= 0.000000000001)
+    return `${inductance * 1000000000000}p`;
+  return inductance.toString();
+}
+
+// lib/shared/get-spice-with-sim.ts
+var formatSimTime = (seconds) => {
+  if (seconds === 0)
+    return "0";
+  const absSeconds = Math.abs(seconds);
+  const precision = (v) => v.toPrecision(4);
+  if (absSeconds >= 1)
+    return precision(seconds);
+  if (absSeconds >= 0.001)
+    return `${precision(seconds * 1000)}m`;
+  if (absSeconds >= 0.000001)
+    return `${precision(seconds * 1e6)}u`;
+  if (absSeconds >= 0.000000001)
+    return `${precision(seconds * 1e9)}n`;
+  if (absSeconds >= 0.000000000001)
+    return `${precision(seconds * 1000000000000)}p`;
+  if (absSeconds >= 0.000000000000001)
+    return `${precision(seconds * 1000000000000000)}f`;
+  return seconds.toExponential(3);
+};
+var getSpiceWithPaddedSim = (circuitJson, options) => {
+  const spiceNetlist = circuitJsonToSpice(circuitJson);
+  const baseSpiceString = spiceNetlist.toSpiceString();
+  const hasAnalysis = /\.tran|\.ac|\.dc|\.op/i.test(baseSpiceString);
+  const hasOutput = /\.probe|\.plot|wrdata/i.test(baseSpiceString);
+  const lines = baseSpiceString.split(`
+`).filter((l) => l.trim() !== "");
+  const componentLines = lines.filter((l) => !l.startsWith("*") && !l.startsWith(".") && l.trim() !== "");
+  const allNodes = new Set;
+  const capacitorNodes = new Set;
+  const componentNamesToProbeCurrent = new Set;
+  for (const line of componentLines) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 3)
+      continue;
+    const componentName = parts[0];
+    const componentType = componentName[0].toUpperCase();
+    let nodesOnLine = [];
+    if (["R", "C", "L", "V", "I", "D"].includes(componentType)) {
+      nodesOnLine = parts.slice(1, 3);
+      if (componentType === "V") {
+        componentNamesToProbeCurrent.add(componentName);
+      }
+    } else if (componentType === "Q" && parts.length >= 4) {
+      nodesOnLine = parts.slice(1, 4);
+    } else if (componentType === "M" && parts.length >= 5) {
+      nodesOnLine = parts.slice(1, 5);
+    } else if (componentType === "X") {
+      nodesOnLine = parts.slice(1, -1);
+    } else {
+      continue;
+    }
+    nodesOnLine.forEach((node) => allNodes.add(node));
+    if (componentType === "C") {
+      nodesOnLine.forEach((node) => capacitorNodes.add(node));
+    }
+  }
+  allNodes.delete("0");
+  capacitorNodes.delete("0");
+  const icLines = Array.from(capacitorNodes).map((node) => `.ic V(${node})=0`);
+  let probeLine = "";
+  if (!hasOutput) {
+    const probes = [];
+    const probeVoltages = Array.from(allNodes).map((node) => `V(${node})`);
+    probes.push(...probeVoltages);
+    const probeCurrents = Array.from(componentNamesToProbeCurrent).map((name) => `I(${name})`);
+    probes.push(...probeCurrents);
+    probeLine = probes.length > 0 ? `.probe ${probes.join(" ")}` : "";
+  }
+  let tranLine = "";
+  if (!hasAnalysis) {
+    const tstart_ms = options?.startTime ?? 0;
+    const duration_ms = options?.duration ?? 20;
+    const tstart = tstart_ms * 0.001;
+    const duration = duration_ms * 0.001;
+    const tstop = tstart + duration;
+    const tstep = duration / 50;
+    tranLine = `.tran ${formatSimTime(tstep)} ${formatSimTime(tstop)} ${formatSimTime(tstart)} UIC`;
+  }
+  const endStatement = ".end";
+  const originalLines = baseSpiceString.split(`
+`);
+  let endIndex = -1;
+  for (let i = originalLines.length - 1;i >= 0; i--) {
+    if (originalLines[i].trim().toLowerCase().startsWith(endStatement)) {
+      endIndex = i;
+      break;
+    }
+  }
+  const injectionLines = [
+    ...icLines.length > 0 && !/\.ic/i.test(baseSpiceString) ? icLines : [],
+    probeLine,
+    tranLine
+  ].filter(Boolean);
+  if (injectionLines.length === 0) {
+    return baseSpiceString;
+  }
+  let finalLines;
+  if (endIndex !== -1) {
+    const beforeEnd = originalLines.slice(0, endIndex);
+    const endLineAndAfter = originalLines.slice(endIndex);
+    finalLines = [...beforeEnd, ...injectionLines, ...endLineAndAfter];
+  } else {
+    finalLines = [...originalLines, ...injectionLines, endStatement];
+  }
+  return finalLines.join(`
+`);
+};
+
+// lib/eecircuit-engine/run-simulation.ts
+import { promises as fs23, existsSync as existsSync9 } from "node:fs";
+import path23 from "node:path";
+import os3 from "node:os";
+var sim = null;
+var fetchSimulation = async () => {
+  const tempFilePath = path23.join(os3.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  if (!existsSync9(tempFilePath)) {
+    const url = "https://cdn.jsdelivr.net/npm/eecircuit-engine@1.5.2/+esm";
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch eecircuit-engine from ${url}: ${response.statusText}`);
+    }
+    const scriptContent = await response.text();
+    await fs23.writeFile(tempFilePath, scriptContent);
+  }
+  const module2 = await import(tempFilePath);
+  return module2.Simulation;
+};
+var initializeSimulation = async () => {
+  if (sim && sim.isInitialized())
+    return;
+  const Simulation = await fetchSimulation();
+  sim = new Simulation;
+  sim.start();
+  const startTime = Date.now();
+  const timeout2 = 15000;
+  while (!sim.isInitialized()) {
+    if (Date.now() - startTime > timeout2) {
+      console.error("Error: Simulation engine initialization timed out.");
+      const initInfo = sim.getInitInfo();
+      if (initInfo) {
+        console.error("Initialization Info:", initInfo);
+      }
+      const errors = sim.getError();
+      if (errors && errors.length > 0) {
+        console.error("Errors:", errors.join(`
+`));
+      }
+      throw new Error("Simulation engine initialization timed out.");
+    }
+    await new Promise((resolve10) => setTimeout(resolve10, 200));
+  }
+};
+var runSimulation = async (spiceString) => {
+  await initializeSimulation();
+  if (!sim)
+    throw new Error("Simulation not initialized");
+  let engineSpiceString = spiceString;
+  const wrdataMatch = engineSpiceString.match(/wrdata\s+(\S+)\s+(.*)/i);
+  if (wrdataMatch) {
+    const variables = wrdataMatch[2].trim().split(/\s+/);
+    const probeLine = `.probe ${variables.join(" ")}`;
+    engineSpiceString = engineSpiceString.replace(/wrdata.*/i, probeLine);
+  } else if (!engineSpiceString.match(/\.probe/i)) {
+    const plotMatch = engineSpiceString.match(/plot\s+(.*)/i);
+    if (plotMatch) {
+      throw new Error("The 'plot' command is not supported for data extraction. Please use 'wrdata <filename> <var1> ...' or '.probe <var1> ...' instead.");
+    }
+    throw new Error("No '.probe' or 'wrdata' command found in SPICE file. Use 'wrdata <filename> <var1> ...' to specify output.");
+  }
+  sim.setNetList(engineSpiceString);
+  const result = await sim.runSim();
+  return {
+    result,
+    info: sim.getInfo(),
+    errors: sim.getError()
+  };
+};
+
+// lib/shared/result-to-csv.ts
+var resultToCsv = (result) => {
+  const uniqueHeaders = [];
+  const uniqueData = [];
+  const seenHeaders = new Set;
+  result.variableNames.forEach((header, index) => {
+    if (!seenHeaders.has(header)) {
+      seenHeaders.add(header);
+      uniqueHeaders.push(header);
+      uniqueData.push(result.data[index]);
+    }
+  });
+  if (result.dataType === "real") {
+    const headers2 = uniqueHeaders.join(",");
+    const rows2 = [];
+    for (let i = 0;i < result.numPoints; i++) {
+      const row = uniqueData.map((d) => d.values[i]).join(",");
+      rows2.push(row);
+    }
+    return [headers2, ...rows2].join(`
+`);
+  }
+  const headers = uniqueHeaders.flatMap((v) => [`${v}_real`, `${v}_img`]).join(",");
+  const rows = [];
+  for (let i = 0;i < result.numPoints; i++) {
+    const row = uniqueData.flatMap((d) => [d.values[i].real, d.values[i].img]).join(",");
+    rows.push(row);
+  }
+  return [headers, ...rows].join(`
+`);
+};
+
 // cli/export/register.ts
+import path24 from "node:path";
+import { promises as fs24 } 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").option("-o, --output <path>", "Output file path").action(async (file, options) => {
+    const format = options.format ?? "json";
+    if (format === "spice") {
+      const { circuitJson } = await generateCircuitJson({ filePath: file });
+      if (circuitJson) {
+        const spiceString = getSpiceWithPaddedSim(circuitJson);
+        const outputSpicePath = options.output ?? path24.join(path24.dirname(file), `${path24.basename(file, path24.extname(file))}.spice.cir`);
+        await fs24.writeFile(outputSpicePath, spiceString);
+        const { result } = await runSimulation(spiceString);
+        const csvContent = resultToCsv(result);
+        const outputCsvPath = outputSpicePath.replace(/\.spice\.cir$/, ".csv");
+        await fs24.writeFile(outputCsvPath, csvContent);
+        console.log(`Exported to ${outputSpicePath} and ${outputCsvPath} (simulation results)!`);
+      }
+      return;
+    }
     await exportSnippet({
       filePath: file,
-      format: options.format ?? "json",
+      format,
       outputPath: options.output,
       onExit: (code) => process.exit(code),
       onError: (message) => console.error(message),
@@ -71774,14 +72443,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path23 = null;
+  let path25 = null;
   let id = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString2(key) || isArray(key)) {
     src = key;
-    path23 = createKeyPath(key);
+    path25 = createKeyPath(key);
     id = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -71795,11 +72464,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path23 = createKeyPath(name);
+    path25 = createKeyPath(name);
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path23, id, weight, src, getFn };
+  return { path: path25, id, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -71807,34 +72476,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path23) {
+function get(obj, path25) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path24, index) => {
+  const deepGet = (obj2, path26, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path24[index]) {
+    if (!path26[index]) {
       list.push(obj2);
     } else {
-      let key = path24[index];
+      let key = path26[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path24.length - 1 && (isString2(value) || isNumber(value) || isBoolean(value))) {
+      if (index === path26.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], path24, index + 1);
+          deepGet(value[i], path26, index + 1);
         }
-      } else if (path24.length) {
-        deepGet(value, path24, index + 1);
+      } else if (path26.length) {
+        deepGet(value, path26, index + 1);
       }
     }
   };
-  deepGet(obj, isString2(path23) ? path23.split(".") : path23, 0);
+  deepGet(obj, isString2(path25) ? path25.split(".") : path25, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -73026,8 +73695,8 @@ var registerSearch = (program3) => {
     }
     if (kicadResults.length) {
       console.log(kleur_default.bold().underline(`Found ${kicadResults.length} footprint(s) from KiCad:`));
-      kicadResults.forEach((path23, idx) => {
-        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path23.replace(".kicad_mod", "").replace(".pretty", "")}`);
+      kicadResults.forEach((path25, idx) => {
+        console.log(`${(idx + 1).toString().padStart(2, " ")}. kicad:${path25.replace(".kicad_mod", "").replace(".pretty", "")}`);
       });
     }
     if (!onlyKicad && results.packages.length) {
@@ -78185,7 +78854,7 @@ var zo = rs.find((t2) => t2.text === "{REF}");
 zo.y = 0;
 zo.x = 0.35;
 zo.anchor = "middle_left";
-var os3 = es;
+var os4 = es;
 var is = { paths: { path11: { type: "path", points: [{ x: -0.39, y: 0 }, { x: 0.06, y: -0.01 }], color: "primary", fill: false }, path40: { type: "path", points: [{ x: 0.07, y: 0.19 }, { x: 0.07, y: -0.18 }], color: "primary", fill: false }, "path12-1": { type: "path", points: [{ x: 0.28, y: 0.53 }, { x: 0.28, y: 0.11 }], color: "primary", fill: false }, "path12-1-5": { type: "path", points: [{ x: 0.29, y: -0.53 }, { x: 0.29, y: -0.1 }], color: "primary", fill: false }, path2: { type: "path", points: [{ x: 0.07, y: 0.11 }, { x: 0.29, y: 0.11 }], color: "primary", fill: false }, "path2-5": { type: "path", points: [{ x: 0.07, y: -0.1 }, { x: 0.29, y: -0.1 }], color: "primary", fill: false }, path15: { type: "path", points: [{ x: -0.08, y: 0.06 }, { x: -0.08, y: -0.07 }, { x: 0.01, y: 0 }, { x: -0.08, y: 0.06 }], color: "primary", fill: true } }, texts: { top1: { type: "text", text: "{REF}", x: -0.15, y: 0.36 }, bottom1: { type: "text", text: "{VAL}", x: 0.04, y: -0.42 } }, refblocks: { top1: { x: 0.28, 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: { type: "circle", x: 0.14, y: 0, radius: 0.29, color: "primary", fill: false } } };
 var { paths: ud, texts: ls, bounds: Ke, refblocks: Oo, circles: vd } = is;
 var t0 = s({ primitives: [...Object.values(ud), ...Object.values(vd), { ...ls.top1, anchor: "middle_right", x: 0 }, { ...ls.bottom1, anchor: "middle_right", x: 0 }], ports: [{ ...Oo.top1, labels: ["1", "drain"] }, { ...Oo.bottom1, labels: ["2", "source"] }, { ...Oo.left1, labels: ["3", "gate"] }], size: { width: Ke.width, height: Ke.height }, center: { x: Ke.centerX, y: Ke.centerY } });
@@ -78205,7 +78874,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 fs23 = r(U, "up");
+var fs25 = 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();
@@ -78774,7 +79443,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: At, 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: os3, njfet_transistor_horz: t0, njfet_transistor_vert: ys, not_connected_down: ms, not_connected_left: ns, not_connected_right: U, not_connected_up: fs23, 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: At, 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: os4, njfet_transistor_horz: t0, njfet_transistor_vert: ys, not_connected_down: ms, not_connected_left: ns, not_connected_right: U, not_connected_up: fs25, 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
@@ -80804,11 +81473,11 @@ var require_react_reconciler_development = __commonJS2({
           fiber = fiber.next, id2--;
         return fiber;
       }
-      function copyWithSetImpl(obj, path23, index, value) {
-        if (index >= path23.length)
+      function copyWithSetImpl(obj, path25, index, value) {
+        if (index >= path25.length)
           return value;
-        var key = path23[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        updated[key] = copyWithSetImpl(obj[key], path23, index + 1, value);
+        var key = path25[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        updated[key] = copyWithSetImpl(obj[key], path25, index + 1, value);
         return updated;
       }
       function copyWithRename(obj, oldPath, newPath) {
@@ -80828,11 +81497,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, path23, index) {
-        var key = path23[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-        if (index + 1 === path23.length)
+      function copyWithDeleteImpl(obj, path25, index) {
+        var key = path25[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+        if (index + 1 === path25.length)
           return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-        updated[key] = copyWithDeleteImpl(obj[key], path23, index + 1);
+        updated[key] = copyWithDeleteImpl(obj[key], path25, index + 1);
         return updated;
       }
       function shouldSuspendImpl() {
@@ -89863,29 +90532,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, path23, value) {
+      overrideHookState = function(fiber, id2, path25, value) {
         id2 = findHook(fiber, id2);
-        id2 !== null && (path23 = copyWithSetImpl(id2.memoizedState, path23, 0, value), id2.memoizedState = path23, id2.baseState = path23, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path23 = enqueueConcurrentRenderForLane(fiber, 2), path23 !== null && scheduleUpdateOnFiber(path23, fiber, 2));
+        id2 !== null && (path25 = copyWithSetImpl(id2.memoizedState, path25, 0, value), id2.memoizedState = path25, id2.baseState = path25, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path25 = enqueueConcurrentRenderForLane(fiber, 2), path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2));
       };
-      overrideHookStateDeletePath = function(fiber, id2, path23) {
+      overrideHookStateDeletePath = function(fiber, id2, path25) {
         id2 = findHook(fiber, id2);
-        id2 !== null && (path23 = copyWithDeleteImpl(id2.memoizedState, path23, 0), id2.memoizedState = path23, id2.baseState = path23, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path23 = enqueueConcurrentRenderForLane(fiber, 2), path23 !== null && scheduleUpdateOnFiber(path23, fiber, 2));
+        id2 !== null && (path25 = copyWithDeleteImpl(id2.memoizedState, path25, 0), id2.memoizedState = path25, id2.baseState = path25, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path25 = enqueueConcurrentRenderForLane(fiber, 2), path25 !== null && scheduleUpdateOnFiber(path25, 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, path23, value) {
-        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path23, 0, value);
+      overrideProps = function(fiber, path25, value) {
+        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path25, 0, value);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path23 = enqueueConcurrentRenderForLane(fiber, 2);
-        path23 !== null && scheduleUpdateOnFiber(path23, fiber, 2);
+        path25 = enqueueConcurrentRenderForLane(fiber, 2);
+        path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2);
       };
-      overridePropsDeletePath = function(fiber, path23) {
-        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path23, 0);
+      overridePropsDeletePath = function(fiber, path25) {
+        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path25, 0);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path23 = enqueueConcurrentRenderForLane(fiber, 2);
-        path23 !== null && scheduleUpdateOnFiber(path23, fiber, 2);
+        path25 = enqueueConcurrentRenderForLane(fiber, 2);
+        path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2);
       };
       overridePropsRenamePath = function(fiber, oldPath, newPath) {
         fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -105222,10 +105891,10 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
         var setErrorHandler = null;
         var setSuspenseHandler = null;
         {
-          var copyWithDeleteImpl = function(obj, path23, index2) {
-            var key = path23[index2];
+          var copyWithDeleteImpl = function(obj, path25, index2) {
+            var key = path25[index2];
             var updated = isArray2(obj) ? obj.slice() : assign2({}, obj);
-            if (index2 + 1 === path23.length) {
+            if (index2 + 1 === path25.length) {
               if (isArray2(updated)) {
                 updated.splice(key, 1);
               } else {
@@ -105233,11 +105902,11 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               }
               return updated;
             }
-            updated[key] = copyWithDeleteImpl(obj[key], path23, index2 + 1);
+            updated[key] = copyWithDeleteImpl(obj[key], path25, index2 + 1);
             return updated;
           };
-          var copyWithDelete = function(obj, path23) {
-            return copyWithDeleteImpl(obj, path23, 0);
+          var copyWithDelete = function(obj, path25) {
+            return copyWithDeleteImpl(obj, path25, 0);
           };
           var copyWithRenameImpl = function(obj, oldPath, newPath, index2) {
             var oldKey = oldPath[index2];
@@ -105269,17 +105938,17 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
             }
             return copyWithRenameImpl(obj, oldPath, newPath, 0);
           };
-          var copyWithSetImpl = function(obj, path23, index2, value) {
-            if (index2 >= path23.length) {
+          var copyWithSetImpl = function(obj, path25, index2, value) {
+            if (index2 >= path25.length) {
               return value;
             }
-            var key = path23[index2];
+            var key = path25[index2];
             var updated = isArray2(obj) ? obj.slice() : assign2({}, obj);
-            updated[key] = copyWithSetImpl(obj[key], path23, index2 + 1, value);
+            updated[key] = copyWithSetImpl(obj[key], path25, index2 + 1, value);
             return updated;
           };
-          var copyWithSet = function(obj, path23, value) {
-            return copyWithSetImpl(obj, path23, 0, value);
+          var copyWithSet = function(obj, path25, value) {
+            return copyWithSetImpl(obj, path25, 0, value);
           };
           var findHook = function(fiber, id2) {
             var currentHook2 = fiber.memoizedState;
@@ -105289,10 +105958,10 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
             }
             return currentHook2;
           };
-          overrideHookState = function(fiber, id2, path23, value) {
+          overrideHookState = function(fiber, id2, path25, value) {
             var hook = findHook(fiber, id2);
             if (hook !== null) {
-              var newState = copyWithSet(hook.memoizedState, path23, value);
+              var newState = copyWithSet(hook.memoizedState, path25, value);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign2({}, fiber.memoizedProps);
@@ -105302,10 +105971,10 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               }
             }
           };
-          overrideHookStateDeletePath = function(fiber, id2, path23) {
+          overrideHookStateDeletePath = function(fiber, id2, path25) {
             var hook = findHook(fiber, id2);
             if (hook !== null) {
-              var newState = copyWithDelete(hook.memoizedState, path23);
+              var newState = copyWithDelete(hook.memoizedState, path25);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign2({}, fiber.memoizedProps);
@@ -105328,8 +105997,8 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               }
             }
           };
-          overrideProps = function(fiber, path23, value) {
-            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path23, value);
+          overrideProps = function(fiber, path25, value) {
+            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path25, value);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -105338,8 +106007,8 @@ Check the render method of %s.`, getComponentNameFromFiber(current2) || "Unknown
               scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
             }
           };
-          overridePropsDeletePath = function(fiber, path23) {
-            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path23);
+          overridePropsDeletePath = function(fiber, path25) {
+            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path25);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -111390,7 +112059,7 @@ var parsePin = (pinString) => {
   const colorMatch = pinString.match(/#[0-9A-F]{6}/);
   const labelColor = colorMatch ? colorMatch[0] : "";
   const pathMatch = pinString.match(/\^\^([^~]+)/);
-  const path23 = pathMatch ? pathMatch[1] : "";
+  const path25 = pathMatch ? pathMatch[1] : "";
   const arrowMatch = pinString.match(/\^\^0~(.+)$/);
   const arrow = arrowMatch ? arrowMatch[1] : "";
   const r3 = Number.parseFloat(rotation2);
@@ -111404,7 +112073,7 @@ var parsePin = (pinString) => {
     rotation: Number.isNaN(r3) ? 0 : r3,
     label,
     labelColor,
-    path: path23,
+    path: path25,
     arrow
   };
 };
@@ -111844,15 +112513,15 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
     }
   }
   const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
-  const path23 = [];
+  const path25 = [];
   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);
-    path23.push({ x, y });
+    path25.push({ x, y });
   }
-  return path23;
+  return path25;
 }
 var __defProp4 = Object.defineProperty;
 var __export22 = (target, all) => {
@@ -113270,7 +113939,7 @@ var platedHoleWithRectPad = (pn2, x, y, holeDiameter, rectPadWidth, rectPadHeigh
   };
 };
 var silkscreenPin = ({
-  fs: fs24,
+  fs: fs26,
   pn: pn2,
   anchor_x,
   anchor_y,
@@ -113313,7 +113982,7 @@ var silkscreenPin = ({
     type: "pcb_silkscreen_text",
     pcb_silkscreen_text_id: "silkscreen_text_1",
     font: "tscircuit2024",
-    font_size: fs24,
+    font_size: fs26,
     pcb_component_id: "pcb_component_1",
     text: `{PIN${pn2}}`,
     layer,
@@ -120929,17 +121598,17 @@ var ObstacleList = class {
     return obstacles;
   }
 };
-function removePathLoops(path23) {
-  if (path23.length < 4)
-    return path23;
-  const result = [{ ...path23[0] }];
-  let currentLayer = path23[0].layer;
-  for (let i = 1;i < path23.length; i++) {
-    const currentSegment = { start: path23[i - 1], end: path23[i] };
-    const isVia = path23[i].route_type === "via" || path23[i - 1].route_type === "via";
-    if (path23[i].layer !== currentLayer || isVia) {
-      result.push({ ...path23[i] });
-      currentLayer = path23[i].layer;
+function removePathLoops(path25) {
+  if (path25.length < 4)
+    return path25;
+  const result = [{ ...path25[0] }];
+  let currentLayer = path25[0].layer;
+  for (let i = 1;i < path25.length; i++) {
+    const currentSegment = { start: path25[i - 1], end: path25[i] };
+    const isVia = path25[i].route_type === "via" || path25[i - 1].route_type === "via";
+    if (path25[i].layer !== currentLayer || isVia) {
+      result.push({ ...path25[i] });
+      currentLayer = path25[i].layer;
       continue;
     }
     let intersectionFound = false;
@@ -120968,8 +121637,8 @@ function removePathLoops(path23) {
       result.push(intersectionPoint);
     }
     const lastPoint = result[result.length - 1];
-    if (lastPoint.x !== path23[i].x || lastPoint.y !== path23[i].y) {
-      result.push(path23[i]);
+    if (lastPoint.x !== path25[i].x || lastPoint.y !== path25[i].y) {
+      result.push(path25[i]);
     }
   }
   return result;
@@ -121458,10 +122127,10 @@ var GeneralizedAstarAutorouter = class {
       });
     }
     if (current2.parent) {
-      const path23 = [];
+      const path25 = [];
       let p = current2;
       while (p) {
-        path23.unshift(p);
+        path25.unshift(p);
         p = p.parent;
       }
       debugSolution.push({
@@ -121469,7 +122138,7 @@ var GeneralizedAstarAutorouter = class {
         pcb_component_id: "",
         pcb_fabrication_note_path_id: `note_path_${current2.x}_${current2.y}`,
         layer: "top",
-        route: path23,
+        route: path25,
         stroke_width: 0.01
       });
     }
@@ -126391,13 +127060,13 @@ var RBush = class {
       return this;
     let node = this.data;
     const bbox = this.toBBox(item);
-    const path23 = [];
+    const path25 = [];
     const indexes = [];
     let i, parent, goingUp;
-    while (node || path23.length) {
+    while (node || path25.length) {
       if (!node) {
-        node = path23.pop();
-        parent = path23[path23.length - 1];
+        node = path25.pop();
+        parent = path25[path25.length - 1];
         i = indexes.pop();
         goingUp = true;
       }
@@ -126405,13 +127074,13 @@ var RBush = class {
         const index = findItem(item, node.children, equalsFn);
         if (index !== -1) {
           node.children.splice(index, 1);
-          path23.push(node);
-          this._condense(path23);
+          path25.push(node);
+          this._condense(path25);
           return this;
         }
       }
       if (!goingUp && !node.leaf && contains(node, bbox)) {
-        path23.push(node);
+        path25.push(node);
         indexes.push(i);
         i = 0;
         parent = node;
@@ -126482,10 +127151,10 @@ var RBush = class {
     calcBBox(node, this.toBBox);
     return node;
   }
-  _chooseSubtree(bbox, node, level, path23) {
+  _chooseSubtree(bbox, node, level, path25) {
     while (true) {
-      path23.push(node);
-      if (node.leaf || path23.length - 1 === level)
+      path25.push(node);
+      if (node.leaf || path25.length - 1 === level)
         break;
       let minArea = Infinity;
       let minEnlargement = Infinity;
@@ -126594,21 +127263,21 @@ var RBush = class {
     }
     return margin;
   }
-  _adjustParentBBoxes(bbox, path23, level) {
+  _adjustParentBBoxes(bbox, path25, level) {
     for (let i = level;i >= 0; i--) {
-      extend(path23[i], bbox);
+      extend(path25[i], bbox);
     }
   }
-  _condense(path23) {
-    for (let i = path23.length - 1, siblings;i >= 0; i--) {
-      if (path23[i].children.length === 0) {
+  _condense(path25) {
+    for (let i = path25.length - 1, siblings;i >= 0; i--) {
+      if (path25[i].children.length === 0) {
         if (i > 0) {
-          siblings = path23[i - 1].children;
-          siblings.splice(siblings.indexOf(path23[i]), 1);
+          siblings = path25[i - 1].children;
+          siblings.splice(siblings.indexOf(path25[i]), 1);
         } else
           this.clear();
       } else
-        calcBBox(path23[i], this.toBBox);
+        calcBBox(path25[i], this.toBBox);
     }
   }
 };
@@ -127753,7 +128422,7 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
     this.capacityPaths = capacityPaths;
     this.colorMap = colorMap ?? {};
     this.unprocessedNodeIds = [
-      ...new Set(capacityPaths.flatMap((path23) => path23.nodeIds))
+      ...new Set(capacityPaths.flatMap((path25) => path25.nodeIds))
     ];
     this.nodePortSegments = /* @__PURE__ */ new Map;
   }
@@ -127764,17 +128433,17 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
       return;
     }
     const pathsGoingThroughNode = [];
-    for (const path23 of this.capacityPaths) {
-      const indexOfNodeInPath = path23.nodeIds.indexOf(nodeId);
+    for (const path25 of this.capacityPaths) {
+      const indexOfNodeInPath = path25.nodeIds.indexOf(nodeId);
       if (indexOfNodeInPath !== -1) {
-        pathsGoingThroughNode.push({ path: path23, indexOfNodeInPath });
+        pathsGoingThroughNode.push({ path: path25, indexOfNodeInPath });
       }
     }
     const node = this.nodeMap.get(nodeId);
     const nodePortSegments = [];
-    for (const { path: path23, indexOfNodeInPath } of pathsGoingThroughNode) {
-      const entryNodeId = path23.nodeIds[indexOfNodeInPath - 1];
-      const exitNodeId = path23.nodeIds[indexOfNodeInPath + 1];
+    for (const { path: path25, indexOfNodeInPath } of pathsGoingThroughNode) {
+      const entryNodeId = path25.nodeIds[indexOfNodeInPath - 1];
+      const exitNodeId = path25.nodeIds[indexOfNodeInPath + 1];
       for (const adjNodeId of [entryNodeId, exitNodeId]) {
         const adjNode = this.nodeMap.get(adjNodeId);
         if (!adjNode)
@@ -127787,7 +128456,7 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
           capacityMeshNodeId: nodeId,
           start: segment2.start,
           end: segment2.end,
-          connectionNames: [path23.connectionName],
+          connectionNames: [path25.connectionName],
           availableZ: mutuallyAvailableZ
         };
         nodePortSegments.push(portSegment);
@@ -128593,37 +129262,37 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     return neighbors;
   }
   getNodePath(node) {
-    const path23 = [];
+    const path25 = [];
     while (node) {
-      path23.push(node);
+      path25.push(node);
       node = node.parent;
     }
-    return path23;
+    return path25;
   }
   getViasInNodePath(node) {
-    const path23 = this.getNodePath(node);
+    const path25 = this.getNodePath(node);
     const vias = [];
-    for (let i = 0;i < path23.length - 1; i++) {
-      if (path23[i].z !== path23[i + 1].z) {
-        vias.push({ x: path23[i].x, y: path23[i].y });
+    for (let i = 0;i < path25.length - 1; i++) {
+      if (path25[i].z !== path25[i + 1].z) {
+        vias.push({ x: path25[i].x, y: path25[i].y });
       }
     }
     return vias;
   }
   setSolvedPath(node) {
-    const path23 = this.getNodePath(node);
-    path23.reverse();
+    const path25 = this.getNodePath(node);
+    path25.reverse();
     const vias = [];
-    for (let i = 0;i < path23.length - 1; i++) {
-      if (path23[i].z !== path23[i + 1].z) {
-        vias.push({ x: path23[i].x, y: path23[i].y });
+    for (let i = 0;i < path25.length - 1; i++) {
+      if (path25[i].z !== path25[i + 1].z) {
+        vias.push({ x: path25[i].x, y: path25[i].y });
       }
     }
     this.solvedPath = {
       connectionName: this.connectionName,
       traceThickness: this.traceThickness,
       viaDiameter: this.viaDiameter,
-      route: path23.map((node2) => ({ x: node2.x, y: node2.y, z: node2.z })).concat([this.B]),
+      route: path25.map((node2) => ({ x: node2.x, y: node2.y, z: node2.z })).concat([this.B]),
       vias
     };
   }
@@ -129362,14 +130031,14 @@ function computeDumbbellPaths({
     const u3 = (dx2 * d1y - dy2 * d1x) / det;
     return t3 > 0 && t3 < 1 && u3 > 0 && u3 < 1;
   };
-  const doPathsIntersect = (path1, path23) => {
+  const doPathsIntersect = (path1, path25) => {
     const segments1 = [];
     for (let i = 0;i < path1.length - 1; i++) {
       segments1.push({ start: path1[i], end: path1[i + 1] });
     }
     const segments2 = [];
-    for (let i = 0;i < path23.length - 1; i++) {
-      segments2.push({ start: path23[i], end: path23[i + 1] });
+    for (let i = 0;i < path25.length - 1; i++) {
+      segments2.push({ start: path25[i], end: path25[i + 1] });
     }
     for (const seg1 of segments1) {
       for (const seg2 of segments2) {
@@ -129431,12 +130100,12 @@ function computeDumbbellPaths({
       specialType: circleCenter === A3 ? "A" : "B"
     };
   };
-  const subdivideOptimalPath = (path23, numSubdivisions) => {
-    if (path23.length < 2)
-      return path23;
-    const result = [path23[0]];
-    for (let i = 0;i < path23.length - 1; i++) {
-      const segment2 = { start: path23[i], end: path23[i + 1] };
+  const subdivideOptimalPath = (path25, numSubdivisions) => {
+    if (path25.length < 2)
+      return path25;
+    const result = [path25[0]];
+    for (let i = 0;i < path25.length - 1; i++) {
+      const segment2 = { start: path25[i], end: path25[i + 1] };
       const segmentMidpoint = {
         x: (segment2.start.x + segment2.end.x) / 2,
         y: (segment2.start.y + segment2.end.y) / 2
@@ -129498,7 +130167,7 @@ function computeDumbbellPaths({
         }
         subdivisionPoints.forEach((p) => result.push(p));
       }
-      result.push(path23[i + 1]);
+      result.push(path25[i + 1]);
     }
     if (result.length > 1) {
       const filteredResult = [result[0]];
@@ -129733,13 +130402,13 @@ function computeDumbbellPaths({
     ].map((l, index) => ({ ...l, index }));
   };
   const subdivideJLinePath = (jLine, oppositePoint, r3, m2, numSubdivisions) => {
-    const path23 = jLine.points;
-    if (path23.length < 2)
-      return path23;
+    const path25 = jLine.points;
+    if (path25.length < 2)
+      return path25;
     const minDistThreshold = r3 + m2;
-    const result = [path23[0]];
-    for (let i = 0;i < path23.length - 1; i++) {
-      const segment2 = { start: path23[i], end: path23[i + 1] };
+    const result = [path25[0]];
+    for (let i = 0;i < path25.length - 1; i++) {
+      const segment2 = { start: path25[i], end: path25[i + 1] };
       const distToOpposite = pointToSegmentDistance22(oppositePoint, segment2.start, segment2.end);
       if (distToOpposite < minDistThreshold) {
         const closestPt = closestPointOnSegment(segment2, oppositePoint);
@@ -129789,18 +130458,18 @@ function computeDumbbellPaths({
     const paths = getPaths();
     const validPaths = [];
     for (let i = 0;i < paths.length; i++) {
-      const path24 = paths[i];
-      const firstSeg = { start: path24[0], end: path24[1] };
+      const path26 = paths[i];
+      const firstSeg = { start: path26[0], end: path26[1] };
       const lastSeg = {
-        start: path24[path24.length - 2],
-        end: path24[path24.length - 1]
+        start: path26[path26.length - 2],
+        end: path26[path26.length - 1]
       };
-      const midSeg = { start: path24[3], end: path24[4] };
+      const midSeg = { start: path26[3], end: path26[4] };
       if (!intersect2(firstSeg, lastSeg) && !intersect2(firstSeg, midSeg) && !intersect2(lastSeg, midSeg)) {
         validPaths.push({
           index: i + 1,
-          path: path24,
-          length: pathLength(path24)
+          path: path26,
+          length: pathLength(path26)
         });
       }
     }
@@ -129808,26 +130477,26 @@ function computeDumbbellPaths({
       return { index: 0, path: [] };
     }
     const optimalPath2 = validPaths.sort((a, b3) => a.length - b3.length)[0];
-    const path23 = [...optimalPath2.path];
-    const firstPoint = path23[0];
-    const dist3 = distance3(firstPoint, path23[2]);
-    const dist4 = distance3(firstPoint, path23[3]);
+    const path25 = [...optimalPath2.path];
+    const firstPoint = path25[0];
+    const dist3 = distance3(firstPoint, path25[2]);
+    const dist4 = distance3(firstPoint, path25[3]);
     const closerIdx = dist3 < dist4 ? 2 : 3;
-    if (dist3 < distance3(firstPoint, path23[1]) || dist4 < distance3(firstPoint, path23[1])) {
-      path23.splice(1, closerIdx - 1);
+    if (dist3 < distance3(firstPoint, path25[1]) || dist4 < distance3(firstPoint, path25[1])) {
+      path25.splice(1, closerIdx - 1);
     }
-    const lastPoint = path23[path23.length - 1];
-    const distM3 = distance3(lastPoint, path23[path23.length - 3]);
-    const distM4 = distance3(lastPoint, path23[path23.length - 4]);
-    const closerLastIdx = distM3 < distM4 ? path23.length - 3 : path23.length - 4;
-    if (distM3 < distance3(lastPoint, path23[path23.length - 2]) || distM4 < distance3(lastPoint, path23[path23.length - 2])) {
-      path23.splice(closerLastIdx + 1, path23.length - closerLastIdx - 2);
+    const lastPoint = path25[path25.length - 1];
+    const distM3 = distance3(lastPoint, path25[path25.length - 3]);
+    const distM4 = distance3(lastPoint, path25[path25.length - 4]);
+    const closerLastIdx = distM3 < distM4 ? path25.length - 3 : path25.length - 4;
+    if (distM3 < distance3(lastPoint, path25[path25.length - 2]) || distM4 < distance3(lastPoint, path25[path25.length - 2])) {
+      path25.splice(closerLastIdx + 1, path25.length - closerLastIdx - 2);
     }
     return {
       index: optimalPath2.index,
-      path: path23,
-      startsAt: path23[0] === C2 ? "C" : "D",
-      goesTo: path23[path23.length - 1] === C2 ? "C" : "D"
+      path: path25,
+      startsAt: path25[0] === C2 ? "C" : "D",
+      goesTo: path25[path25.length - 1] === C2 ? "C" : "D"
     };
   };
   const optimalPath = findOptimalPath();
@@ -131247,9 +131916,9 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
     let closestIntersection = null;
     let intersectedSegmentZ = null;
     const checkIntersectionsWithPathMap = (pathMap) => {
-      for (const path23 of pathMap.values()) {
-        for (let i = 0;i < path23.length - 1; i++) {
-          const segment2 = [path23[i], path23[i + 1]];
+      for (const path25 of pathMap.values()) {
+        for (let i = 0;i < path25.length - 1; i++) {
+          const segment2 = [path25[i], path25[i + 1]];
           if (segment2[0].x === segment2[1].x && segment2[0].y === segment2[1].y) {
             continue;
           }
@@ -131379,11 +132048,11 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
       });
     }
     const drawPath = (pathMap, labelPrefix) => {
-      for (const [connectionName, path23] of pathMap.entries()) {
+      for (const [connectionName, path25] of pathMap.entries()) {
         const color = colorMap[connectionName] ?? "black";
-        for (let i = 0;i < path23.length - 1; i++) {
-          const p12 = path23[i];
-          const p2 = path23[i + 1];
+        for (let i = 0;i < path25.length - 1; i++) {
+          const p12 = path25[i];
+          const p2 = path25[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 },
@@ -131981,10 +132650,10 @@ function detectMultiConnectionClosedFacesWithoutVias(polyLines, bounds) {
   const allSegments = [];
   const viaPoints = /* @__PURE__ */ new Map;
   for (const polyLine of polyLines) {
-    const path23 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
-    for (let i = 0;i < path23.length - 1; i++) {
-      const p12 = path23[i];
-      const p2 = path23[i + 1];
+    const path25 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
+    for (let i = 0;i < path25.length - 1; i++) {
+      const p12 = path25[i];
+      const p2 = path25[i + 1];
       const layer = p12.z2;
       allSegments.push({
         start: { x: p12.x, y: p12.y },
@@ -132002,7 +132671,7 @@ function detectMultiConnectionClosedFacesWithoutVias(polyLines, bounds) {
         }
       }
     }
-    const lastPoint = path23[path23.length - 1];
+    const lastPoint = path25[path25.length - 1];
     if (lastPoint.z1 !== lastPoint.z2) {
       const key = pointKey2(lastPoint);
       if (!viaPoints.has(key)) {
@@ -132301,14 +132970,14 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     const polyLineVias = [];
     for (let i = 0;i < polyLines.length; i++) {
       const polyLine = polyLines[i];
-      const path23 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
+      const path25 = [polyLine.start, ...polyLine.mPoints, polyLine.end];
       const segmentsByLayer = new Map(this.availableZ.map((z852) => [z852, []]));
-      for (let i22 = 0;i22 < path23.length - 1; i22++) {
-        const segment2 = [path23[i22], path23[i22 + 1]];
+      for (let i22 = 0;i22 < path25.length - 1; i22++) {
+        const segment2 = [path25[i22], path25[i22 + 1]];
         segmentsByLayer.get(segment2[0].z2).push(segment2);
       }
       polyLineSegmentsByLayer.push(segmentsByLayer);
-      polyLineVias.push(path23.filter((p) => p.z1 !== p.z2));
+      polyLineVias.push(path25.filter((p) => p.z1 !== p.z2));
     }
     for (let i = 0;i < polyLines.length; i++) {
       const path1SegmentsByLayer = polyLineSegmentsByLayer[i];
@@ -133737,7 +134406,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((fs24) => fs24.nodeWithPortPoints.capacityMeshNodeId)}. err0: ${this.failedSolvers[0].error}.`;
+        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs26) => fs26.nodeWithPortPoints.capacityMeshNodeId)}. err0: ${this.failedSolvers[0].error}.`;
         return;
       }
       this.solved = true;
@@ -136518,13 +137187,13 @@ var CapacityPathingSolver = class extends BaseSolver {
     return this.getDistanceBetweenNodes(node, endGoal);
   }
   getBacktrackedPath(candidate) {
-    const path23 = [];
+    const path25 = [];
     let currentCandidate = candidate;
     while (currentCandidate) {
-      path23.push(currentCandidate.node);
+      path25.push(currentCandidate.node);
       currentCandidate = currentCandidate.prevCandidate;
     }
-    return path23;
+    return path25;
   }
   getNeighboringNodes(node) {
     return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap((edge) => edge.nodeIds.filter((n3) => n3 !== node.capacityMeshNodeId)).map((n3) => this.nodeMap.get(n3));
@@ -136532,12 +137201,12 @@ var CapacityPathingSolver = class extends BaseSolver {
   getCapacityPaths() {
     const capacityPaths = [];
     for (const connection of this.connectionsWithNodes) {
-      const path23 = connection.path;
-      if (path23) {
+      const path25 = connection.path;
+      if (path25) {
         capacityPaths.push({
           capacityPathId: connection.connection.name,
           connectionName: connection.connection.name,
-          nodeIds: path23.map((node) => node.capacityMeshNodeId)
+          nodeIds: path25.map((node) => node.capacityMeshNodeId)
         });
       }
     }
@@ -137222,10 +137891,10 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
     return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
   }
   getBacktrackedPath(candidate) {
-    const path23 = [];
+    const path25 = [];
     let currentCandidate = candidate;
     while (currentCandidate) {
-      path23.push(currentCandidate.node);
+      path25.push(currentCandidate.node);
       if (this.nodeMap.has(currentCandidate.node.capacityMeshNodeId)) {
         currentCandidate = currentCandidate.prevCandidate;
       } else {
@@ -137233,7 +137902,7 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
         break;
       }
     }
-    return path23.reverse();
+    return path25.reverse();
   }
   getNeighboringNodes(node) {
     if (!this.nodeMap.has(node.capacityMeshNodeId))
@@ -137248,8 +137917,8 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   doesNodeHaveCapacityForTrace(node, prevNode) {
     return true;
   }
-  reduceCapacityAlongPath(path23) {
-    for (const pathNode of path23) {
+  reduceCapacityAlongPath(path25) {
+    for (const pathNode of path25) {
       if (this.usedNodeCapacityMap.has(pathNode.capacityMeshNodeId)) {
         const nodeId = pathNode.capacityMeshNodeId;
         const nodeInSection = this.nodeMap.get(nodeId);
@@ -137378,9 +138047,9 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
     this.queuedNodes = null;
   }
   _handleGoalReached(currentCandidate, currentTerminal, endNode) {
-    const path23 = this.getBacktrackedPath(currentCandidate);
-    currentTerminal.path = path23;
-    this.reduceCapacityAlongPath(path23);
+    const path25 = this.getBacktrackedPath(currentCandidate);
+    currentTerminal.path = path25;
+    this.reduceCapacityAlongPath(path25);
     this.currentConnectionIndex++;
     this.candidates = null;
     this.visitedNodes = null;
@@ -137429,10 +138098,10 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
       const connectionColor = this.colorMap[connectionName] ?? "purple";
       topCandidates.forEach((candidate, index) => {
         const opacity = 0.8 * (1 - index / 5);
-        const path23 = this.getBacktrackedPath(candidate);
-        if (path23.length > 0) {
+        const path25 = this.getBacktrackedPath(candidate);
+        if (path25.length > 0) {
           baseGraphics.lines.push({
-            points: path23.map(({ center: { x, y } }) => ({ x, y })),
+            points: path25.map(({ center: { x, y } }) => ({ x, y })),
             strokeColor: safeTransparentize(connectionColor, 1 - opacity),
             strokeWidth: 0.05
           });
@@ -138121,12 +138790,12 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   getCapacityPaths() {
     const capacityPaths = [];
     for (const connection of this.connectionsWithNodes) {
-      const path23 = connection.path;
-      if (path23) {
+      const path25 = connection.path;
+      if (path25) {
         capacityPaths.push({
           capacityPathId: connection.connection.name,
           connectionName: connection.connection.name,
-          nodeIds: path23.map((node) => node.capacityMeshNodeId)
+          nodeIds: path25.map((node) => node.capacityMeshNodeId)
         });
       }
     }
@@ -139147,22 +139816,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 path23 of possiblePaths) {
-      const fullPath = path23.map((p) => ({ x: p.x, y: p.y, z: start.z }));
+    for (const path25 of possiblePaths) {
+      const fullPath = path25.map((p) => ({ x: p.x, y: p.y, z: start.z }));
       if (this.isValidPath(fullPath)) {
         return fullPath;
       }
     }
     return null;
   }
-  addPathToResult(path23) {
-    if (path23.length === 0)
+  addPathToResult(path25) {
+    if (path25.length === 0)
       return;
-    for (let i = 0;i < path23.length; i++) {
-      if (i === 0 && this.newRoute.length > 0 && this.arePointsEqual(this.newRoute[this.newRoute.length - 1], path23[i])) {
+    for (let i = 0;i < path25.length; i++) {
+      if (i === 0 && this.newRoute.length > 0 && this.arePointsEqual(this.newRoute[this.newRoute.length - 1], path25[i])) {
         continue;
       }
-      this.newRoute.push(path23[i]);
+      this.newRoute.push(path25[i]);
     }
     this.currentStepSize = this.maxStepSize;
   }
@@ -166569,7 +167238,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
     for (let i = 0;i < portsWithPosition.length - 1; i++) {
       const start = portsWithPosition[i];
       const end = portsWithPosition[i + 1];
-      const path23 = calculateElbow({
+      const path25 = calculateElbow({
         x: start.position.x,
         y: start.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(start.facingDirection)
@@ -166578,8 +167247,8 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         y: end.position.y,
         facingDirection: convertFacingDirectionToElbowDirection(end.facingDirection)
       });
-      for (let j4 = 0;j4 < path23.length - 1; j4++) {
-        elbowEdges.push({ from: path23[j4], to: path23[j4 + 1] });
+      for (let j4 = 0;j4 < path25.length - 1; j4++) {
+        elbowEdges.push({ from: path25[j4], to: path25[j4 + 1] });
       }
     }
     const doesSegmentIntersectRect = (edge, rect) => {
@@ -172767,8 +173436,8 @@ react/cjs/react-jsx-runtime.development.js:
 */
 
 // lib/import/import-component-from-jlcpcb.ts
-import fs24 from "node:fs/promises";
-import path23 from "node:path";
+import fs26 from "node:fs/promises";
+import path25 from "node:path";
 var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd()) => {
   const component = await fetchEasyEDAComponent(jlcpcbPartNumber);
   const tsx = await convertRawEasyToTsx(component);
@@ -172776,10 +173445,10 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
   if (!fileName) {
     throw new Error("Could not determine file name of converted component");
   }
-  const importsDir = path23.join(projectDir, "imports");
-  await fs24.mkdir(importsDir, { recursive: true });
-  const filePath = path23.join(importsDir, `${fileName}.tsx`);
-  await fs24.writeFile(filePath, tsx);
+  const importsDir = path25.join(projectDir, "imports");
+  await fs26.mkdir(importsDir, { recursive: true });
+  const filePath = path25.join(importsDir, `${fileName}.tsx`);
+  await fs26.writeFile(filePath, tsx);
   return { filePath };
 };
 
@@ -172880,12 +173549,12 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path26 from "node:path";
-import fs27 from "node:fs";
+import path28 from "node:path";
+import fs29 from "node:fs";
 
 // cli/build/build-file.ts
-import path24 from "node:path";
-import fs25 from "node:fs";
+import path26 from "node:path";
+import fs27 from "node:fs";
 
 // lib/shared/circuit-json-diagnostics.ts
 function analyzeCircuitJson(circuitJson) {
@@ -172916,9 +173585,9 @@ var buildFile = async (input, output, projectDir, options) => {
       filePath: input,
       platformConfig: options?.platformConfig
     });
-    fs25.mkdirSync(path24.dirname(output), { recursive: true });
-    fs25.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
-    console.log(`Circuit JSON written to ${path24.relative(projectDir, output)}`);
+    fs27.mkdirSync(path26.dirname(output), { recursive: true });
+    fs27.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
+    console.log(`Circuit JSON written to ${path26.relative(projectDir, output)}`);
     const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
     if (!options?.ignoreWarnings) {
       for (const warn of warnings) {
@@ -172946,16 +173615,16 @@ var buildFile = async (input, output, projectDir, options) => {
 };
 
 // cli/build/get-build-entrypoints.ts
-import fs26 from "node:fs";
-import path25 from "node:path";
+import fs28 from "node:fs";
+import path27 from "node:path";
 async function getBuildEntrypoints({
   fileOrDir,
   rootDir = process.cwd()
 }) {
-  const resolvedRoot = path25.resolve(rootDir);
+  const resolvedRoot = path27.resolve(rootDir);
   if (fileOrDir) {
-    const resolved = path25.resolve(resolvedRoot, fileOrDir);
-    if (fs26.existsSync(resolved) && fs26.statSync(resolved).isDirectory()) {
+    const resolved = path27.resolve(resolvedRoot, fileOrDir);
+    if (fs28.existsSync(resolved) && fs28.statSync(resolved).isDirectory()) {
       const projectDir2 = resolved;
       const files2 = globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
         cwd: projectDir2,
@@ -172963,10 +173632,10 @@ async function getBuildEntrypoints({
       });
       return {
         projectDir: projectDir2,
-        circuitFiles: files2.map((f) => path25.join(projectDir2, f))
+        circuitFiles: files2.map((f) => path27.join(projectDir2, f))
       };
     }
-    return { projectDir: path25.dirname(resolved), circuitFiles: [resolved] };
+    return { projectDir: path27.dirname(resolved), circuitFiles: [resolved] };
   }
   const projectDir = resolvedRoot;
   const files = globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
@@ -172975,7 +173644,7 @@ async function getBuildEntrypoints({
   });
   return {
     projectDir,
-    circuitFiles: files.map((f) => path25.join(projectDir, f))
+    circuitFiles: files.map((f) => path27.join(projectDir, f))
   };
 }
 
@@ -172983,13 +173652,13 @@ async function getBuildEntrypoints({
 var registerBuild = (program3) => {
   program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").action(async (file, options) => {
     const { projectDir, mainEntrypoint, circuitFiles } = await getBuildEntrypoints({ fileOrDir: file });
-    const distDir = path26.join(projectDir, "dist");
-    fs27.mkdirSync(distDir, { recursive: true });
+    const distDir = path28.join(projectDir, "dist");
+    fs29.mkdirSync(distDir, { recursive: true });
     let hasErrors = false;
     for (const filePath of circuitFiles) {
-      const relative9 = path26.relative(projectDir, filePath);
+      const relative9 = path28.relative(projectDir, filePath);
       const outputDirName = relative9.replace(/(\.board|\.circuit)?\.tsx$/, "");
-      const outputPath = path26.join(distDir, outputDirName, "circuit.json");
+      const outputPath = path28.join(distDir, outputDirName, "circuit.json");
       const ok = await buildFile(filePath, outputPath, projectDir, options);
       if (!ok)
         hasErrors = true;
@@ -173001,8 +173670,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs29 from "node:fs";
-import path27 from "node:path";
+import fs31 from "node:fs";
+import path29 from "node:path";
 import looksSame2 from "looks-same";
 import sharp from "sharp";
 import {
@@ -173013,7 +173682,7 @@ import { convertCircuitJsonToSimple3dSvg } from "circuit-json-to-simple-3d";
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs28 from "node:fs/promises";
+import fs30 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -173029,7 +173698,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs28.writeFile(diffPath, buffer2);
+      await fs30.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -173053,19 +173722,19 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f) => path27.resolve(projectDir, f));
+  const resolvedPaths = filePaths.map((f) => path29.resolve(projectDir, f));
   const boardFiles = resolvedPaths.length > 0 ? resolvedPaths.flatMap((p) => {
-    if (fs29.existsSync(p) && fs29.statSync(p).isDirectory()) {
+    if (fs31.existsSync(p) && fs31.statSync(p).isDirectory()) {
       return globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
         cwd: p,
         ignore
-      }).map((f) => path27.join(p, f));
+      }).map((f) => path29.join(p, f));
     }
     return [p];
   }) : globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
     cwd: projectDir,
     ignore
-  }).map((f) => path27.join(projectDir, f));
+  }).map((f) => path29.join(projectDir, f));
   if (boardFiles.length === 0) {
     console.log("No entrypoint found. Run 'tsci init' to bootstrap a project or specify a file with 'tsci snapshot <file>'");
     return onExit(0);
@@ -173077,9 +173746,9 @@ var snapshotProject = async ({
     const pcbSvg = convertCircuitJsonToPcbSvg3(circuitJson);
     const schSvg = convertCircuitJsonToSchematicSvg2(circuitJson);
     const svg3d = threeD ? await convertCircuitJsonToSimple3dSvg(circuitJson) : null;
-    const snapDir = path27.join(path27.dirname(file), "__snapshots__");
-    fs29.mkdirSync(snapDir, { recursive: true });
-    const base = path27.basename(file).replace(/\.tsx$/, "");
+    const snapDir = path29.join(path29.dirname(file), "__snapshots__");
+    fs31.mkdirSync(snapDir, { recursive: true });
+    const base = path29.basename(file).replace(/\.tsx$/, "");
     const pairs3 = [];
     if (pcbOnly || !schematicOnly)
       pairs3.push(["pcb", pcbSvg]);
@@ -173093,31 +173762,31 @@ var snapshotProject = async ({
     }
     for (const [type, newSvg] of pairs3) {
       const is3d = type === "3d";
-      const snapPath = path27.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs29.existsSync(snapPath);
+      const snapPath = path29.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs31.existsSync(snapPath);
       const newContentBuffer = is3d ? await sharp(Buffer.from(newSvg)).png().toBuffer() : Buffer.from(newSvg, "utf8");
       const newContentForFile = is3d ? newContentBuffer : newSvg;
       if (!existing) {
-        fs29.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
+        fs31.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path29.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs29.readFileSync(snapPath);
+      const oldContentBuffer = fs31.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(path27.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path29.relative(projectDir, snapPath)));
         } else {
-          fs29.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
+          fs31.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path29.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path29.relative(projectDir, snapPath)));
       }
     }
   }
@@ -173155,22 +173824,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs30 from "node:fs";
-import path28 from "node:path";
+import fs32 from "node:fs";
+import path30 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path28.resolve(startDir);
-    while (dir !== path28.parse(dir).root) {
-      if (fs30.existsSync(path28.join(dir, ".git"))) {
+    let dir = path30.resolve(startDir);
+    while (dir !== path30.parse(dir).root) {
+      if (fs32.existsSync(path30.join(dir, ".git"))) {
         return dir;
       }
-      dir = path28.dirname(dir);
+      dir = path30.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path28.join(gitRoot, ".github", "workflows");
-  fs30.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path30.join(gitRoot, ".github", "workflows");
+  fs32.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -173209,8 +173878,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path28.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path28.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path30.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path30.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -173236,8 +173905,8 @@ var registerSetup = (program3) => {
 };
 
 // cli/convert/register.ts
-import fs31 from "node:fs/promises";
-import path29 from "node:path";
+import fs33 from "node:fs/promises";
+import path31 from "node:path";
 
 // node_modules/kicad-component-converter/dist/index.js
 var __create4 = Object.create;
@@ -174549,8 +175218,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params2) => {
-  const { data, path: path29, errorMaps, issueData } = params2;
-  const fullPath = [...path29, ...issueData.path || []];
+  const { data, path: path31, errorMaps, issueData } = params2;
+  const fullPath = [...path31, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -174658,11 +175327,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path29, key) {
+  constructor(parent, value, path31, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path29;
+    this._path = path31;
     this._key = key;
   }
   get path() {
@@ -178451,14 +179120,14 @@ function generateArcPath(start, mid, end, numPoints) {
   if (angleDelta < 0) {
     angleDelta += 2 * Math.PI;
   }
-  const path29 = [];
+  const path31 = [];
   for (let i = 0;i <= numPoints; i++) {
     const angle = angleStart + i / numPoints * angleDelta;
     const x = center2.x + radius * Math.cos(angle);
     const y = center2.y + radius * Math.sin(angle);
-    path29.push({ x, y });
+    path31.push({ x, y });
   }
-  return path29;
+  return path31;
 }
 var makePoint = (p) => {
   if (Array.isArray(p)) {
@@ -178902,15 +179571,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 = path29.resolve(file);
-      const modContent = await fs31.readFile(inputPath, "utf-8");
+      const inputPath = path31.resolve(file);
+      const modContent = await fs33.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path29.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path31.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path29.resolve(options.output) : path29.join(path29.dirname(inputPath), `${componentName}.tsx`);
-      await fs31.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path31.resolve(options.output) : path31.join(path31.dirname(inputPath), `${componentName}.tsx`);
+      await fs33.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);
@@ -178919,6 +179588,89 @@ var registerConvert = (program3) => {
   });
 };
 
+// lib/shared/result-to-table.ts
+var formatNumber = (n3) => {
+  return n3.toExponential(6);
+};
+function formatRows(rows) {
+  if (rows.length === 0)
+    return "";
+  const colWidths = Array(rows[0].length).fill(0);
+  for (const row of rows) {
+    for (let i = 0;i < row.length; i++) {
+      colWidths[i] = Math.max(colWidths[i], row[i].length);
+    }
+  }
+  return rows.map((row) => row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ")).join(`
+`);
+}
+var resultToTable = (result) => {
+  const uniqueHeaders = [];
+  const uniqueData = [];
+  const seenHeaders = new Set;
+  result.variableNames.forEach((header, index) => {
+    if (!seenHeaders.has(header)) {
+      seenHeaders.add(header);
+      uniqueHeaders.push(header);
+      uniqueData.push(result.data[index]);
+    }
+  });
+  if (result.dataType === "real") {
+    const headers2 = ["Index", ...uniqueHeaders];
+    const dataRows2 = [];
+    for (let i = 0;i < result.numPoints; i++) {
+      const row = [
+        i.toString(),
+        ...uniqueData.map((d) => formatNumber(d.values[i]))
+      ];
+      dataRows2.push(row);
+    }
+    return formatRows([headers2, ...dataRows2]);
+  }
+  const headers = [
+    "Index",
+    ...uniqueHeaders.flatMap((v2) => [`${v2}_real`, `${v2}_img`])
+  ];
+  const dataRows = [];
+  for (let i = 0;i < result.numPoints; i++) {
+    const row = [
+      i.toString(),
+      ...uniqueData.flatMap((d) => [
+        formatNumber(d.values[i].real),
+        formatNumber(d.values[i].img)
+      ])
+    ];
+    dataRows.push(row);
+  }
+  return formatRows([headers, ...dataRows]);
+};
+
+// cli/simulate/register.ts
+var registerSimulate = (program3) => {
+  const simulateCommand = program3.command("simulate").description("Run a simulation");
+  simulateCommand.command("analog").description("Run an analog SPICE simulation").argument("<file>", "Path to tscircuit tsx or circuit json file").action(async (file) => {
+    const { circuitJson } = await generateCircuitJson({
+      filePath: file,
+      saveToFile: false
+    });
+    if (!circuitJson) {
+      console.log("error: Failed to generate circuit JSON");
+      return;
+    }
+    const spiceString = getSpiceWithPaddedSim(circuitJson);
+    const { result, info, errors } = await runSimulation(spiceString);
+    if (errors?.length > 0) {
+      console.error(errors.join(`
+`));
+    }
+    if (info) {
+      console.log(info);
+    }
+    const tableContent = resultToTable(result);
+    console.log(tableContent);
+  });
+};
+
 // cli/main.ts
 var program2 = new Command;
 program2.name("tsci").description("CLI for developing tscircuit packages");
@@ -178944,6 +179696,7 @@ registerUpgradeCommand(program2);
 registerSearch(program2);
 registerImport(program2);
 registerConvert(program2);
+registerSimulate(program2);
 if (process.argv.includes("--version") || process.argv.includes("-v") || process.argv.includes("-V")) {
   console.log(getVersion());
   process.exit(0);