@tscircuit/cli 0.1.2047 → 0.1.2048

package/dist/cli/main.js

@@ -153243,7 +153243,7 @@ var import_perfect_cli = __toESM3(require_dist3(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.2046";
+var version = "0.1.2047";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -153262,7 +153262,7 @@ var package_default = {
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.19.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.9",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#db2cd1ca2ce51490e3230e53c3d7b361eeb14446",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#cb6059c8e2561967afad591b30251a915cab42e5",
     "@tscircuit/circuit-json-util": "^0.0.113",
     "@tscircuit/eval": "^0.0.1016",
     "@tscircuit/fake-snippets": "^0.0.182",
@@ -319215,10 +319215,154 @@ var escapeAttr2 = (value) => value.replaceAll("&", "&").replaceAll('"', "&qu
 var addAttr = (attrs, key, value, options) => {
   if (value === undefined)
     return;
-  const stringValue = typeof value === "number" ? options?.formatDelta ? fmtDelta(value) : fmtNumber4(value) : options?.escape === false ? value : escapeAttr2(value);
+  const stringValue = typeof value === "number" ? options?.formatDelta ? fmtDelta(value) : fmtNumber4(value) : escapeAttr2(value);
   attrs.push(`${key}="${stringValue}"`);
 };
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/source-connectivity.ts
+function getSourceConnectivity(circuitJson) {
+  const parent = new Map;
+  const find = (id) => {
+    const next = parent.get(id);
+    if (next === undefined || next === id)
+      return id;
+    const root = find(next);
+    parent.set(id, root);
+    return root;
+  };
+  const join = (ids) => {
+    const first = ids[0];
+    if (!first)
+      return;
+    const root = find(first);
+    for (const id of ids.slice(1))
+      parent.set(find(id), root);
+  };
+  for (const element of circuitJson) {
+    if (element.type === "source_port" || element.type === "source_net") {
+      const id = element.type === "source_port" ? element.source_port_id : element.source_net_id;
+      if (element.subcircuit_connectivity_map_key)
+        join([id, `connectivity:${element.subcircuit_connectivity_map_key}`]);
+    }
+    if (element.type === "source_trace") {
+      join([
+        ...element.connected_source_port_ids,
+        ...element.connected_source_net_ids,
+        ...element.subcircuit_connectivity_map_key ? [`connectivity:${element.subcircuit_connectivity_map_key}`] : []
+      ]);
+    }
+    if (element.type === "source_component_internal_connection")
+      join(element.source_port_ids);
+    if (element.type === "source_component") {
+      for (const ids of element.internally_connected_source_port_ids ?? [])
+        join(ids);
+    }
+  }
+  return find;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/placement-network-index.ts
+class PlacementNetworkIndex {
+  connected;
+  components = new Map;
+  portsByComponent = new Map;
+  portsByNet = new Map;
+  powerNets = new Set;
+  groundNets = new Set;
+  placements = new Map;
+  schematicComponents = new Map;
+  schematicPorts = new Map;
+  constructor(ctx) {
+    this.connected = getSourceConnectivity(ctx.circuitJson);
+    for (const placement of ctx.componentPlacements) {
+      if (placement.sourceComponentId)
+        append2(this.placements, placement.sourceComponentId, placement);
+    }
+    for (const element of ctx.circuitJson) {
+      if (element.type === "source_component")
+        this.components.set(element.source_component_id, element);
+      if (element.type === "source_port" && element.source_component_id) {
+        append2(this.portsByComponent, element.source_component_id, element);
+        append2(this.portsByNet, this.connected(element.source_port_id), element);
+      }
+      if (element.type === "source_net") {
+        const net = this.connected(element.source_net_id);
+        if (element.is_power || element.is_positive_voltage_source)
+          this.powerNets.add(net);
+        if (element.is_ground)
+          this.groundNets.add(net);
+      }
+      if (element.type === "schematic_component")
+        this.schematicComponents.set(element.schematic_component_id, element);
+      if (element.type === "schematic_port" && element.source_port_id)
+        append2(this.schematicPorts, element.source_port_id, element);
+    }
+  }
+  placement(componentId) {
+    const placements = this.placements.get(componentId);
+    return placements?.length === 1 ? placements[0] : undefined;
+  }
+  port(sourcePort) {
+    const placement = this.placement(sourcePort.source_component_id);
+    const ports = this.schematicPorts.get(sourcePort.source_port_id)?.filter((port) => port.schematic_component_id === placement?.schematicComponentId);
+    return ports?.length === 1 ? ports[0] : undefined;
+  }
+  namedPort(componentId, name) {
+    const ports = this.portsByComponent.get(componentId)?.filter((port) => port.name === name || port.port_hints?.includes(name));
+    return ports?.length === 1 ? ports[0] : undefined;
+  }
+  twoTerminalNets(componentId) {
+    const ports = this.portsByComponent.get(componentId);
+    if (ports?.length !== 2)
+      return;
+    const first = this.connected(ports[0].source_port_id);
+    const second = this.connected(ports[1].source_port_id);
+    if (first !== second)
+      return [first, second];
+  }
+  isRail(net) {
+    return this.powerNets.has(net) || this.groundNets.has(net);
+  }
+  isDirectOpAmpFeedback(componentId) {
+    const nets = this.twoTerminalNets(componentId);
+    if (!nets || nets.some((net) => this.isRail(net)))
+      return false;
+    return nets.some((net) => (this.portsByNet.get(net) ?? []).some((port) => {
+      const hostId = port.source_component_id;
+      if (this.components.get(hostId)?.ftype !== "simple_op_amp")
+        return false;
+      const output = this.namedPort(hostId, "output");
+      if (output?.source_port_id !== port.source_port_id)
+        return false;
+      return ["inverting_input", "non_inverting_input"].some((name) => {
+        const input = this.namedPort(hostId, name);
+        if (!input)
+          return false;
+        const inputNet = this.connected(input.source_port_id);
+        return inputNet !== net && nets.includes(inputNet);
+      });
+    }));
+  }
+  sameLocalScope(first, second) {
+    if (first.schematicSheetId !== second.schematicSheetId || first.subcircuitId !== second.subcircuitId)
+      return false;
+    const a = this.schematicComponents.get(first.schematicComponentId ?? "");
+    const b = this.schematicComponents.get(second.schematicComponentId ?? "");
+    if (!a || !b || a.schematic_group_id !== b.schematic_group_id)
+      return false;
+    const firstSource = this.components.get(first.sourceComponentId ?? "");
+    const secondSource = this.components.get(second.sourceComponentId ?? "");
+    return firstSource?.source_group_id === secondSource?.source_group_id && firstSource?.subcircuit_id === secondSource?.subcircuit_id;
+  }
+}
+function append2(map, key, value) {
+  const values = map.get(key);
+  if (values)
+    values.push(value);
+  else
+    map.set(key, [value]);
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/graphics.ts
 import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 function mergeGraphicsObjects2(objects) {
@@ -319259,6 +319403,7 @@ class CapacitorOrientationSolver extends BaseSolver5 {
   schematicComponentById;
   sourceComponentById;
   capacitorPlacements;
+  feedbackCapacitorIds;
   currentPlacementIndex = 0;
   horizontalSymbolNames = new Set([
     "capacitor_left",
@@ -319274,6 +319419,8 @@ class CapacitorOrientationSolver extends BaseSolver5 {
     this.schematicComponentById = this.buildSchematicComponentById(ctx.circuitJson);
     this.sourceComponentById = this.buildSourceComponentById(ctx.circuitJson);
     this.capacitorPlacements = this.getCapacitorPlacements();
+    const networks = new PlacementNetworkIndex(ctx);
+    this.feedbackCapacitorIds = new Set(this.capacitorPlacements.flatMap((capacitor) => capacitor.sourceComponentId && networks.isDirectOpAmpFeedback(capacitor.sourceComponentId) ? [capacitor.sourceComponentId] : []));
     this.solved = this.capacitorPlacements.length === 0;
   }
   getCapacitorPlacements() {
@@ -319352,6 +319499,8 @@ class CapacitorOrientationSolver extends BaseSolver5 {
       return;
     if (!this.horizontalSymbolNames.has(schematicComponent.symbol_name ?? ""))
       return;
+    if (this.feedbackCapacitorIds.has(placement.sourceComponentId))
+      return;
     return {
       lineItemType: "CapacitorSymbolHorizontal",
       schematicBox: this.createIssuePlacement(placement),
@@ -319365,13 +319514,111 @@ class CapacitorOrientationSolver extends BaseSolver5 {
     addAttr(attrs, "schY", issue.schematicBox.schY);
     addAttr(attrs, "width", issue.schematicBox.width);
     addAttr(attrs, "height", issue.schematicBox.height);
-    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "message", issue.message);
     return `<CapacitorSymbolHorizontal ${attrs.join(" ")} />`;
   }
 }
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DecouplingCapacitorGroupingSolver/DecouplingCapacitorGroupingSolver.ts
 import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+class DecouplingCapacitorGroupingSolver extends BaseSolver6 {
+  params;
+  static MIN_BODY_GAP = 4;
+  banks = [];
+  netNames = new Map;
+  bankIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const index = new PlacementNetworkIndex(params2.ctx);
+    const powerNets = new Set(index.powerNets);
+    const groundNets = new Set(index.groundNets);
+    for (const element of params2.ctx.circuitJson) {
+      if (element.type === "source_net") {
+        const net = index.connected(element.source_net_id);
+        if (!this.netNames.has(net))
+          this.netNames.set(net, element.name);
+      }
+    }
+    for (const ports of index.portsByComponent.values()) {
+      for (const port of ports) {
+        if (port.do_not_connect)
+          continue;
+        const net = index.connected(port.source_port_id);
+        if (port.provides_power || port.requires_power)
+          powerNets.add(net);
+        if (port.provides_ground || port.requires_ground)
+          groundNets.add(net);
+        if ((powerNets.has(net) || groundNets.has(net)) && !this.netNames.has(net))
+          this.netNames.set(net, port.name);
+      }
+    }
+    for (const component of index.components.values()) {
+      if (component.ftype !== "simple_capacitor")
+        continue;
+      const id = component.source_component_id;
+      const placement = index.placement(id);
+      const nets = index.twoTerminalNets(id);
+      const ports = index.portsByComponent.get(id);
+      if (!placement || !nets || !ports || ports.some((port) => {
+        const schematicPort = index.port(port);
+        return port.do_not_connect || !schematicPort || schematicPort.schematic_sheet_id !== placement.schematicSheetId;
+      }))
+        continue;
+      const power = nets.find((net) => powerNets.has(net) && !groundNets.has(net));
+      const ground = nets.find((net) => groundNets.has(net) && !powerNets.has(net));
+      if (!power || !ground)
+        continue;
+      const bank = this.banks.find((candidate) => candidate.power === power && candidate.ground === ground && index.sameLocalScope(candidate.capacitors[0], placement));
+      if (bank)
+        bank.capacitors.push(placement);
+      else
+        this.banks.push({ power, ground, capacitors: [placement] });
+    }
+    this.solved = this.banks.length === 0;
+  }
+  _step() {
+    const bank = this.banks[this.bankIndex++];
+    this.solved = this.bankIndex >= this.banks.length;
+    if (bank.capacitors.length < 2)
+      return;
+    const maxRecommendedBodyGap = Math.max(DecouplingCapacitorGroupingSolver.MIN_BODY_GAP, ...bank.capacitors.map((box) => 3 * Math.max(box.width, box.height)));
+    let maxBodyGap = 0;
+    for (let i = 0;i < bank.capacitors.length; i++) {
+      for (const b of bank.capacitors.slice(i + 1)) {
+        const a = bank.capacitors[i];
+        const gap = Math.hypot(Math.max(0, Math.abs(a.schX - b.schX) - (a.width + b.width) / 2), Math.max(0, Math.abs(a.schY - b.schY) - (a.height + b.height) / 2));
+        maxBodyGap = Math.max(maxBodyGap, gap);
+      }
+    }
+    if (maxBodyGap <= maxRecommendedBodyGap + 0.000001)
+      return;
+    const railName = this.netNames.get(bank.power) ?? bank.power;
+    const groundName = this.netNames.get(bank.ground) ?? bank.ground;
+    this.params.issues.push({
+      lineItemType: "DecouplingCapacitorsNotCloseTogether",
+      railName,
+      groundName,
+      capacitorSchematicBoxes: bank.capacitors,
+      maxBodyGap,
+      maxRecommendedBodyGap,
+      message: `Group the decoupling capacitors between ${railName} and ${groundName} closer together in this schematic block. Preserve their net connections.`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "rail", issue.railName);
+    addAttr(attrs, "ground", issue.groundName);
+    addAttr(attrs, "capacitorNames", issue.capacitorSchematicBoxes.map((box) => box.sourceComponentName ?? box.schematicComponentId).join(", "));
+    addAttr(attrs, "maxBodyGap", issue.maxBodyGap);
+    addAttr(attrs, "maxRecommendedBodyGap", issue.maxRecommendedBodyGap);
+    addAttr(attrs, "message", issue.message);
+    return `<DecouplingCapacitorsNotCloseTogether ${attrs.join(" ")} />`;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
 function centeredRect(cx, cy, w, h) {
@@ -319389,7 +319636,7 @@ function rectOverlap(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-class ComponentNetLabelCollisionSolver extends BaseSolver6 {
+class ComponentNetLabelCollisionSolver extends BaseSolver7 {
   params;
   LABEL_HALF_HEIGHT = 0.1;
   LABEL_BOUNDS_SLACK = 0.1;
@@ -319451,6 +319698,12 @@ class ComponentNetLabelCollisionSolver extends BaseSolver6 {
         if (rectOverlap(leftBounds, rightBounds)) {
           hits.push({
             type: "label-label",
+            bounds: {
+              left: Math.max(leftBounds.left, rightBounds.left),
+              right: Math.min(leftBounds.right, rightBounds.right),
+              top: Math.min(leftBounds.top, rightBounds.top),
+              bottom: Math.max(leftBounds.bottom, rightBounds.bottom)
+            },
             leftComp,
             rightComp,
             leftId,
@@ -319485,6 +319738,12 @@ class ComponentNetLabelCollisionSolver extends BaseSolver6 {
       }
       hits.push({
         type: "box-label",
+        bounds: {
+          left: Math.max(boxBounds.left, labelBounds.left),
+          right: Math.min(boxBounds.right, labelBounds.right),
+          top: Math.min(boxBounds.top, labelBounds.top),
+          bottom: Math.max(boxBounds.bottom, labelBounds.bottom)
+        },
         boxComp,
         labelComp,
         boxId,
@@ -319540,6 +319799,7 @@ class ComponentNetLabelCollisionSolver extends BaseSolver6 {
       schematicSheetId: firstPlacement.schematicSheetId,
       schematicSheetName: firstPlacement.schematicSheetName,
       pairs,
+      collisionBounds: collisions.map((collision) => collision.bounds),
       moves: Array.from(globalFixes.values())
     });
   }
@@ -319736,8 +319996,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver6 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver7 {
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver8 {
   static ALIGNMENT_EPSILON = 0.01;
   ctx;
   out;
@@ -319870,9 +320130,170 @@ class ComponentPinAlignmentSolver extends BaseSolver7 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CrystalLoadCapacitorPlacementSolver/CrystalLoadCapacitorPlacementSolver.ts
+import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
+class CrystalLoadCapacitorPlacementSolver extends BaseSolver9 {
+  static ALIGNMENT_TOLERANCE = 0.1;
+  issues;
+  networks;
+  currentNetworkIndex = 0;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.issues = issues;
+    this.networks = this.findCrystalLoadNetworks(ctx);
+    this.solved = this.networks.length === 0;
+  }
+  _step() {
+    const network = this.networks[this.currentNetworkIndex];
+    if (!network) {
+      this.solved = true;
+      return;
+    }
+    this.currentNetworkIndex += 1;
+    this.solved = this.currentNetworkIndex >= this.networks.length;
+    const deltaSchX = round(network.newSchX - network.crystal.schX);
+    const deltaSchY = round(network.newSchY - network.crystal.schY);
+    if (Math.abs(deltaSchX) <= CrystalLoadCapacitorPlacementSolver.ALIGNMENT_TOLERANCE && Math.abs(deltaSchY) <= CrystalLoadCapacitorPlacementSolver.ALIGNMENT_TOLERANCE) {
+      return;
+    }
+    const crystalName = network.crystal.sourceComponentName ?? "the crystal";
+    const firstCapacitorName = network.firstLoadCapacitor.sourceComponentName ?? "the first load capacitor";
+    const secondCapacitorName = network.secondLoadCapacitor.sourceComponentName ?? "the second load capacitor";
+    this.issues.push({
+      lineItemType: "CrystalNotCenteredOverLoadCapacitors",
+      crystalSchematicBox: network.crystal,
+      firstLoadCapacitorSchematicBox: network.firstLoadCapacitor,
+      secondLoadCapacitorSchematicBox: network.secondLoadCapacitor,
+      deltaSchX,
+      deltaSchY,
+      newSchX: network.newSchX,
+      newSchY: network.newSchY,
+      message: `move ${crystalName} to schX=${network.newSchX}, schY=${network.newSchY} so it is centered between ${firstCapacitorName} and ${secondCapacitorName} and aligned with their load-side pins`
+    });
+  }
+  findCrystalLoadNetworks(ctx) {
+    const sourceComponents = new Map;
+    const sourcePortsByComponentId = new Map;
+    const schematicPortsBySourcePortId = new Map;
+    const placementBySourceComponentId = new Map(ctx.componentPlacements.flatMap((placement) => placement.sourceComponentId ? [[placement.sourceComponentId, placement]] : []));
+    for (const element of ctx.circuitJson) {
+      if (element.type === "source_component") {
+        sourceComponents.set(element.source_component_id, {
+          sourceComponentId: element.source_component_id,
+          ftype: "ftype" in element && typeof element.ftype === "string" ? element.ftype : undefined
+        });
+      }
+      if (element.type === "source_port" && typeof element.source_component_id === "string" && typeof element.subcircuit_connectivity_map_key === "string") {
+        const sourcePort = {
+          sourcePortId: element.source_port_id,
+          sourceComponentId: element.source_component_id,
+          connectivityKey: element.subcircuit_connectivity_map_key
+        };
+        const componentPorts = sourcePortsByComponentId.get(element.source_component_id) ?? [];
+        componentPorts.push(sourcePort);
+        sourcePortsByComponentId.set(element.source_component_id, componentPorts);
+      }
+      if (element.type === "schematic_port" && element.source_port_id) {
+        schematicPortsBySourcePortId.set(element.source_port_id, element);
+      }
+    }
+    const capacitorConnectionsByConnectivityKey = new Map;
+    for (const sourceComponent of sourceComponents.values()) {
+      if (sourceComponent.ftype !== "simple_capacitor")
+        continue;
+      const capacitorPorts = sourcePortsByComponentId.get(sourceComponent.sourceComponentId) ?? [];
+      if (capacitorPorts.length !== 2)
+        continue;
+      const firstCapacitorPort = capacitorPorts[0];
+      const secondCapacitorPort = capacitorPorts[1];
+      const capacitorPlacement = placementBySourceComponentId.get(sourceComponent.sourceComponentId);
+      if (!capacitorPlacement)
+        continue;
+      for (const [loadPort, returnPort] of [
+        [firstCapacitorPort, secondCapacitorPort],
+        [secondCapacitorPort, firstCapacitorPort]
+      ]) {
+        const schematicLoadPort = schematicPortsBySourcePortId.get(loadPort.sourcePortId);
+        if (!schematicLoadPort)
+          continue;
+        const connections = capacitorConnectionsByConnectivityKey.get(loadPort.connectivityKey) ?? [];
+        connections.push({
+          capacitor: capacitorPlacement,
+          loadPort: schematicLoadPort,
+          returnConnectivityKey: returnPort.connectivityKey
+        });
+        capacitorConnectionsByConnectivityKey.set(loadPort.connectivityKey, connections);
+      }
+    }
+    const networks = [];
+    for (const sourceComponent of sourceComponents.values()) {
+      if (sourceComponent.ftype !== "simple_crystal" && sourceComponent.ftype !== "simple_chip") {
+        continue;
+      }
+      const crystalPorts = sourcePortsByComponentId.get(sourceComponent.sourceComponentId) ?? [];
+      if (crystalPorts.length !== 2 || crystalPorts[0].connectivityKey === crystalPorts[1].connectivityKey) {
+        continue;
+      }
+      const firstCrystalConnectivityKey = crystalPorts[0].connectivityKey;
+      const secondCrystalConnectivityKey = crystalPorts[1].connectivityKey;
+      const hasOscillatorHost = [...sourcePortsByComponentId.entries()].some(([sourceComponentId, sourcePorts]) => sourceComponentId !== sourceComponent.sourceComponentId && sourcePorts.length > 2 && sourcePorts.some((port) => port.connectivityKey === firstCrystalConnectivityKey) && sourcePorts.some((port) => port.connectivityKey === secondCrystalConnectivityKey));
+      if (!hasOscillatorHost)
+        continue;
+      const crystalPlacement = placementBySourceComponentId.get(sourceComponent.sourceComponentId);
+      if (!crystalPlacement)
+        continue;
+      const firstConnections = capacitorConnectionsByConnectivityKey.get(crystalPorts[0].connectivityKey) ?? [];
+      const secondConnections = capacitorConnectionsByConnectivityKey.get(crystalPorts[1].connectivityKey) ?? [];
+      const candidatePairs = firstConnections.flatMap((firstConnection) => secondConnections.flatMap((secondConnection) => {
+        if (firstConnection.capacitor.sourceComponentId === secondConnection.capacitor.sourceComponentId || firstConnection.returnConnectivityKey !== secondConnection.returnConnectivityKey || firstConnection.returnConnectivityKey === firstCrystalConnectivityKey || firstConnection.returnConnectivityKey === secondCrystalConnectivityKey || firstConnection.capacitor.schematicSheetId !== crystalPlacement.schematicSheetId || secondConnection.capacitor.schematicSheetId !== crystalPlacement.schematicSheetId) {
+          return [];
+        }
+        return [{ firstConnection, secondConnection }];
+      }));
+      if (candidatePairs.length === 0)
+        continue;
+      const bestPair = candidatePairs.toSorted((a, b) => pairDistance(a, crystalPlacement) - pairDistance(b, crystalPlacement))[0];
+      const loadPorts = [
+        bestPair.firstConnection.loadPort,
+        bestPair.secondConnection.loadPort
+      ];
+      const capacitors = [
+        bestPair.firstConnection.capacitor,
+        bestPair.secondConnection.capacitor
+      ].toSorted((a, b) => a.schX - b.schX);
+      networks.push({
+        crystal: crystalPlacement,
+        firstLoadCapacitor: capacitors[0],
+        secondLoadCapacitor: capacitors[1],
+        newSchX: round((loadPorts[0].center.x + loadPorts[1].center.x) / 2),
+        newSchY: round((loadPorts[0].center.y + loadPorts[1].center.y) / 2)
+      });
+    }
+    return networks;
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "crystalName", issue.crystalSchematicBox.sourceComponentName);
+    addAttr(attrs, "firstLoadCapacitorName", issue.firstLoadCapacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "secondLoadCapacitorName", issue.secondLoadCapacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "newSchX", issue.newSchX);
+    addAttr(attrs, "newSchY", issue.newSchY);
+    addAttr(attrs, "deltaSchX", issue.deltaSchX, { formatDelta: true });
+    addAttr(attrs, "deltaSchY", issue.deltaSchY, { formatDelta: true });
+    addAttr(attrs, "message", issue.message);
+    return `<CrystalNotCenteredOverLoadCapacitors ${attrs.join(" ")} />`;
+  }
+}
+var pairDistance = (pair, crystal) => distance49(pair.firstConnection.capacitor, crystal) + distance49(pair.secondConnection.capacitor, crystal);
+var distance49 = (first, second) => Math.hypot(first.schX - second.schX, first.schY - second.schY);
+var round = (value) => Math.round(value * 100) / 100;
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
-import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
-class DiodeResistorAlignmentSolver extends BaseSolver8 {
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+class DiodeResistorAlignmentSolver extends BaseSolver10 {
   static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
   ctx;
   out;
@@ -320033,9 +320454,277 @@ class DiodeResistorAlignmentSolver extends BaseSolver8 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/FeedbackNetworkPlacementSolver/FeedbackNetworkPlacementSolver.ts
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+class FeedbackNetworkPlacementSolver extends BaseSolver11 {
+  static MIN_BODY_GAP = 4;
+  index;
+  amplifierIds;
+  issues;
+  currentIndex = 0;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.issues = issues;
+    this.index = new PlacementNetworkIndex(ctx);
+    this.amplifierIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_op_amp").map((component) => component.source_component_id);
+    this.solved = this.amplifierIds.length === 0;
+  }
+  _step() {
+    const id = this.amplifierIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.amplifierIds.length;
+    if (!id)
+      return;
+    const index = this.index;
+    const amplifier = index.placement(id);
+    const output = index.namedPort(id, "output");
+    const input = index.namedPort(id, "inverting_input");
+    if (!amplifier || !output || !input || !index.port(output) || !index.port(input))
+      return;
+    const outputNet = index.connected(output.source_port_id);
+    const inputNet = index.connected(input.source_port_id);
+    if (outputNet === inputNet || index.isRail(outputNet) || index.isRail(inputNet))
+      return;
+    if ((index.portsByNet.get(inputNet) ?? []).some((port) => port.source_component_id !== id && index.components.get(port.source_component_id)?.ftype === "simple_op_amp"))
+      return;
+    const feedbackComponents = [];
+    const seen = new Set;
+    for (const port of index.portsByNet.get(outputNet) ?? []) {
+      const componentId = port.source_component_id;
+      if (seen.has(componentId))
+        continue;
+      seen.add(componentId);
+      const component = index.components.get(componentId);
+      if (component?.ftype !== "simple_resistor" && component?.ftype !== "simple_capacitor")
+        continue;
+      if (component.ftype === "simple_resistor" && !(component.resistance > 0))
+        continue;
+      const nets = index.twoTerminalNets(componentId);
+      if (!nets?.includes(inputNet) || !nets.includes(outputNet))
+        continue;
+      const placement = index.placement(componentId);
+      if (!placement || !index.sameLocalScope(amplifier, placement))
+        return;
+      feedbackComponents.push(placement);
+    }
+    const distantComponents = feedbackComponents.flatMap((schematicBox) => {
+      const bodyGap = distanceBetweenBoxes(amplifier, schematicBox);
+      const maxRecommendedBodyGap = Math.max(FeedbackNetworkPlacementSolver.MIN_BODY_GAP, 3 * Math.max(schematicBox.width, schematicBox.height));
+      return bodyGap > maxRecommendedBodyGap ? [{ schematicBox, bodyGap, maxRecommendedBodyGap }] : [];
+    });
+    if (distantComponents.length === 0)
+      return;
+    const names = distantComponents.map(({ schematicBox }) => schematicBox.sourceComponentName ?? schematicBox.sourceComponentId).join(", ");
+    this.issues.push({
+      lineItemType: "FeedbackNetworkNotCompact",
+      amplifierSchematicBox: amplifier,
+      feedbackComponents,
+      distantComponents,
+      outputSourcePortId: output.source_port_id,
+      invertingInputSourcePortId: input.source_port_id,
+      message: `consider grouping ${names} closer to ${amplifier.sourceComponentName ?? id}, with a compact feedback return path above or below the amplifier`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "amplifierName", issue.amplifierSchematicBox.sourceComponentName);
+    addAttr(attrs, "feedbackComponentNames", issue.feedbackComponents.map((box) => box.sourceComponentName ?? box.sourceComponentId).join(", "));
+    addAttr(attrs, "distantComponentNames", issue.distantComponents.map(({ schematicBox }) => schematicBox.sourceComponentName ?? schematicBox.sourceComponentId).join(", "));
+    addAttr(attrs, "message", issue.message);
+    return `<FeedbackNetworkNotCompact ${attrs.join(" ")} />`;
+  }
+}
+function distanceBetweenBoxes(a, b) {
+  return Math.hypot(Math.max(0, Math.abs(a.schX - b.schX) - (a.width + b.width) / 2), Math.max(0, Math.abs(a.schY - b.schY) - (a.height + b.height) / 2));
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+class PullResistorPlacementSolver extends BaseSolver12 {
+  static MIN_WRONG_SIDE_GAP = 1.5;
+  index;
+  resistorIds;
+  issues;
+  currentIndex = 0;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.issues = issues;
+    this.index = new PlacementNetworkIndex(ctx);
+    this.resistorIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_resistor" && component.resistance > 0).map((component) => component.source_component_id);
+    this.solved = this.resistorIds.length === 0;
+  }
+  _step() {
+    const id = this.resistorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.resistorIds.length;
+    if (!id)
+      return;
+    const index = this.index;
+    const resistor = index.placement(id);
+    const nets = index.twoTerminalNets(id);
+    if (!resistor || !nets)
+      return;
+    const rails = nets.filter((net) => index.isRail(net));
+    if (rails.length !== 1)
+      return;
+    const rail = rails[0];
+    if (index.powerNets.has(rail) && index.groundNets.has(rail))
+      return;
+    const pullDirection = index.groundNets.has(rail) ? "down" : "up";
+    const signal = nets.find((net) => net !== rail);
+    const signalPorts = index.portsByNet.get(signal) ?? [];
+    const requiringPorts = signalPorts.filter((port) => port.needs_external_pullup || port.needs_external_pulldown);
+    if (requiringPorts.length !== 1)
+      return;
+    const signalPort = requiringPorts[0];
+    if (signalPort.needs_external_pullup && signalPort.needs_external_pulldown)
+      return;
+    if (pullDirection === "up" ? !signalPort.needs_external_pullup : !signalPort.needs_external_pulldown)
+      return;
+    const host = index.placement(signalPort.source_component_id);
+    const schematicPin = index.port(signalPort);
+    if (!host || !schematicPin || !index.sameLocalScope(host, resistor))
+      return;
+    if (signalPorts.some((port) => {
+      const otherId = port.source_component_id;
+      if (otherId === id || otherId === signalPort.source_component_id)
+        return false;
+      const type = index.components.get(otherId)?.ftype;
+      if (type !== "simple_capacitor")
+        return true;
+      const capacitorNets = index.twoTerminalNets(otherId);
+      const returnNet = capacitorNets?.find((net) => net !== signal);
+      if (!returnNet || !index.groundNets.has(returnNet) || index.powerNets.has(returnNet))
+        return true;
+      const capacitor = index.placement(otherId);
+      return !capacitor || !index.sameLocalScope(host, capacitor);
+    }))
+      return;
+    const signalSchY = schematicPin.center.y;
+    const wrongSideGap = pullDirection === "up" ? signalSchY - (resistor.schY + resistor.height / 2) : resistor.schY - resistor.height / 2 - signalSchY;
+    if (wrongSideGap <= PullResistorPlacementSolver.MIN_WRONG_SIDE_GAP)
+      return;
+    const preferredSide = pullDirection === "up" ? "above" : "below";
+    this.issues.push({
+      lineItemType: "PullResistorOnWrongSide",
+      resistorSchematicBox: resistor,
+      hostSchematicBox: host,
+      signalSourcePortId: signalPort.source_port_id,
+      signalPinName: signalPort.name,
+      signalSchY,
+      pullDirection,
+      preferredSide,
+      wrongSideGap,
+      maxRecommendedWrongSideGap: PullResistorPlacementSolver.MIN_WRONG_SIDE_GAP,
+      message: `consider placing ${resistor.sourceComponentName ?? id} ${preferredSide} ${host.sourceComponentName ?? signalPort.source_component_id}.${signalPort.name} so the pull-${pullDirection} branch reads toward ${pullDirection === "up" ? "power" : "ground"}`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "resistorName", issue.resistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "hostName", issue.hostSchematicBox.sourceComponentName);
+    addAttr(attrs, "signalPin", issue.signalPinName);
+    addAttr(attrs, "pullDirection", issue.pullDirection);
+    addAttr(attrs, "preferredSide", issue.preferredSide);
+    addAttr(attrs, "signalSchY", issue.signalSchY);
+    addAttr(attrs, "wrongSideGap", issue.wrongSideGap);
+    addAttr(attrs, "message", issue.message);
+    return `<PullResistorOnWrongSide ${attrs.join(" ")} />`;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentRailOrientationSolver/TwoPinComponentRailOrientationSolver.ts
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+class TwoPinComponentRailOrientationSolver extends BaseSolver13 {
+  static EPSILON = 0.01;
+  index;
+  powerNets;
+  groundNets;
+  componentIds;
+  issues;
+  currentIndex = 0;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.issues = issues;
+    this.index = new PlacementNetworkIndex(ctx);
+    this.powerNets = new Set(this.index.powerNets);
+    this.groundNets = new Set(this.index.groundNets);
+    for (const element of ctx.circuitJson) {
+      if (element.type !== "source_port")
+        continue;
+      const net = this.index.connected(element.source_port_id);
+      if (element.provides_power || element.requires_power)
+        this.powerNets.add(net);
+      if (element.provides_ground || element.requires_ground)
+        this.groundNets.add(net);
+    }
+    this.componentIds = [...this.index.components.keys()].filter((id) => this.index.portsByComponent.get(id)?.length === 2);
+    this.solved = this.componentIds.length === 0;
+  }
+  _step() {
+    const id = this.componentIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.componentIds.length;
+    if (!id)
+      return;
+    const index = this.index;
+    const component = index.placement(id);
+    const nets = index.twoTerminalNets(id);
+    if (!component || !nets)
+      return;
+    if (nets.some((net) => this.powerNets.has(net) && this.groundNets.has(net)))
+      return;
+    const railTypes = nets.map((net) => this.powerNets.has(net) ? "power" : this.groundNets.has(net) ? "ground" : undefined);
+    if (railTypes.every((type) => type === undefined))
+      return;
+    const railType = railTypes.includes("power") ? "power" : "ground";
+    const candidates = nets.flatMap((net, i) => railTypes[i] === railType ? [{ net, index: i }] : []);
+    const railIndex = (candidates.find(({ net }) => index.portsByNet.get(net)?.some((port) => railType === "power" ? port.provides_power : port.provides_ground)) ?? candidates.find(({ net }) => (railType === "power" ? index.powerNets : index.groundNets).has(net)) ?? candidates[0]).index;
+    const rail = nets[railIndex];
+    const sourcePorts = index.portsByComponent.get(id);
+    const railSourcePort = sourcePorts.find((port) => index.connected(port.source_port_id) === rail);
+    const otherSourcePort = sourcePorts.find((port) => port !== railSourcePort);
+    const railPort = index.port(railSourcePort);
+    const otherPort = index.port(otherSourcePort);
+    if (!railPort || !otherPort)
+      return;
+    const horizontal = Math.abs(railPort.center.y - otherPort.center.y) <= TwoPinComponentRailOrientationSolver.EPSILON && Math.abs(railPort.center.x - otherPort.center.x) > TwoPinComponentRailOrientationSolver.EPSILON && (railPort.facing_direction === "left" && otherPort.facing_direction === "right" || railPort.facing_direction === "right" && otherPort.facing_direction === "left");
+    if (!horizontal)
+      return;
+    const suggestedRailFacingDirection = railType === "power" ? "up" : "down";
+    const deltaSchRotation = railPort.facing_direction === "left" === (railType === "power") ? -90 : 90;
+    this.issues.push({
+      lineItemType: "TwoPinComponentShouldBeVertical",
+      schematicBox: component,
+      railSourcePortId: railSourcePort.source_port_id,
+      railPinName: railSourcePort.name,
+      railType,
+      deltaSchRotation,
+      suggestedRailFacingDirection,
+      message: `rotate ${component.sourceComponentName ?? id} by ${deltaSchRotation}° so its ${railType}-connected pin faces ${suggestedRailFacingDirection} and the component is vertical`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+    addAttr(attrs, "railPin", issue.railPinName);
+    addAttr(attrs, "railType", issue.railType);
+    addAttr(attrs, "deltaSchRotation", issue.deltaSchRotation);
+    addAttr(attrs, "suggestedRailFacingDirection", issue.suggestedRailFacingDirection);
+    addAttr(attrs, "message", issue.message);
+    return `<TwoPinComponentShouldBeVertical ${attrs.join(" ")} />`;
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver9 {
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver14 {
   params;
   MESSAGE = "Inner labels are colliding. Increase the schWidth or schHeight.";
   PIN_LABEL_EDGE_PADDING = 0.1;
@@ -320086,7 +320775,7 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver9 {
   }
   static issueToString(issue) {
     const attrs = [];
-    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "message", issue.message);
     addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
     addAttr(attrs, "currentSchWidth", issue.schematicBox.width);
     addAttr(attrs, "currentSchHeight", issue.schematicBox.height);
@@ -320233,8 +320922,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver9 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
-import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver10 {
+import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver15 {
   params;
   placements;
   firstIndex = 0;
@@ -320353,8 +321042,8 @@ class SchematicBoxOverlapSolver extends BaseSolver10 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver11 {
+import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver16 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
@@ -320433,7 +321122,7 @@ class SchematicBoxTooWideSolver extends BaseSolver11 {
   }
   static issueToString(issue) {
     const attrs = [];
-    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "message", issue.message);
     addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
     addAttr(attrs, "currentSchWidth", issue.schematicBox.width);
     addAttr(attrs, "measuredInnerLabelHorizontalEmptySpace", issue.measuredInnerLabelHorizontalEmptySpace);
@@ -320529,8 +321218,8 @@ class SchematicBoxTooWideSolver extends BaseSolver11 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver12 {
+import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver17 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
   PIN_NAME_CHARACTER_WIDTH = 0.095;
@@ -320597,7 +321286,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver12 {
   }
   static issueToString(issue) {
     const attrs = [];
-    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "message", issue.message);
     addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
     addAttr(attrs, "pinSide", issue.pinSide);
     addAttr(attrs, "edgeSide", issue.edgeSide);
@@ -320868,8 +321557,8 @@ var buildSolverContext = (circuitJson) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
-import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
-class TraceSimplificationSolver extends BaseSolver13 {
+import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver18 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -321098,9 +321787,293 @@ class TraceSimplificationSolver extends BaseSolver13 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
+import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/getPowerOrGroundConnectionIds.ts
+import {
+  findConnectedNetworks as findConnectedNetworks3,
+  getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2
+} from "circuit-json-to-connectivity-map";
+function getPowerOrGroundConnectionIds(circuitJson) {
+  const powerOrGroundIds = new Set;
+  const idsByConnectivityKey = new Map;
+  for (const element of circuitJson) {
+    if (element.type !== "source_net" && element.type !== "source_port")
+      continue;
+    const id = element.type === "source_net" ? element.source_net_id : element.source_port_id;
+    const isPowerOrGround = element.type === "source_net" ? element.is_power || element.is_ground || element.is_positive_voltage_source : element.provides_power || element.requires_power || element.provides_ground || element.requires_ground;
+    if (isPowerOrGround)
+      powerOrGroundIds.add(id);
+    const key = element.subcircuit_connectivity_map_key;
+    if (key !== undefined) {
+      const ids = idsByConnectivityKey.get(key) ?? [];
+      ids.push(id);
+      idsByConnectivityKey.set(key, ids);
+    }
+  }
+  const sourceConnectivity = getSourcePortConnectivityMapFromCircuitJson2(circuitJson);
+  const networks = findConnectedNetworks3([
+    ...Object.values(sourceConnectivity.netMap),
+    ...idsByConnectivityKey.values()
+  ]);
+  for (const ids of Object.values(networks)) {
+    if (ids.some((id) => powerOrGroundIds.has(id))) {
+      for (const id of ids)
+        powerOrGroundIds.add(id);
+    }
+  }
+  return powerOrGroundIds;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
+class TwoPinComponentOrientationSolver extends BaseSolver19 {
+  static EPSILON = 0.01;
+  ctx;
+  out;
+  powerOrGroundConnectionIds;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.ctx = ctx;
+    this.out = issues;
+    this.powerOrGroundConnectionIds = getPowerOrGroundConnectionIds(ctx.circuitJson);
+  }
+  _step() {
+    const ports = this.ctx.circuitJson.filter((element) => element.type === "schematic_port");
+    const portsById = new Map(ports.map((port) => [port.schematic_port_id, port]));
+    const portsByComponentId = new Map;
+    for (const port of ports) {
+      if (!port.schematic_component_id)
+        continue;
+      const componentPorts = portsByComponentId.get(port.schematic_component_id) ?? [];
+      componentPorts.push(port);
+      portsByComponentId.set(port.schematic_component_id, componentPorts);
+    }
+    const placementsByComponentId = new Map(this.ctx.componentPlacements.flatMap((placement) => placement.schematicComponentId ? [[placement.schematicComponentId, placement]] : []));
+    const bestCandidateByComponentId = new Map;
+    for (const trace of this.ctx.circuitJson.filter((element) => element.type === "schematic_trace")) {
+      const points = this.getTracePoints(trace);
+      const currentTurnCount = this.countTurns(points);
+      if (currentTurnCount === undefined || currentTurnCount < 2)
+        continue;
+      const endpoints = this.getTraceEndpoints(trace, points, ports, portsById);
+      if (!endpoints)
+        continue;
+      for (const [targetEndpoint, connectedEndpoint] of [
+        endpoints,
+        [endpoints[1], endpoints[0]]
+      ]) {
+        const candidate = this.getFlipCandidate({
+          trace,
+          targetEndpoint,
+          connectedEndpoint,
+          currentTurnCount,
+          portsByComponentId,
+          placementsByComponentId
+        });
+        if (!candidate)
+          continue;
+        const componentId = candidate.targetPort.schematic_component_id;
+        const existing = bestCandidateByComponentId.get(componentId);
+        if (!existing || this.isBetterCandidate(candidate, existing)) {
+          bestCandidateByComponentId.set(componentId, candidate);
+        }
+      }
+    }
+    for (const candidate of bestCandidateByComponentId.values()) {
+      this.out.push(this.makeIssue(candidate));
+    }
+    this.solved = true;
+  }
+  getFlipCandidate({
+    trace,
+    targetEndpoint,
+    connectedEndpoint,
+    currentTurnCount,
+    portsByComponentId,
+    placementsByComponentId
+  }) {
+    const targetPort = targetEndpoint.port;
+    const connectedPort = connectedEndpoint.port;
+    const targetComponentId = targetPort.schematic_component_id;
+    const connectedComponentId = connectedPort.schematic_component_id;
+    if (!targetComponentId || !connectedComponentId || targetComponentId === connectedComponentId || targetPort.schematic_sheet_id !== connectedPort.schematic_sheet_id) {
+      return;
+    }
+    const componentPorts = portsByComponentId.get(targetComponentId);
+    if (componentPorts?.length !== 2)
+      return;
+    if (componentPorts.some((port) => port.source_port_id && this.powerOrGroundConnectionIds.has(port.source_port_id))) {
+      return;
+    }
+    const connectedComponentPorts = portsByComponentId.get(connectedComponentId) ?? [];
+    if (connectedComponentPorts.length <= 2)
+      return;
+    const otherPort = componentPorts.find((port) => port.schematic_port_id !== targetPort.schematic_port_id);
+    if (!otherPort || !this.areOppositePorts(targetPort, otherPort))
+      return;
+    const currentFacingDirection = targetPort.facing_direction;
+    const suggestedFacingDirection = otherPort.facing_direction;
+    if (!currentFacingDirection || !suggestedFacingDirection)
+      return;
+    if (!this.traceLeavesPortInFacingDirection(targetEndpoint))
+      return;
+    const connectedPoint = connectedPort.center;
+    if (this.isPointInFacingDirection(targetPort.center, connectedPoint, currentFacingDirection) || !this.isPointInFacingDirection(otherPort.center, connectedPoint, suggestedFacingDirection) || !connectedPort.facing_direction || !this.isPointInFacingDirection(connectedPoint, otherPort.center, connectedPort.facing_direction)) {
+      return;
+    }
+    const suggestedTurnCount = this.getMinimumTurnCount(otherPort.center, connectedPoint, suggestedFacingDirection);
+    if (suggestedTurnCount >= currentTurnCount)
+      return;
+    const targetPlacement = placementsByComponentId.get(targetComponentId);
+    const connectedPlacement = placementsByComponentId.get(connectedComponentId);
+    if (!targetPlacement || !connectedPlacement)
+      return;
+    return {
+      trace,
+      targetPort,
+      targetPlacement,
+      connectedPlacement,
+      suggestedFacingDirection,
+      currentTurnCount,
+      suggestedTurnCount,
+      traceLength: this.getTraceLength(targetEndpoint.pointsFromEndpoint)
+    };
+  }
+  getTraceEndpoints(trace, points, ports, portsById) {
+    const firstEdge = trace.edges[0];
+    const lastEdge = trace.edges.at(-1);
+    if (!firstEdge || !lastEdge || points.length < 2)
+      return;
+    const startPort = firstEdge.from_schematic_port_id ? portsById.get(firstEdge.from_schematic_port_id) : this.findPortAtPoint(ports, points[0], trace.schematic_sheet_id);
+    const endPort = lastEdge.to_schematic_port_id ? portsById.get(lastEdge.to_schematic_port_id) : this.findPortAtPoint(ports, points.at(-1), trace.schematic_sheet_id);
+    if (!startPort || !endPort)
+      return;
+    return [
+      { port: startPort, pointsFromEndpoint: points },
+      { port: endPort, pointsFromEndpoint: [...points].reverse() }
+    ];
+  }
+  getTracePoints(trace) {
+    const firstEdge = trace.edges[0];
+    if (!firstEdge)
+      return [];
+    const points = [firstEdge.from];
+    for (const edge of trace.edges) {
+      if (!this.pointsEqual(points.at(-1), edge.from))
+        return [];
+      points.push(edge.to);
+    }
+    return points;
+  }
+  countTurns(points) {
+    const axes = [];
+    for (const [index, point] of points.slice(1).entries()) {
+      const previousPoint = points[index];
+      if (this.pointsEqual(previousPoint, point))
+        continue;
+      const axis = this.getAxis(previousPoint, point);
+      if (!axis)
+        return;
+      if (axes.at(-1) !== axis)
+        axes.push(axis);
+    }
+    return Math.max(0, axes.length - 1);
+  }
+  traceLeavesPortInFacingDirection(endpoint) {
+    const nextPoint = endpoint.pointsFromEndpoint.find((point) => !this.pointsEqual(point, endpoint.port.center));
+    return Boolean(nextPoint && endpoint.port.facing_direction && this.isPointInFacingDirection(endpoint.port.center, nextPoint, endpoint.port.facing_direction));
+  }
+  areOppositePorts(a, b) {
+    const horizontal = (a.facing_direction === "left" && b.facing_direction === "right" || a.facing_direction === "right" && b.facing_direction === "left") && Math.abs(a.center.y - b.center.y) <= TwoPinComponentOrientationSolver.EPSILON;
+    const vertical = (a.facing_direction === "up" && b.facing_direction === "down" || a.facing_direction === "down" && b.facing_direction === "up") && Math.abs(a.center.x - b.center.x) <= TwoPinComponentOrientationSolver.EPSILON;
+    return horizontal || vertical;
+  }
+  getMinimumTurnCount(from, to, facingDirection) {
+    const alignedWithFacingAxis = facingDirection === "left" || facingDirection === "right" ? Math.abs(from.y - to.y) <= TwoPinComponentOrientationSolver.EPSILON : Math.abs(from.x - to.x) <= TwoPinComponentOrientationSolver.EPSILON;
+    return alignedWithFacingAxis ? 0 : 1;
+  }
+  isPointInFacingDirection(origin, point, facingDirection) {
+    const { EPSILON } = TwoPinComponentOrientationSolver;
+    switch (facingDirection) {
+      case "left":
+        return point.x < origin.x - EPSILON;
+      case "right":
+        return point.x > origin.x + EPSILON;
+      case "up":
+        return point.y > origin.y + EPSILON;
+      case "down":
+        return point.y < origin.y - EPSILON;
+    }
+  }
+  getAxis(a, b) {
+    const dx = Math.abs(a.x - b.x);
+    const dy = Math.abs(a.y - b.y);
+    const { EPSILON } = TwoPinComponentOrientationSolver;
+    if (dx <= EPSILON && dy > EPSILON)
+      return "vertical";
+    if (dy <= EPSILON && dx > EPSILON)
+      return "horizontal";
+    return;
+  }
+  pointsEqual(a, b) {
+    const { EPSILON } = TwoPinComponentOrientationSolver;
+    return Math.abs(a.x - b.x) <= EPSILON && Math.abs(a.y - b.y) <= EPSILON;
+  }
+  findPortAtPoint(ports, point, schematicSheetId) {
+    return ports.find((port) => port.schematic_sheet_id === schematicSheetId && this.pointsEqual(port.center, point));
+  }
+  getTraceLength(points) {
+    return points.slice(1).reduce((length, point, index) => {
+      const previousPoint = points[index];
+      return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
+    }, 0);
+  }
+  isBetterCandidate(candidate, existing) {
+    const improvement = candidate.currentTurnCount - candidate.suggestedTurnCount;
+    const existingImprovement = existing.currentTurnCount - existing.suggestedTurnCount;
+    return improvement > existingImprovement || improvement === existingImprovement && candidate.traceLength > existing.traceLength;
+  }
+  makeIssue(candidate) {
+    const targetName = candidate.targetPlacement.sourceComponentName ?? candidate.targetPlacement.schematicComponentId ?? "component";
+    const connectedName = candidate.connectedPlacement.sourceComponentName ?? candidate.connectedPlacement.schematicComponentId ?? "connected component";
+    const targetPin = candidate.targetPort.pin_number ? `pin${candidate.targetPort.pin_number}` : candidate.targetPort.display_pin_label;
+    return {
+      lineItemType: "TwoPinComponentCouldBeFlipped",
+      schematicTraceId: candidate.trace.schematic_trace_id,
+      targetComponent: candidate.targetPlacement,
+      connectedComponent: candidate.connectedPlacement,
+      targetPin,
+      currentFacingDirection: candidate.targetPort.facing_direction,
+      suggestedFacingDirection: candidate.suggestedFacingDirection,
+      deltaSchRotation: 180,
+      currentTurnCount: candidate.currentTurnCount,
+      suggestedTurnCount: candidate.suggestedTurnCount,
+      message: `rotate ${targetName} by 180° so ${targetPin ?? "its connected pin"} faces ${connectedName} and reduce this trace from ${candidate.currentTurnCount} turns to ${candidate.suggestedTurnCount}`
+    };
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "schematicTraceId", issue.schematicTraceId);
+    addAttr(attrs, "targetComponentName", issue.targetComponent.sourceComponentName);
+    addAttr(attrs, "connectedComponentName", issue.connectedComponent.sourceComponentName);
+    addAttr(attrs, "targetPin", issue.targetPin);
+    addAttr(attrs, "currentFacingDirection", issue.currentFacingDirection);
+    addAttr(attrs, "suggestedFacingDirection", issue.suggestedFacingDirection);
+    addAttr(attrs, "deltaSchRotation", issue.deltaSchRotation);
+    addAttr(attrs, "currentTurnCount", issue.currentTurnCount);
+    addAttr(attrs, "suggestedTurnCount", issue.suggestedTurnCount);
+    addAttr(attrs, "message", issue.message);
+    return `<TwoPinComponentCouldBeFlipped ${attrs.join(" ")} />`;
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver14 {
+import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver20 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -321148,7 +322121,7 @@ class VerboseNetLabelSolver extends BaseSolver14 {
   }
   static issueToString(issue) {
     const attrs = [];
-    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "message", issue.message);
     addAttr(attrs, "text", issue.text);
     addAttr(attrs, "involvedPins", issue.involvedPins.join(","));
     addAttr(attrs, "schSheetName", issue.schematicSheetName);
@@ -321208,11 +322181,446 @@ class VerboseNetLabelSolver extends BaseSolver14 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
+import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-text-geometry.ts
+var rectPolygon = (bounds) => [
+  { x: bounds.left, y: bounds.bottom },
+  { x: bounds.right, y: bounds.bottom },
+  { x: bounds.right, y: bounds.top },
+  { x: bounds.left, y: bounds.top }
+];
+var advance = (character) => {
+  if (/\s/.test(character))
+    return 0.28;
+  if (/[ilI.,:;!'|]/.test(character))
+    return 0.25;
+  if (/[MW@%]/.test(character))
+    return 0.9;
+  if (/[mw]/.test(character))
+    return 0.8;
+  if (/[A-Z]/.test(character))
+    return 0.67;
+  return 0.56;
+};
+var widthInEm = (text) => Array.from(text).reduce((width, character) => width + advance(character), 0);
+function getSchematicTextPolygons(text) {
+  const size = text.font_size;
+  if (!Number.isFinite(size) || size <= 0 || !Number.isFinite(text.rotation) || !Number.isFinite(text.position.x) || !Number.isFinite(text.position.y))
+    return [];
+  const anchor = text.anchor;
+  const horizontal = anchor.includes("left") ? 0 : anchor.includes("right") ? 1 : 0.5;
+  const top = anchor.includes("top") ? 0 : anchor.includes("bottom") ? size : size / 2;
+  const radians = -text.rotation * Math.PI / 180;
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  return text.text.split(`
+`).flatMap((line, index) => {
+    const visible = line.trim();
+    if (!visible)
+      return [];
+    const leading = line.length - line.trimStart().length;
+    const left = (widthInEm(line.slice(0, leading)) - widthInEm(line) * horizontal) * size;
+    const polygon = rectPolygon({
+      left,
+      right: left + widthInEm(visible) * size,
+      top: top - index * size - size * 0.05,
+      bottom: top - (index + 1) * size + size * 0.05
+    });
+    return [
+      polygon.map(({ x, y }) => ({
+        x: text.position.x + x * cos - y * sin,
+        y: text.position.y + x * sin + y * cos
+      }))
+    ];
+  });
+}
+function polygonsOverlap(a, b) {
+  for (const polygon of [a, b]) {
+    for (let i = 0;i < polygon.length; i++) {
+      const p = polygon[i];
+      const q = polygon[(i + 1) % polygon.length];
+      const length = Math.hypot(q.x - p.x, q.y - p.y);
+      if (length < 0.000000001)
+        continue;
+      const nx = -(q.y - p.y) / length;
+      const ny = (q.x - p.x) / length;
+      const project = (points) => points.map(({ x, y }) => x * nx + y * ny);
+      const pa = project(a);
+      const pb = project(b);
+      if (Math.min(Math.max(...pa), Math.max(...pb)) - Math.max(Math.min(...pa), Math.min(...pb)) <= 0.000001)
+        return false;
+    }
+  }
+  return true;
+}
+function traceSegmentPolygon(from, to) {
+  const length = Math.hypot(to.x - from.x, to.y - from.y);
+  if (length < 0.000000001)
+    return;
+  const dx = -(to.y - from.y) / length * 0.01;
+  const dy = (to.x - from.x) / length * 0.01;
+  return [
+    { x: from.x + dx, y: from.y + dy },
+    { x: to.x + dx, y: to.y + dy },
+    { x: to.x - dx, y: to.y - dy },
+    { x: from.x - dx, y: from.y - dy }
+  ];
+}
+function segmentCrossesPolygon(from, to, polygon) {
+  if (Math.hypot(to.x - from.x, to.y - from.y) < 0.000000001)
+    return false;
+  let low = 0;
+  let high = 1;
+  for (let i = 0;i < polygon.length; i++) {
+    const p = polygon[i];
+    const q = polygon[(i + 1) % polygon.length];
+    const length = Math.hypot(q.x - p.x, q.y - p.y);
+    if (length < 0.000000001)
+      continue;
+    const nx = -(q.y - p.y) / length;
+    const ny = (q.x - p.x) / length;
+    const start = (from.x - p.x) * nx + (from.y - p.y) * ny - 0.000001;
+    const end = (to.x - p.x) * nx + (to.y - p.y) * ny - 0.000001;
+    if (start <= 0 && end <= 0)
+      return false;
+    if (start <= 0)
+      low = Math.max(low, -start / (end - start));
+    if (end <= 0)
+      high = Math.min(high, -start / (end - start));
+    if (high <= low)
+      return false;
+  }
+  return high > low;
+}
+var polygonBounds = (polygons) => {
+  const points = polygons.flat();
+  return {
+    left: Math.min(...points.map((p) => p.x)),
+    right: Math.max(...points.map((p) => p.x)),
+    top: Math.max(...points.map((p) => p.y)),
+    bottom: Math.min(...points.map((p) => p.y))
+  };
+};
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
+class SchematicTextClearanceSolver extends BaseSolver21 {
+  params;
+  texts;
+  obstacles;
+  sheetNames;
+  index = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const { ctx } = params2;
+    this.sheetNames = getSchematicSheetNamesById(ctx.circuitJson);
+    const customSymbolIds = new Set(ctx.circuitJson.flatMap((element) => element.type === "schematic_component" && element.is_box_with_pins === false && !element.symbol_name ? [element.schematic_component_id] : []));
+    const seenText = new Set;
+    this.texts = ctx.circuitJson.flatMap((element) => {
+      if (element.type !== "schematic_text")
+        return [];
+      if (element.schematic_component_id || element.schematic_symbol_id || "source_trace_id" in element && element.source_trace_id)
+        return [];
+      const polygons = getSchematicTextPolygons(element);
+      if (!polygons.length)
+        return [];
+      const sheetId = element.schematic_sheet_id;
+      const fingerprint = JSON.stringify([
+        sheetId,
+        element.text,
+        element.position.x,
+        element.position.y,
+        element.font_size,
+        element.anchor,
+        element.rotation,
+        element.color
+      ]);
+      if (seenText.has(fingerprint))
+        return [];
+      seenText.add(fingerprint);
+      return [
+        {
+          text: element,
+          polygons,
+          sheetId,
+          object: {
+            type: "text",
+            id: element.schematic_text_id,
+            text: element.text
+          }
+        }
+      ];
+    });
+    this.obstacles = [
+      ...ctx.componentPlacements.flatMap((p) => p.schematicComponentId && !customSymbolIds.has(p.schematicComponentId) ? [
+        {
+          object: {
+            type: "component",
+            id: p.schematicComponentId,
+            componentName: p.sourceComponentName,
+            schematicComponentId: p.schematicComponentId
+          },
+          polygons: [
+            rectPolygon(centeredRect(p.schX, p.schY, p.width, p.height))
+          ],
+          sheetId: p.schematicSheetId
+        }
+      ] : []),
+      ...ctx.circuitJson.flatMap((element) => element.type === "schematic_trace" ? [
+        {
+          object: {
+            type: "trace",
+            id: element.schematic_trace_id
+          },
+          sheetId: element.schematic_sheet_id,
+          segments: element.edges,
+          polygons: element.edges.flatMap((edge) => {
+            const polygon = traceSegmentPolygon(edge.from, edge.to);
+            return polygon ? [polygon] : [];
+          })
+        }
+      ] : [])
+    ];
+    this.solved = this.texts.length === 0;
+  }
+  _step() {
+    const text = this.texts[this.index];
+    const targets = [...this.obstacles, ...this.texts.slice(this.index + 1)];
+    const collisions = targets.filter((target) => this.collides(text, target));
+    if (collisions.length) {
+      const suggestedMove = this.findClearPosition(text);
+      for (const target of collisions) {
+        this.params.issues.push({
+          lineItemType: "SchematicTextCollision",
+          schematicSheetId: text.sheetId,
+          schematicSheetName: text.sheetId ? this.sheetNames.get(text.sheetId) : undefined,
+          schematicTextId: text.text.schematic_text_id,
+          text: text.text.text,
+          collidingObject: target.object,
+          textBounds: polygonBounds(text.polygons),
+          collidingObjectBounds: polygonBounds(target.polygons),
+          suggestedMove,
+          message: `Text "${text.text.text}" overlaps ${target.object.type} ${target.object.componentName ?? target.object.id}; reposition the text to leave its visible area clear.`
+        });
+      }
+    }
+    this.index++;
+    this.solved = this.index >= this.texts.length;
+  }
+  collides(text, obstacle) {
+    if (text.sheetId !== obstacle.sheetId)
+      return false;
+    return text.polygons.some((a) => obstacle.segments ? obstacle.segments.some((edge) => segmentCrossesPolygon(edge.from, edge.to, a)) : obstacle.polygons.some((b) => polygonsOverlap(a, b)));
+  }
+  findClearPosition(text) {
+    const obstacles = [
+      ...this.obstacles,
+      ...this.texts.filter((t) => t !== text)
+    ];
+    const step = Math.max(0.1, text.text.font_size / 2);
+    for (let distance = step;distance <= Math.max(4, text.text.font_size * 8); distance += step) {
+      for (const [dx, dy] of [
+        [0, distance],
+        [0, -distance],
+        [-distance, 0],
+        [distance, 0]
+      ]) {
+        const newSchX = Math.round((text.text.position.x + dx) * 1000) / 1000;
+        const newSchY = Math.round((text.text.position.y + dy) * 1000) / 1000;
+        const moved = {
+          ...text,
+          polygons: getSchematicTextPolygons({
+            ...text.text,
+            position: { x: newSchX, y: newSchY }
+          })
+        };
+        if (obstacles.every((obstacle) => !this.collides(moved, obstacle)))
+          return { newSchX, newSchY };
+      }
+    }
+    return;
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "schematicTextId", issue.schematicTextId);
+    addAttr(attrs, "text", issue.text);
+    addAttr(attrs, "collidingObjectType", issue.collidingObject.type);
+    addAttr(attrs, "collidingObjectId", issue.collidingObject.id);
+    addAttr(attrs, "newSchX", issue.suggestedMove?.newSchX);
+    addAttr(attrs, "newSchY", issue.suggestedMove?.newSchY);
+    addAttr(attrs, "message", issue.message);
+    return `<SchematicTextCollision ${attrs.join(" ")} />`;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ResetNetworkGroupingSolver/ResetNetworkGroupingSolver.ts
+import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
+class ResetNetworkGroupingSolver extends BaseSolver22 {
+  params;
+  static MIN_DISTANCE = 6;
+  networks;
+  index = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.networks = this.findNetworks(params2.ctx);
+    this.solved = this.networks.length === 0;
+  }
+  _step() {
+    const network = this.networks[this.index];
+    const rcMembers = network.members.slice(0, 2);
+    const threshold = Math.max(ResetNetworkGroupingSolver.MIN_DISTANCE, ...rcMembers.map((p) => 3 * Math.max(p.width, p.height)));
+    const distances = rcMembers.map((p) => Math.hypot(Math.max(0, Math.abs(p.schX - network.pinPosition.x) - p.width / 2), Math.max(0, Math.abs(p.schY - network.pinPosition.y) - p.height / 2)));
+    if (distances.some((distance) => distance > threshold)) {
+      const hostName = network.host.sourceComponentName ?? network.host.schematicComponentId;
+      const resetPin = resetPinName(network.pin);
+      const memberNames = rcMembers.map((p) => p.sourceComponentName ?? p.schematicComponentId).join(", ");
+      this.params.issues.push({
+        lineItemType: "ResetNetworkNotGrouped",
+        hostSchematicBox: network.host,
+        resetSourcePortId: network.pin.source_port_id,
+        resetPinName: resetPin,
+        supportNetworkComponents: network.members,
+        maxDistanceFromResetPin: Math.round(Math.max(...distances) * 100) / 100,
+        maxRecommendedDistance: threshold,
+        message: `Group ${memberNames} near ${hostName}.${resetPin} so the reset pull-up and capacitor can be read together. Preserve all net connections; associated test points may remain in a debug area.`
+      });
+    }
+    this.index++;
+    this.solved = this.index >= this.networks.length;
+  }
+  findNetworks(ctx) {
+    const root = getSourceConnectivity(ctx.circuitJson);
+    const sources = ctx.circuitJson.filter((e) => e.type === "source_component");
+    const sourceById = new Map(sources.map((e) => [e.source_component_id, e]));
+    const ports = ctx.circuitJson.filter((e) => e.type === "source_port");
+    const portsByComponent = new Map;
+    const portsByNet = new Map;
+    const power = new Set;
+    const ground = new Set;
+    for (const port of ports) {
+      if (!port.source_component_id)
+        continue;
+      const componentPorts = portsByComponent.get(port.source_component_id) ?? [];
+      componentPorts.push(port);
+      portsByComponent.set(port.source_component_id, componentPorts);
+      const net = root(port.source_port_id);
+      const netPorts = portsByNet.get(net) ?? [];
+      netPorts.push(port);
+      portsByNet.set(net, netPorts);
+      if (port.provides_power || port.requires_power)
+        power.add(net);
+      if (port.provides_ground || port.requires_ground)
+        ground.add(net);
+    }
+    for (const element of ctx.circuitJson) {
+      if (element.type !== "source_net")
+        continue;
+      if (element.is_power || element.is_positive_voltage_source)
+        power.add(root(element.source_net_id));
+      if (element.is_ground)
+        ground.add(root(element.source_net_id));
+    }
+    const placementBySource = new Map(ctx.componentPlacements.flatMap((p) => p.sourceComponentId ? [[p.sourceComponentId, p]] : []));
+    const schematicPorts = ctx.circuitJson.filter((e) => e.type === "schematic_port");
+    const schematicComponents = new Map(ctx.circuitJson.filter((e) => e.type === "schematic_component").map((e) => [e.schematic_component_id, e]));
+    const networks = [];
+    const seen = new Set;
+    for (const pin of ports) {
+      if (!pin.source_component_id || !resetPinName(pin) || pin.do_not_connect)
+        continue;
+      if (sourceById.get(pin.source_component_id)?.ftype !== "simple_chip")
+        continue;
+      const net = root(pin.source_port_id);
+      if (seen.has(net) || power.has(net) || ground.has(net))
+        continue;
+      seen.add(net);
+      const peers = portsByNet.get(net) ?? [];
+      const chips = new Set(peers.filter((p) => p.source_component_id && sourceById.get(p.source_component_id)?.ftype === "simple_chip").map((p) => p.source_component_id));
+      if (chips.size !== 1)
+        continue;
+      const host = placementBySource.get(pin.source_component_id);
+      const schematicPin = schematicPorts.find((p) => p.source_port_id === pin.source_port_id && p.schematic_component_id === host?.schematicComponentId);
+      if (!host || !schematicPin || schematicPin.schematic_sheet_id !== host.schematicSheetId)
+        continue;
+      const pullups = [];
+      const capacitors = [];
+      const testpoints = [];
+      let unsupported = false;
+      for (const id of new Set(peers.map((p) => p.source_component_id))) {
+        if (!id || id === pin.source_component_id)
+          continue;
+        const type = sourceById.get(id)?.ftype;
+        const componentPorts = portsByComponent.get(id) ?? [];
+        const placement = placementBySource.get(id);
+        if (type === "simple_connector" || type === "simple_pin_header")
+          continue;
+        if (!placement) {
+          unsupported = true;
+          break;
+        }
+        if (type === "simple_test_point" && componentPorts.length === 1) {
+          testpoints.push(placement);
+          continue;
+        }
+        if (componentPorts.length !== 2) {
+          unsupported = true;
+          break;
+        }
+        const other = componentPorts.find((p) => root(p.source_port_id) !== net);
+        if (!other) {
+          unsupported = true;
+          break;
+        }
+        const otherNet = root(other.source_port_id);
+        if (type === "simple_resistor" && power.has(otherNet) && !ground.has(otherNet))
+          pullups.push(placement);
+        else if (type === "simple_capacitor" && ground.has(otherNet) && !power.has(otherNet))
+          capacitors.push(placement);
+        else {
+          unsupported = true;
+          break;
+        }
+      }
+      if (unsupported || pullups.length !== 1 || capacitors.length !== 1)
+        continue;
+      const members = [...pullups, ...capacitors, ...testpoints];
+      const hostGroup = host.schematicComponentId ? schematicComponents.get(host.schematicComponentId)?.schematic_group_id : undefined;
+      if (members.some((member) => {
+        const group = member.schematicComponentId ? schematicComponents.get(member.schematicComponentId)?.schematic_group_id : undefined;
+        return member.schematicSheetId !== host.schematicSheetId || member.subcircuitId !== host.subcircuitId || group !== hostGroup;
+      }))
+        continue;
+      networks.push({ host, pin, pinPosition: schematicPin.center, members });
+    }
+    return networks;
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "hostComponentName", issue.hostSchematicBox.sourceComponentName);
+    addAttr(attrs, "resetPin", issue.resetPinName);
+    addAttr(attrs, "supportNetworkComponents", issue.supportNetworkComponents.map((p) => p.sourceComponentName ?? p.schematicComponentId).join(","));
+    addAttr(attrs, "maxDistanceFromResetPin", issue.maxDistanceFromResetPin);
+    addAttr(attrs, "maxRecommendedDistance", issue.maxRecommendedDistance);
+    addAttr(attrs, "message", issue.message);
+    return `<ResetNetworkNotGrouped ${attrs.join(" ")} />`;
+  }
+}
+var resetPinName = (port) => [port.name, ...port.port_hints ?? []].find((name) => /^N?(RESET|RST)(N|B)?$/.test(name.toUpperCase().replace(/[_\-!~#/]/g, "")));
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
 class SchematicPlacementPipeline extends BasePipelineSolver2 {
   ctx;
   issues = [];
   pipelineDef = [
+    definePipelineStep3("SchematicTextClearanceSolver", SchematicTextClearanceSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("ResetNetworkGroupingSolver", ResetNetworkGroupingSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("SchematicBoxOverlapSolver", SchematicBoxOverlapSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
@@ -321240,16 +322648,35 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     definePipelineStep3("TraceSimplificationSolver", TraceSimplificationSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
+    definePipelineStep3("CrystalLoadCapacitorPlacementSolver", CrystalLoadCapacitorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("TwoPinComponentOrientationSolver", TwoPinComponentOrientationSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("FeedbackNetworkPlacementSolver", FeedbackNetworkPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("TwoPinComponentRailOrientationSolver", TwoPinComponentRailOrientationSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("PullResistorPlacementSolver", PullResistorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("ComponentNetLabelCollisionSolver", ComponentNetLabelCollisionSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("DecouplingCapacitorGroupingSolver", DecouplingCapacitorGroupingSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
     ])
   ];
   _setup() {
     this.ctx = buildSolverContext(this.inputProblem);
   }
   getOutput() {
+    const railOrientationComponentIds = new Set(this.issues.flatMap((issue) => issue.lineItemType === "TwoPinComponentShouldBeVertical" && issue.schematicBox.schematicComponentId ? [issue.schematicBox.schematicComponentId] : []));
     return {
-      issues: this.issues,
+      issues: this.issues.filter((issue) => issue.lineItemType !== "CapacitorSymbolHorizontal" || !railOrientationComponentIds.has(issue.schematicBox.schematicComponentId ?? "")),
       componentPlacements: this.ctx.componentPlacements
     };
   }
@@ -321292,6 +322719,27 @@ var getRelevantPlacementsForIssues = ({
   };
   for (const issue of issues) {
     switch (issue.lineItemType) {
+      case "DecouplingCapacitorsNotCloseTogether":
+        for (const placement of issue.capacitorSchematicBoxes)
+          addPlacement(placement);
+        break;
+      case "ResetNetworkNotGrouped":
+        addPlacement(issue.hostSchematicBox);
+        for (const placement of issue.supportNetworkComponents)
+          addPlacement(placement);
+        break;
+      case "SchematicTextCollision":
+        if (issue.collidingObject.schematicComponentId)
+          addPlacement(placementByComponentId.get(issue.collidingObject.schematicComponentId));
+        if (issue.collidingObject.type === "trace") {
+          for (const placement of getTraceEndpointPlacements({
+            schematicTraceId: issue.collidingObject.id,
+            circuitJson,
+            placementByComponentId
+          }))
+            addPlacement(placement);
+        }
+        break;
       case "ComponentOverlap":
         addPlacement(issue.firstComponent);
         addPlacement(issue.secondComponent);
@@ -321328,6 +322776,27 @@ var getRelevantPlacementsForIssues = ({
           relevantPlacements.add(placement);
         }
         break;
+      case "CrystalNotCenteredOverLoadCapacitors":
+        addPlacement(issue.crystalSchematicBox);
+        addPlacement(issue.firstLoadCapacitorSchematicBox);
+        addPlacement(issue.secondLoadCapacitorSchematicBox);
+        break;
+      case "TwoPinComponentCouldBeFlipped":
+        addPlacement(issue.targetComponent);
+        addPlacement(issue.connectedComponent);
+        break;
+      case "FeedbackNetworkNotCompact":
+        addPlacement(issue.amplifierSchematicBox);
+        for (const component of issue.feedbackComponents)
+          addPlacement(component);
+        break;
+      case "TwoPinComponentShouldBeVertical":
+        addPlacement(issue.schematicBox);
+        break;
+      case "PullResistorOnWrongSide":
+        addPlacement(issue.resistorSchematicBox);
+        addPlacement(issue.hostSchematicBox);
+        break;
       case "ComponentNetLabelCollision":
         addPlacement(issue.firstComponent);
         addPlacement(issue.secondComponent);
@@ -321357,7 +322826,7 @@ var getIssueSchematicSheetContext = (issue) => {
       return { schematicSheetId, schematicSheetName };
     }
   }
-  for (const value of Object.values(issue)) {
+  for (const value of Object.values(issue).flat()) {
     if (isSchematicBoxPlacement(value)) {
       return {
         schematicSheetId: value.schematicSheetId,
@@ -321406,6 +322875,38 @@ class SchematicPlacementAnalysis {
   getLineItems() {
     return this.lineItems;
   }
+  getIssues(filter = {}) {
+    return this.lineItems.flatMap((item) => item.lineItemType === "SchematicPlacementIssues" ? item.issues : []).filter((issue) => (filter.issueTypes === undefined || filter.issueTypes.includes(issue.lineItemType)) && (filter.schematicSheetId === undefined || (getIssueSchematicSheetContext(issue).schematicSheetId ?? "") === filter.schematicSheetId));
+  }
+  getIssueCounts(filter = {}) {
+    const counts = {
+      ComponentOverlap: 0,
+      SchematicBoxHasALotOfSurroundingWhitespace: 0,
+      CapacitorSymbolHorizontal: 0,
+      VerboseSchematicNetLabel: 0,
+      PinHeaderSchematicBoxTooWide: 0,
+      GenericSchematicBoxTooWide: 0,
+      SchematicBoxInnerLabelCollision: 0,
+      SchematicPinPaddingToEdgeTooLarge: 0,
+      DiodeResistorNotAligned: 0,
+      ComponentPinsWouldAlignWithVerticalShift: 0,
+      TraceCanBeSimplifiedByMovingComponent: 0,
+      CrystalNotCenteredOverLoadCapacitors: 0,
+      ComponentNetLabelCollision: 0,
+      ComponentBoxNetLabelCollision: 0,
+      NetLabelCollision: 0,
+      FeedbackNetworkNotCompact: 0,
+      PullResistorOnWrongSide: 0,
+      SchematicTextCollision: 0,
+      ResetNetworkNotGrouped: 0,
+      TwoPinComponentCouldBeFlipped: 0,
+      TwoPinComponentShouldBeVertical: 0,
+      DecouplingCapacitorsNotCloseTogether: 0
+    };
+    for (const issue of this.getIssues(filter))
+      counts[issue.lineItemType]++;
+    return counts;
+  }
   getString() {
     return this.toString();
   }
@@ -321425,6 +322926,8 @@ class SchematicPlacementAnalysis {
         return SchematicBoxOverlapSolver.issueToString(issue);
       case "CapacitorSymbolHorizontal":
         return CapacitorOrientationSolver.issueToString(issue);
+      case "DecouplingCapacitorsNotCloseTogether":
+        return DecouplingCapacitorGroupingSolver.issueToString(issue);
       case "VerboseSchematicNetLabel":
         return VerboseNetLabelSolver.issueToString(issue);
       case "PinHeaderSchematicBoxTooWide":
@@ -321440,8 +322943,22 @@ class SchematicPlacementAnalysis {
         return ComponentPinAlignmentSolver.issueToString(issue);
       case "TraceCanBeSimplifiedByMovingComponent":
         return TraceSimplificationSolver.issueToString(issue);
+      case "CrystalNotCenteredOverLoadCapacitors":
+        return CrystalLoadCapacitorPlacementSolver.issueToString(issue);
+      case "TwoPinComponentCouldBeFlipped":
+        return TwoPinComponentOrientationSolver.issueToString(issue);
+      case "FeedbackNetworkNotCompact":
+        return FeedbackNetworkPlacementSolver.issueToString(issue);
+      case "TwoPinComponentShouldBeVertical":
+        return TwoPinComponentRailOrientationSolver.issueToString(issue);
+      case "PullResistorOnWrongSide":
+        return PullResistorPlacementSolver.issueToString(issue);
       case "NetLabelCollision":
         return ComponentNetLabelCollisionSolver.netLabelCollisionToString(issue);
+      case "SchematicTextCollision":
+        return SchematicTextClearanceSolver.issueToString(issue);
+      case "ResetNetworkNotGrouped":
+        return ResetNetworkGroupingSolver.issueToString(issue);
       default:
         return "";
     }
@@ -321515,6 +323032,8 @@ var analyzeSchematicPlacement = (circuitJson) => {
   const schematicSheetIds = new Set(circuitJson.flatMap((element) => ("schematic_sheet_id" in element) && typeof element.schematic_sheet_id === "string" ? [element.schematic_sheet_id] : []));
   return new SchematicPlacementAnalysis(lineItems, schematicSheetIds.size > 1);
 };
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/svg/create-issue-overlay-svg.ts
+import { convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg4 } from "circuit-to-svg";
 // cli/check/schematic-placement/register.ts
 var checkSchematicPlacement = async (file) => {
   const resolvedInputFilePath = await resolveCheckInputFilePath(file);
@@ -338902,7 +340421,7 @@ var import_jszip5 = __toESM3(require_lib4(), 1);
 
 // lib/shared/convert-circuit-json-to-schematic-pdf.ts
 var import_pdf_lib = __toESM3(require_cjs(), 1);
-import { convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg4 } from "circuit-to-svg";
+import { convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg5 } from "circuit-to-svg";
 var A4_LANDSCAPE_WIDTH = 841.89;
 var A4_LANDSCAPE_HEIGHT = 595.28;
 var RENDER_SCALE = 2;
@@ -338912,7 +340431,7 @@ var convertCircuitJsonToSchematicPdf = async (circuitJson) => {
   const schematicSheets = getSchematicSheets(circuitJson);
   const pages = schematicSheets.length > 0 ? schematicSheets : [undefined];
   for (const schematicSheet of pages) {
-    const schematicSvg = convertCircuitJsonToSchematicSvg4(circuitJson, {
+    const schematicSvg = convertCircuitJsonToSchematicSvg5(circuitJson, {
       width: Math.round(A4_LANDSCAPE_WIDTH * RENDER_SCALE),
       height: Math.round(A4_LANDSCAPE_HEIGHT * RENDER_SCALE),
       schematicSheetId: schematicSheet?.schematic_sheet_id
@@ -340778,7 +342297,7 @@ __export5(dist_exports, {
   capacitance: () => capacitance4,
   circuit_json_footprint_load_error: () => circuit_json_footprint_load_error2,
   current: () => current2,
-  distance: () => distance49,
+  distance: () => distance50,
   duration_ms: () => duration_ms,
   experiment_type: () => experiment_type,
   external_footprint_load_error: () => external_footprint_load_error2,
@@ -345245,7 +346764,7 @@ var inductance2 = external_exports2.string().or(external_exports2.number()).tran
 var voltage5 = external_exports2.string().or(external_exports2.number()).transform((v) => parseAndConvertSiUnit(v, "V").value);
 var length67 = external_exports2.string().or(external_exports2.number()).transform((v) => parseAndConvertSiUnit(v).value);
 var frequency7 = external_exports2.string().or(external_exports2.number()).transform((v) => parseAndConvertSiUnit(v, "Hz").value);
-var distance49 = length67;
+var distance50 = length67;
 var current2 = external_exports2.string().or(external_exports2.number()).transform((v) => parseAndConvertSiUnit(v, "A").value);
 var duration_ms = external_exports2.string().or(external_exports2.number()).transform((v) => parseAndConvertSiUnit(v).value);
 var time = duration_ms;
@@ -345286,16 +346805,16 @@ expectStringUnionsMatch('T2 has extra: "c"');
 expectStringUnionsMatch('T1 has extra: "d", T2 has extra: "c"');
 expectStringUnionsMatch(true);
 var point9 = external_exports2.object({
-  x: distance49,
-  y: distance49
+  x: distance50,
+  y: distance50
 });
 var position = point9;
 expectTypesMatch2(true);
 expectTypesMatch2(true);
 var point33 = external_exports2.object({
-  x: distance49,
-  y: distance49,
-  z: distance49
+  x: distance50,
+  y: distance50,
+  z: distance50
 });
 var position3 = point33;
 expectTypesMatch2(true);
@@ -345360,7 +346879,7 @@ var kicadAt2 = point9.extend({
 expectTypesMatch2(true);
 var kicadFont2 = external_exports2.object({
   size: point9.optional(),
-  thickness: distance49.optional()
+  thickness: distance50.optional()
 });
 expectTypesMatch2(true);
 var kicadEffects2 = external_exports2.object({
@@ -345396,7 +346915,7 @@ var kicadFootprintPad2 = external_exports2.object({
   shape: external_exports2.string().optional(),
   at: kicadAt2.optional(),
   size: point9.optional(),
-  drill: distance49.optional(),
+  drill: distance50.optional(),
   layers: external_exports2.array(external_exports2.string()).optional(),
   removeUnusedLayers: external_exports2.boolean().optional(),
   uuid: external_exports2.string().optional()
@@ -345427,7 +346946,7 @@ var kicadSymbolPinNumbers2 = external_exports2.object({
 });
 expectTypesMatch2(true);
 var kicadSymbolPinNames2 = external_exports2.object({
-  offset: distance49.optional(),
+  offset: distance50.optional(),
   hide: external_exports2.boolean().optional()
 });
 expectTypesMatch2(true);
@@ -345501,7 +347020,7 @@ var source_simple_capacitor = source_component_base.extend({
   capacitance: capacitance4,
   max_voltage_rating: voltage5.optional(),
   display_capacitance: external_exports2.string().optional(),
-  max_decoupling_trace_length: distance49.optional()
+  max_decoupling_trace_length: distance50.optional()
 });
 expectTypesMatch2(true);
 var source_simple_resistor = source_component_base.extend({
@@ -346059,11 +347578,11 @@ var schematic_box = external_exports2.object({
   schematic_sheet_id: external_exports2.string().optional(),
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
-  width: distance49,
-  height: distance49,
+  width: distance50,
+  height: distance50,
   is_dashed: external_exports2.boolean().default(false),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   subcircuit_id: external_exports2.string().optional()
 }).describe("Draws a box on the schematic");
 expectTypesMatch2(true);
@@ -346076,10 +347595,10 @@ var schematic_path = external_exports2.object({
   fill_color: external_exports2.string().optional(),
   is_filled: external_exports2.boolean().optional(),
   is_dashed: external_exports2.boolean().default(false),
-  stroke_width: distance49.nullable().optional(),
+  stroke_width: distance50.nullable().optional(),
   stroke_color: external_exports2.string().optional(),
-  dash_length: distance49.optional(),
-  dash_gap: distance49.optional(),
+  dash_length: distance50.optional(),
+  dash_gap: distance50.optional(),
   points: external_exports2.array(point9),
   subcircuit_id: external_exports2.string().optional()
 });
@@ -346158,15 +347677,15 @@ var schematic_line = external_exports2.object({
   schematic_sheet_id: external_exports2.string().optional(),
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
-  x1: distance49,
-  y1: distance49,
-  x2: distance49,
-  y2: distance49,
-  stroke_width: distance49.nullable().optional(),
+  x1: distance50,
+  y1: distance50,
+  x2: distance50,
+  y2: distance50,
+  stroke_width: distance50.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_dashed: external_exports2.boolean().default(false),
-  dash_length: distance49.optional(),
-  dash_gap: distance49.optional(),
+  dash_length: distance50.optional(),
+  dash_gap: distance50.optional(),
   subcircuit_id: external_exports2.string().optional()
 }).describe("Draws a styled line on the schematic");
 expectTypesMatch2(true);
@@ -346177,10 +347696,10 @@ var schematic_rect = external_exports2.object({
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
   center: point9,
-  width: distance49,
-  height: distance49,
+  width: distance50,
+  height: distance50,
   rotation: rotation11.default(0),
-  stroke_width: distance49.nullable().optional(),
+  stroke_width: distance50.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_filled: external_exports2.boolean().default(false),
   fill_color: external_exports2.string().optional(),
@@ -346195,8 +347714,8 @@ var schematic_circle = external_exports2.object({
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
   center: point9,
-  radius: distance49,
-  stroke_width: distance49.nullable().optional(),
+  radius: distance50,
+  stroke_width: distance50.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_filled: external_exports2.boolean().default(false),
   fill_color: external_exports2.string().optional(),
@@ -346211,11 +347730,11 @@ var schematic_arc = external_exports2.object({
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
   center: point9,
-  radius: distance49,
+  radius: distance50,
   start_angle_degrees: rotation11,
   end_angle_degrees: rotation11,
   direction: external_exports2.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
-  stroke_width: distance49.nullable().optional(),
+  stroke_width: distance50.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_dashed: external_exports2.boolean().default(false),
   subcircuit_id: external_exports2.string().optional()
@@ -346265,8 +347784,8 @@ var schematic_text = external_exports2.object({
   text: external_exports2.string(),
   font_size: external_exports2.number().default(0.18),
   position: external_exports2.object({
-    x: distance49,
-    y: distance49
+    x: distance50,
+    y: distance50
   }),
   rotation: external_exports2.number().default(0),
   anchor: external_exports2.union([fivePointAnchor2.describe("legacy"), ninePointAnchor2]).default("center"),
@@ -346436,10 +347955,10 @@ var schematic_table = external_exports2.object({
   schematic_table_id: getZodPrefixedIdWithDefault("schematic_table"),
   schematic_sheet_id: external_exports2.string().optional(),
   anchor_position: point9,
-  column_widths: external_exports2.array(distance49),
-  row_heights: external_exports2.array(distance49),
-  cell_padding: distance49.optional(),
-  border_width: distance49.optional(),
+  column_widths: external_exports2.array(distance50),
+  row_heights: external_exports2.array(distance50),
+  cell_padding: distance50.optional(),
+  border_width: distance50.optional(),
   subcircuit_id: external_exports2.string().optional(),
   schematic_component_id: external_exports2.string().optional(),
   anchor: ninePointAnchor2.optional()
@@ -346456,11 +347975,11 @@ var schematic_table_cell = external_exports2.object({
   end_column_index: external_exports2.number(),
   text: external_exports2.string().optional(),
   center: point9,
-  width: distance49,
-  height: distance49,
+  width: distance50,
+  height: distance50,
   horizontal_align: external_exports2.enum(["left", "center", "right"]).optional(),
   vertical_align: external_exports2.enum(["top", "middle", "bottom"]).optional(),
-  font_size: distance49.optional(),
+  font_size: distance50.optional(),
   subcircuit_id: external_exports2.string().optional()
 }).describe("Defines a cell within a schematic_table");
 expectTypesMatch2(true);
@@ -346474,8 +347993,8 @@ var schematic_sheet = external_exports2.object({
 }).describe("Defines a schematic sheet or page that components can be placed on");
 expectTypesMatch2(true);
 var point_with_bulge = external_exports2.object({
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   bulge: external_exports2.number().optional()
 });
 expectTypesMatch2(true);
@@ -346566,8 +348085,8 @@ var getRotationBetweenPcbPin1Locations2 = (from, to) => {
   return null;
 };
 var pcb_route_hint = external_exports2.object({
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   via: external_exports2.boolean().optional(),
   via_to_layer: layer_ref2.optional()
 });
@@ -346575,11 +348094,11 @@ var pcb_route_hints = external_exports2.array(pcb_route_hint);
 expectTypesMatch2(true);
 expectTypesMatch2(true);
 var route_hint_point8 = external_exports2.object({
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   via: external_exports2.boolean().optional(),
   to_layer: layer_ref2.optional(),
-  trace_width: distance49.optional()
+  trace_width: distance50.optional()
 });
 expectTypesMatch2(true);
 var manufacturing_drc_properties = external_exports2.object({
@@ -346664,8 +348183,8 @@ var pcb_hole_circle = external_exports2.object({
   pcb_component_id: external_exports2.string().optional(),
   hole_shape: external_exports2.literal("circle"),
   hole_diameter: external_exports2.number(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -346680,8 +348199,8 @@ var pcb_hole_rect = external_exports2.object({
   hole_shape: external_exports2.literal("rect"),
   hole_width: external_exports2.number(),
   hole_height: external_exports2.number(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -346695,8 +348214,8 @@ var pcb_hole_circle_or_square = external_exports2.object({
   pcb_component_id: external_exports2.string().optional(),
   hole_shape: external_exports2.enum(["circle", "square"]),
   hole_diameter: external_exports2.number(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -346711,8 +348230,8 @@ var pcb_hole_oval = external_exports2.object({
   hole_shape: external_exports2.literal("oval"),
   hole_width: external_exports2.number(),
   hole_height: external_exports2.number(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -346727,8 +348246,8 @@ var pcb_hole_pill = external_exports2.object({
   hole_shape: external_exports2.literal("pill"),
   hole_width: external_exports2.number(),
   hole_height: external_exports2.number(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -346743,8 +348262,8 @@ var pcb_hole_rotated_pill = external_exports2.object({
   hole_shape: external_exports2.literal("rotated_pill"),
   hole_width: external_exports2.number(),
   hole_height: external_exports2.number(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   ccw_rotation: rotation11,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
@@ -346760,8 +348279,8 @@ var pcb_plated_hole_circle = external_exports2.object({
   outer_diameter: external_exports2.number(),
   hole_diameter: external_exports2.number(),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -346779,8 +348298,8 @@ var pcb_plated_hole_oval = external_exports2.object({
   hole_width: external_exports2.number(),
   hole_height: external_exports2.number(),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   ccw_rotation: rotation11,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
@@ -346800,11 +348319,11 @@ var pcb_circular_hole_with_rect_pad = external_exports2.object({
   rect_pad_width: external_exports2.number(),
   rect_pad_height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
-  hole_offset_x: distance49.default(0),
-  hole_offset_y: distance49.default(0),
+  hole_offset_x: distance50.default(0),
+  hole_offset_y: distance50.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -346825,11 +348344,11 @@ var pcb_pill_hole_with_rect_pad = external_exports2.object({
   rect_pad_width: external_exports2.number(),
   rect_pad_height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
-  hole_offset_x: distance49.default(0),
-  hole_offset_y: distance49.default(0),
+  hole_offset_x: distance50.default(0),
+  hole_offset_y: distance50.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -346851,11 +348370,11 @@ var pcb_rotated_pill_hole_with_rect_pad = external_exports2.object({
   rect_pad_height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
   rect_ccw_rotation: rotation11,
-  hole_offset_x: distance49.default(0),
-  hole_offset_y: distance49.default(0),
+  hole_offset_x: distance50.default(0),
+  hole_offset_y: distance50.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -346873,14 +348392,14 @@ var pcb_hole_with_polygon_pad = external_exports2.object({
   hole_width: external_exports2.number().optional(),
   hole_height: external_exports2.number().optional(),
   pad_outline: external_exports2.array(external_exports2.object({
-    x: distance49,
-    y: distance49
+    x: distance50,
+    y: distance50
   })).min(3),
-  hole_offset_x: distance49.default(0),
-  hole_offset_y: distance49.default(0),
+  hole_offset_x: distance50.default(0),
+  hole_offset_y: distance50.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -346910,8 +348429,8 @@ var pcb_port = external_exports2.object({
   subcircuit_id: external_exports2.string().optional(),
   source_port_id: external_exports2.string(),
   pcb_component_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   layers: external_exports2.array(layer_ref2),
   is_board_pinout: external_exports2.boolean().optional()
 }).describe("Defines a port on the PCB");
@@ -346922,8 +348441,8 @@ var pcb_smtpad_circle = external_exports2.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   radius: external_exports2.number(),
   layer: layer_ref2,
   port_hints: external_exports2.array(external_exports2.string()).optional(),
@@ -346939,8 +348458,8 @@ var pcb_smtpad_rect = external_exports2.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
@@ -346963,8 +348482,8 @@ var pcb_smtpad_rotated_rect = external_exports2.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
@@ -346988,8 +348507,8 @@ var pcb_smtpad_pill = external_exports2.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -347007,8 +348526,8 @@ var pcb_smtpad_rotated_pill = external_exports2.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -347056,8 +348575,8 @@ var pcb_solder_paste_circle = external_exports2.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   radius: external_exports2.number(),
   layer: layer_ref2,
   pcb_component_id: external_exports2.string().optional(),
@@ -347069,8 +348588,8 @@ var pcb_solder_paste_rect = external_exports2.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   layer: layer_ref2,
@@ -347083,8 +348602,8 @@ var pcb_solder_paste_pill = external_exports2.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -347098,11 +348617,11 @@ var pcb_solder_paste_rotated_rect = external_exports2.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
-  ccw_rotation: distance49,
+  ccw_rotation: distance50,
   layer: layer_ref2,
   pcb_component_id: external_exports2.string().optional(),
   pcb_smtpad_id: external_exports2.string().optional()
@@ -347113,8 +348632,8 @@ var pcb_solder_paste_rotated_pill = external_exports2.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -347129,8 +348648,8 @@ var pcb_solder_paste_oval = external_exports2.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   width: external_exports2.number(),
   height: external_exports2.number(),
   layer: layer_ref2,
@@ -347167,9 +348686,9 @@ var pcb_text = external_exports2.object({
 expectTypesMatch2(true);
 var pcb_trace_route_point_wire = external_exports2.object({
   route_type: external_exports2.literal("wire"),
-  x: distance49,
-  y: distance49,
-  width: distance49,
+  x: distance50,
+  y: distance50,
+  width: distance50,
   copper_pour_id: external_exports2.string().optional(),
   is_inside_copper_pour: external_exports2.boolean().optional(),
   start_pcb_port_id: external_exports2.string().optional(),
@@ -347178,12 +348697,12 @@ var pcb_trace_route_point_wire = external_exports2.object({
 });
 var pcb_trace_route_point_via = external_exports2.object({
   route_type: external_exports2.literal("via"),
-  x: distance49,
-  y: distance49,
+  x: distance50,
+  y: distance50,
   copper_pour_id: external_exports2.string().optional(),
   is_inside_copper_pour: external_exports2.boolean().optional(),
-  hole_diameter: distance49.optional(),
-  outer_diameter: distance49.optional(),
+  hole_diameter: distance50.optional(),
+  outer_diameter: distance50.optional(),
   from_layer: layer_ref2,
   to_layer: layer_ref2
 });
@@ -347191,7 +348710,7 @@ var pcb_trace_route_point_through_pad = external_exports2.object({
   route_type: external_exports2.literal("through_pad"),
   start: point9,
   end: point9,
-  width: distance49,
+  width: distance50,
   start_layer: layer_ref2,
   end_layer: layer_ref2,
   pcb_smtpad_id: external_exports2.string().optional(),
@@ -347239,8 +348758,8 @@ var pcb_trace_too_long_warning = external_exports2.object({
   pcb_trace_id: external_exports2.string(),
   source_net_id: external_exports2.string().optional(),
   source_trace_id: external_exports2.string().optional(),
-  actual_trace_length: distance49,
-  maximum_trace_length: distance49,
+  actual_trace_length: distance50,
+  maximum_trace_length: distance50,
   subcircuit_id: external_exports2.string().optional()
 }).describe("Warning emitted when a PCB trace is longer than its maximum allowed length");
 expectTypesMatch2(true);
@@ -347310,10 +348829,10 @@ var pcb_via = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   subcircuit_connectivity_map_key: external_exports2.string().optional(),
-  x: distance49,
-  y: distance49,
-  outer_diameter: distance49.default("0.6mm"),
-  hole_diameter: distance49.default("0.25mm"),
+  x: distance50,
+  y: distance50,
+  outer_diameter: distance50.default("0.6mm"),
+  hole_diameter: distance50.default("0.25mm"),
   from_layer: layer_ref2.optional(),
   to_layer: layer_ref2.optional(),
   layers: external_exports2.array(layer_ref2),
@@ -347401,11 +348920,11 @@ var pcb_silkscreen_line = external_exports2.object({
   pcb_component_id: external_exports2.string(),
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
-  stroke_width: distance49.default("0.1mm"),
-  x1: distance49,
-  y1: distance49,
-  x2: distance49,
-  y2: distance49,
+  stroke_width: distance50.default("0.1mm"),
+  x1: distance50,
+  y1: distance50,
+  x2: distance50,
+  y2: distance50,
   layer: visible_layer
 }).describe("Defines a silkscreen line on the PCB");
 expectTypesMatch2(true);
@@ -347426,7 +348945,7 @@ var pcb_silkscreen_text = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   font: external_exports2.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance49.default("0.2mm"),
+  font_size: distance50.default("0.2mm"),
   pcb_component_id: external_exports2.string(),
   text: external_exports2.string(),
   is_knockout: external_exports2.boolean().default(false).optional(),
@@ -347454,7 +348973,7 @@ var pcb_copper_text = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   font: external_exports2.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance49.default("0.2mm"),
+  font_size: distance50.default("0.2mm"),
   pcb_component_id: external_exports2.string(),
   text: external_exports2.string(),
   is_knockout: external_exports2.boolean().default(false).optional(),
@@ -347514,8 +349033,8 @@ var pcb_silkscreen_oval = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   center: point9,
-  radius_x: distance49,
-  radius_y: distance49,
+  radius_x: distance50,
+  radius_y: distance50,
   layer: visible_layer,
   ccw_rotation: rotation11.optional()
 }).describe("Defines a silkscreen oval on the PCB");
@@ -347555,7 +349074,7 @@ var pcb_fabrication_note_text2 = external_exports2.object({
   subcircuit_id: external_exports2.string().optional(),
   pcb_group_id: external_exports2.string().optional(),
   font: external_exports2.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance49.default("1mm"),
+  font_size: distance50.default("1mm"),
   pcb_component_id: external_exports2.string(),
   text: external_exports2.string(),
   ccw_rotation: external_exports2.number().optional(),
@@ -347625,7 +349144,7 @@ var pcb_note_text2 = external_exports2.object({
   subcircuit_id: external_exports2.string().optional(),
   name: external_exports2.string().optional(),
   font: external_exports2.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance49.default("1mm"),
+  font_size: distance50.default("1mm"),
   text: external_exports2.string().optional(),
   anchor_position: point9.default({ x: 0, y: 0 }),
   anchor_alignment: external_exports2.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
@@ -347676,12 +349195,12 @@ var pcb_note_line2 = external_exports2.object({
   subcircuit_id: external_exports2.string().optional(),
   name: external_exports2.string().optional(),
   text: external_exports2.string().optional(),
-  x1: distance49,
-  y1: distance49,
-  x2: distance49,
-  y2: distance49,
+  x1: distance50,
+  y1: distance50,
+  x2: distance50,
+  y2: distance50,
   layer: visible_layer.default("top"),
-  stroke_width: distance49.default("0.1mm"),
+  stroke_width: distance50.default("0.1mm"),
   color: external_exports2.string().optional(),
   is_dashed: external_exports2.boolean().optional()
 }).describe("Defines a straight documentation note line on the PCB");
@@ -347732,8 +349251,8 @@ var pcb_keepout2 = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   center: point9,
-  width: distance49,
-  height: distance49,
+  width: distance50,
+  height: distance50,
   pcb_keepout_id: external_exports2.string(),
   layers: external_exports2.array(external_exports2.string()),
   description: external_exports2.string().optional(),
@@ -347744,7 +349263,7 @@ var pcb_keepout2 = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   center: point9,
-  radius: distance49,
+  radius: distance50,
   pcb_keepout_id: external_exports2.string(),
   layers: external_exports2.array(external_exports2.string()),
   description: external_exports2.string().optional(),
@@ -347920,8 +349439,8 @@ var pcb_breakout_point = external_exports2.object({
   source_port_id: external_exports2.string().optional(),
   source_net_id: external_exports2.string().optional(),
   layer: layer_ref2.optional(),
-  x: distance49,
-  y: distance49
+  x: distance50,
+  y: distance50
 }).describe("Defines a routing target within a pcb_group for a source_trace or source_net");
 expectTypesMatch2(true);
 var pcb_ground_plane = external_exports2.object({
@@ -347949,9 +349468,9 @@ var pcb_thermal_spoke = external_exports2.object({
   pcb_ground_plane_id: external_exports2.string(),
   shape: external_exports2.string(),
   spoke_count: external_exports2.number(),
-  spoke_thickness: distance49,
-  spoke_inner_diameter: distance49,
-  spoke_outer_diameter: distance49,
+  spoke_thickness: distance50,
+  spoke_inner_diameter: distance50,
+  spoke_outer_diameter: distance50,
   pcb_plated_hole_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional()
 }).describe("Pattern for connecting a ground plane to a plated hole");
@@ -348033,8 +349552,8 @@ var pcb_via_clearance_error = base_circuit_json_error.extend({
   pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
   error_type: external_exports2.literal("pcb_via_clearance_error").default("pcb_via_clearance_error"),
   pcb_via_ids: external_exports2.array(external_exports2.string()).min(2),
-  minimum_clearance: distance49.optional(),
-  actual_clearance: distance49.optional(),
+  minimum_clearance: distance50.optional(),
+  actual_clearance: distance50.optional(),
   pcb_center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -348048,8 +349567,8 @@ var pcb_via_trace_clearance_error = base_circuit_json_error.extend({
   error_type: external_exports2.literal("pcb_via_trace_clearance_error").default("pcb_via_trace_clearance_error"),
   pcb_via_id: external_exports2.string(),
   pcb_trace_id: external_exports2.string(),
-  minimum_clearance: distance49.optional(),
-  actual_clearance: distance49.optional(),
+  minimum_clearance: distance50.optional(),
+  actual_clearance: distance50.optional(),
   center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -348062,8 +349581,8 @@ var pcb_pad_pad_clearance_error = base_circuit_json_error.extend({
   pcb_pad_pad_clearance_error_id: getZodPrefixedIdWithDefault("pcb_pad_pad_clearance_error"),
   error_type: external_exports2.literal("pcb_pad_pad_clearance_error").default("pcb_pad_pad_clearance_error"),
   pcb_pad_ids: external_exports2.array(external_exports2.string()).min(2),
-  minimum_clearance: distance49.optional(),
-  actual_clearance: distance49.optional(),
+  minimum_clearance: distance50.optional(),
+  actual_clearance: distance50.optional(),
   center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -348077,8 +349596,8 @@ var pcb_pad_trace_clearance_error = base_circuit_json_error.extend({
   error_type: external_exports2.literal("pcb_pad_trace_clearance_error").default("pcb_pad_trace_clearance_error"),
   pcb_pad_id: external_exports2.string(),
   pcb_trace_id: external_exports2.string(),
-  minimum_clearance: distance49.optional(),
-  actual_clearance: distance49.optional(),
+  minimum_clearance: distance50.optional(),
+  actual_clearance: distance50.optional(),
   center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -352284,14 +353803,14 @@ var getEasyEdaCadModelPlacement = async (easyEdaJson, { fetch: fetch2 = globalTh
   placementCache.set(cacheKey, placementPromise);
   return placementPromise;
 };
-var round = (value) => Number(value.toFixed(6));
+var round2 = (value) => Number(value.toFixed(6));
 var EASYEDA_SCHEMATIC_UNIT_TO_TSCIRCUIT_UNIT = 0.02;
-var toSchematicUnits = (value) => round(value * EASYEDA_SCHEMATIC_UNIT_TO_TSCIRCUIT_UNIT);
+var toSchematicUnits = (value) => round2(value * EASYEDA_SCHEMATIC_UNIT_TO_TSCIRCUIT_UNIT);
 var getPointTransformer = (origin) => (point2) => ({
   x: toSchematicUnits(point2.x - origin.x),
   y: toSchematicUnits(origin.y - point2.y)
 });
-var formatNumber7 = (value) => String(round(value));
+var formatNumber7 = (value) => String(round2(value));
 var SVG_PATH_COMMAND_PARAMETER_COUNTS = {
   A: 7,
   C: 6,
@@ -352441,8 +353960,8 @@ var alignPortToDrawing = ({
   if (!nearestEndpoint)
     return position2;
   return {
-    x: round(nearestEndpoint.x + outwardDirection.x * stemLength),
-    y: round(nearestEndpoint.y + outwardDirection.y * stemLength)
+    x: round2(nearestEndpoint.x + outwardDirection.x * stemLength),
+    y: round2(nearestEndpoint.y + outwardDirection.y * stemLength)
   };
 };
 var getTextFontSize = (fontSize) => {
@@ -352560,7 +354079,7 @@ var generateShapeTsx = ({
     if (shape.visibility !== "1")
       return;
     const position2 = transformPoint({ x: shape.x, y: shape.y });
-    return `<schematictext schX={${position2.x}} schY={${position2.y}} text=${JSON.stringify(shape.content)} fontSize={${getTextFontSize(shape.fontSize)}} anchor=${JSON.stringify(getTextAnchor(shape.alignment))} color=${JSON.stringify(shape.fontColor)} schRotation={${round(-shape.rotation)}} />`;
+    return `<schematictext schX={${position2.x}} schY={${position2.y}} text=${JSON.stringify(shape.content)} fontSize={${getTextFontSize(shape.fontSize)}} anchor=${JSON.stringify(getTextAnchor(shape.alignment))} color=${JSON.stringify(shape.fontColor)} schRotation={${round2(-shape.rotation)}} />`;
   }
   if (shape.type === "PIN" && portMetadata) {
     if (shape.visibility !== "show")
@@ -353808,7 +355327,7 @@ __export6(dist_exports2, {
   capacitance: () => capacitance5,
   circuit_json_footprint_load_error: () => circuit_json_footprint_load_error3,
   current: () => current3,
-  distance: () => distance50,
+  distance: () => distance51,
   duration_ms: () => duration_ms2,
   experiment_type: () => experiment_type2,
   external_footprint_load_error: () => external_footprint_load_error3,
@@ -354353,7 +355872,7 @@ var inductance3 = z56.string().or(z56.number()).transform((v) => parseAndConvert
 var voltage6 = z56.string().or(z56.number()).transform((v) => parseAndConvertSiUnit2(v, "V").value);
 var length68 = z56.string().or(z56.number()).transform((v) => parseAndConvertSiUnit2(v).value);
 var frequency8 = z56.string().or(z56.number()).transform((v) => parseAndConvertSiUnit2(v, "Hz").value);
-var distance50 = length68;
+var distance51 = length68;
 var current3 = z56.string().or(z56.number()).transform((v) => parseAndConvertSiUnit2(v, "A").value);
 var duration_ms2 = z56.string().or(z56.number()).transform((v) => parseAndConvertSiUnit2(v).value);
 var time2 = duration_ms2;
@@ -354394,16 +355913,16 @@ expectStringUnionsMatch2('T2 has extra: "c"');
 expectStringUnionsMatch2('T1 has extra: "d", T2 has extra: "c"');
 expectStringUnionsMatch2(true);
 var point10 = z211.object({
-  x: distance50,
-  y: distance50
+  x: distance51,
+  y: distance51
 });
 var position2 = point10;
 expectTypesMatch3(true);
 expectTypesMatch3(true);
 var point34 = z311.object({
-  x: distance50,
-  y: distance50,
-  z: distance50
+  x: distance51,
+  y: distance51,
+  z: distance51
 });
 var position32 = point34;
 expectTypesMatch3(true);
@@ -354468,7 +355987,7 @@ var kicadAt3 = point10.extend({
 expectTypesMatch3(true);
 var kicadFont3 = z94.object({
   size: point10.optional(),
-  thickness: distance50.optional()
+  thickness: distance51.optional()
 });
 expectTypesMatch3(true);
 var kicadEffects3 = z94.object({
@@ -354504,7 +356023,7 @@ var kicadFootprintPad3 = z94.object({
   shape: z94.string().optional(),
   at: kicadAt3.optional(),
   size: point10.optional(),
-  drill: distance50.optional(),
+  drill: distance51.optional(),
   layers: z94.array(z94.string()).optional(),
   removeUnusedLayers: z94.boolean().optional(),
   uuid: z94.string().optional()
@@ -354535,7 +356054,7 @@ var kicadSymbolPinNumbers3 = z103.object({
 });
 expectTypesMatch3(true);
 var kicadSymbolPinNames3 = z103.object({
-  offset: distance50.optional(),
+  offset: distance51.optional(),
   hide: z103.boolean().optional()
 });
 expectTypesMatch3(true);
@@ -354609,7 +356128,7 @@ var source_simple_capacitor2 = source_component_base2.extend({
   capacitance: capacitance5,
   max_voltage_rating: voltage6.optional(),
   display_capacitance: z143.string().optional(),
-  max_decoupling_trace_length: distance50.optional()
+  max_decoupling_trace_length: distance51.optional()
 });
 expectTypesMatch3(true);
 var source_simple_resistor2 = source_component_base2.extend({
@@ -355167,11 +356686,11 @@ var schematic_box2 = z722.object({
   schematic_sheet_id: z722.string().optional(),
   schematic_component_id: z722.string().optional(),
   schematic_symbol_id: z722.string().optional(),
-  width: distance50,
-  height: distance50,
+  width: distance51,
+  height: distance51,
   is_dashed: z722.boolean().default(false),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   subcircuit_id: z722.string().optional()
 }).describe("Draws a box on the schematic");
 expectTypesMatch3(true);
@@ -355184,10 +356703,10 @@ var schematic_path2 = z732.object({
   fill_color: z732.string().optional(),
   is_filled: z732.boolean().optional(),
   is_dashed: z732.boolean().default(false),
-  stroke_width: distance50.nullable().optional(),
+  stroke_width: distance51.nullable().optional(),
   stroke_color: z732.string().optional(),
-  dash_length: distance50.optional(),
-  dash_gap: distance50.optional(),
+  dash_length: distance51.optional(),
+  dash_gap: distance51.optional(),
   points: z732.array(point10),
   subcircuit_id: z732.string().optional()
 });
@@ -355266,15 +356785,15 @@ var schematic_line2 = z76.object({
   schematic_sheet_id: z76.string().optional(),
   schematic_component_id: z76.string().optional(),
   schematic_symbol_id: z76.string().optional(),
-  x1: distance50,
-  y1: distance50,
-  x2: distance50,
-  y2: distance50,
-  stroke_width: distance50.nullable().optional(),
+  x1: distance51,
+  y1: distance51,
+  x2: distance51,
+  y2: distance51,
+  stroke_width: distance51.nullable().optional(),
   color: z76.string().default("#000000"),
   is_dashed: z76.boolean().default(false),
-  dash_length: distance50.optional(),
-  dash_gap: distance50.optional(),
+  dash_length: distance51.optional(),
+  dash_gap: distance51.optional(),
   subcircuit_id: z76.string().optional()
 }).describe("Draws a styled line on the schematic");
 expectTypesMatch3(true);
@@ -355285,10 +356804,10 @@ var schematic_rect2 = z77.object({
   schematic_component_id: z77.string().optional(),
   schematic_symbol_id: z77.string().optional(),
   center: point10,
-  width: distance50,
-  height: distance50,
+  width: distance51,
+  height: distance51,
   rotation: rotation12.default(0),
-  stroke_width: distance50.nullable().optional(),
+  stroke_width: distance51.nullable().optional(),
   color: z77.string().default("#000000"),
   is_filled: z77.boolean().default(false),
   fill_color: z77.string().optional(),
@@ -355303,8 +356822,8 @@ var schematic_circle2 = z78.object({
   schematic_component_id: z78.string().optional(),
   schematic_symbol_id: z78.string().optional(),
   center: point10,
-  radius: distance50,
-  stroke_width: distance50.nullable().optional(),
+  radius: distance51,
+  stroke_width: distance51.nullable().optional(),
   color: z78.string().default("#000000"),
   is_filled: z78.boolean().default(false),
   fill_color: z78.string().optional(),
@@ -355319,11 +356838,11 @@ var schematic_arc2 = z79.object({
   schematic_component_id: z79.string().optional(),
   schematic_symbol_id: z79.string().optional(),
   center: point10,
-  radius: distance50,
+  radius: distance51,
   start_angle_degrees: rotation12,
   end_angle_degrees: rotation12,
   direction: z79.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
-  stroke_width: distance50.nullable().optional(),
+  stroke_width: distance51.nullable().optional(),
   color: z79.string().default("#000000"),
   is_dashed: z79.boolean().default(false),
   subcircuit_id: z79.string().optional()
@@ -355373,8 +356892,8 @@ var schematic_text2 = z822.object({
   text: z822.string(),
   font_size: z822.number().default(0.18),
   position: z822.object({
-    x: distance50,
-    y: distance50
+    x: distance51,
+    y: distance51
   }),
   rotation: z822.number().default(0),
   anchor: z822.union([fivePointAnchor3.describe("legacy"), ninePointAnchor3]).default("center"),
@@ -355544,10 +357063,10 @@ var schematic_table2 = z942.object({
   schematic_table_id: getZodPrefixedIdWithDefault2("schematic_table"),
   schematic_sheet_id: z942.string().optional(),
   anchor_position: point10,
-  column_widths: z942.array(distance50),
-  row_heights: z942.array(distance50),
-  cell_padding: distance50.optional(),
-  border_width: distance50.optional(),
+  column_widths: z942.array(distance51),
+  row_heights: z942.array(distance51),
+  cell_padding: distance51.optional(),
+  border_width: distance51.optional(),
   subcircuit_id: z942.string().optional(),
   schematic_component_id: z942.string().optional(),
   anchor: ninePointAnchor3.optional()
@@ -355564,11 +357083,11 @@ var schematic_table_cell2 = z95.object({
   end_column_index: z95.number(),
   text: z95.string().optional(),
   center: point10,
-  width: distance50,
-  height: distance50,
+  width: distance51,
+  height: distance51,
   horizontal_align: z95.enum(["left", "center", "right"]).optional(),
   vertical_align: z95.enum(["top", "middle", "bottom"]).optional(),
-  font_size: distance50.optional(),
+  font_size: distance51.optional(),
   subcircuit_id: z95.string().optional()
 }).describe("Defines a cell within a schematic_table");
 expectTypesMatch3(true);
@@ -355582,8 +357101,8 @@ var schematic_sheet2 = z96.object({
 }).describe("Defines a schematic sheet or page that components can be placed on");
 expectTypesMatch3(true);
 var point_with_bulge2 = z97.object({
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   bulge: z97.number().optional()
 });
 expectTypesMatch3(true);
@@ -355674,8 +357193,8 @@ var getRotationBetweenPcbPin1Locations3 = (from, to) => {
   return null;
 };
 var pcb_route_hint2 = z100.object({
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   via: z100.boolean().optional(),
   via_to_layer: layer_ref3.optional()
 });
@@ -355683,11 +357202,11 @@ var pcb_route_hints2 = z100.array(pcb_route_hint2);
 expectTypesMatch3(true);
 expectTypesMatch3(true);
 var route_hint_point9 = z101.object({
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   via: z101.boolean().optional(),
   to_layer: layer_ref3.optional(),
-  trace_width: distance50.optional()
+  trace_width: distance51.optional()
 });
 expectTypesMatch3(true);
 var manufacturing_drc_properties2 = z1022.object({
@@ -355772,8 +357291,8 @@ var pcb_hole_circle2 = z105.object({
   pcb_component_id: z105.string().optional(),
   hole_shape: z105.literal("circle"),
   hole_diameter: z105.number(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   is_covered_with_solder_mask: z105.boolean().optional(),
   soldermask_margin: z105.number().optional()
 });
@@ -355788,8 +357307,8 @@ var pcb_hole_rect2 = z105.object({
   hole_shape: z105.literal("rect"),
   hole_width: z105.number(),
   hole_height: z105.number(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   is_covered_with_solder_mask: z105.boolean().optional(),
   soldermask_margin: z105.number().optional()
 });
@@ -355803,8 +357322,8 @@ var pcb_hole_circle_or_square2 = z105.object({
   pcb_component_id: z105.string().optional(),
   hole_shape: z105.enum(["circle", "square"]),
   hole_diameter: z105.number(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   is_covered_with_solder_mask: z105.boolean().optional(),
   soldermask_margin: z105.number().optional()
 });
@@ -355819,8 +357338,8 @@ var pcb_hole_oval2 = z105.object({
   hole_shape: z105.literal("oval"),
   hole_width: z105.number(),
   hole_height: z105.number(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   is_covered_with_solder_mask: z105.boolean().optional(),
   soldermask_margin: z105.number().optional()
 });
@@ -355835,8 +357354,8 @@ var pcb_hole_pill2 = z105.object({
   hole_shape: z105.literal("pill"),
   hole_width: z105.number(),
   hole_height: z105.number(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   is_covered_with_solder_mask: z105.boolean().optional(),
   soldermask_margin: z105.number().optional()
 });
@@ -355851,8 +357370,8 @@ var pcb_hole_rotated_pill2 = z105.object({
   hole_shape: z105.literal("rotated_pill"),
   hole_width: z105.number(),
   hole_height: z105.number(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   ccw_rotation: rotation12,
   is_covered_with_solder_mask: z105.boolean().optional(),
   soldermask_margin: z105.number().optional()
@@ -355868,8 +357387,8 @@ var pcb_plated_hole_circle2 = z106.object({
   outer_diameter: z106.number(),
   hole_diameter: z106.number(),
   is_covered_with_solder_mask: z106.boolean().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   layers: z106.array(layer_ref3),
   port_hints: z106.array(z106.string()).optional(),
   pcb_component_id: z106.string().optional(),
@@ -355887,8 +357406,8 @@ var pcb_plated_hole_oval2 = z106.object({
   hole_width: z106.number(),
   hole_height: z106.number(),
   is_covered_with_solder_mask: z106.boolean().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   ccw_rotation: rotation12,
   layers: z106.array(layer_ref3),
   port_hints: z106.array(z106.string()).optional(),
@@ -355908,11 +357427,11 @@ var pcb_circular_hole_with_rect_pad2 = z106.object({
   rect_pad_width: z106.number(),
   rect_pad_height: z106.number(),
   rect_border_radius: z106.number().optional(),
-  hole_offset_x: distance50.default(0),
-  hole_offset_y: distance50.default(0),
+  hole_offset_x: distance51.default(0),
+  hole_offset_y: distance51.default(0),
   is_covered_with_solder_mask: z106.boolean().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   layers: z106.array(layer_ref3),
   port_hints: z106.array(z106.string()).optional(),
   pcb_component_id: z106.string().optional(),
@@ -355933,11 +357452,11 @@ var pcb_pill_hole_with_rect_pad2 = z106.object({
   rect_pad_width: z106.number(),
   rect_pad_height: z106.number(),
   rect_border_radius: z106.number().optional(),
-  hole_offset_x: distance50.default(0),
-  hole_offset_y: distance50.default(0),
+  hole_offset_x: distance51.default(0),
+  hole_offset_y: distance51.default(0),
   is_covered_with_solder_mask: z106.boolean().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   layers: z106.array(layer_ref3),
   port_hints: z106.array(z106.string()).optional(),
   pcb_component_id: z106.string().optional(),
@@ -355959,11 +357478,11 @@ var pcb_rotated_pill_hole_with_rect_pad2 = z106.object({
   rect_pad_height: z106.number(),
   rect_border_radius: z106.number().optional(),
   rect_ccw_rotation: rotation12,
-  hole_offset_x: distance50.default(0),
-  hole_offset_y: distance50.default(0),
+  hole_offset_x: distance51.default(0),
+  hole_offset_y: distance51.default(0),
   is_covered_with_solder_mask: z106.boolean().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   layers: z106.array(layer_ref3),
   port_hints: z106.array(z106.string()).optional(),
   pcb_component_id: z106.string().optional(),
@@ -355981,14 +357500,14 @@ var pcb_hole_with_polygon_pad2 = z106.object({
   hole_width: z106.number().optional(),
   hole_height: z106.number().optional(),
   pad_outline: z106.array(z106.object({
-    x: distance50,
-    y: distance50
+    x: distance51,
+    y: distance51
   })).min(3),
-  hole_offset_x: distance50.default(0),
-  hole_offset_y: distance50.default(0),
+  hole_offset_x: distance51.default(0),
+  hole_offset_y: distance51.default(0),
   is_covered_with_solder_mask: z106.boolean().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   layers: z106.array(layer_ref3),
   port_hints: z106.array(z106.string()).optional(),
   pcb_component_id: z106.string().optional(),
@@ -356018,8 +357537,8 @@ var pcb_port2 = z107.object({
   subcircuit_id: z107.string().optional(),
   source_port_id: z107.string(),
   pcb_component_id: z107.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   layers: z107.array(layer_ref3),
   is_board_pinout: z107.boolean().optional()
 }).describe("Defines a port on the PCB");
@@ -356030,8 +357549,8 @@ var pcb_smtpad_circle2 = z108.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z108.string().optional(),
   subcircuit_id: z108.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   radius: z108.number(),
   layer: layer_ref3,
   port_hints: z108.array(z108.string()).optional(),
@@ -356047,8 +357566,8 @@ var pcb_smtpad_rect2 = z108.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z108.string().optional(),
   subcircuit_id: z108.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z108.number(),
   height: z108.number(),
   rect_border_radius: z108.number().optional(),
@@ -356071,8 +357590,8 @@ var pcb_smtpad_rotated_rect2 = z108.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z108.string().optional(),
   subcircuit_id: z108.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z108.number(),
   height: z108.number(),
   rect_border_radius: z108.number().optional(),
@@ -356096,8 +357615,8 @@ var pcb_smtpad_pill2 = z108.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z108.string().optional(),
   subcircuit_id: z108.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z108.number(),
   height: z108.number(),
   radius: z108.number(),
@@ -356115,8 +357634,8 @@ var pcb_smtpad_rotated_pill2 = z108.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z108.string().optional(),
   subcircuit_id: z108.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z108.number(),
   height: z108.number(),
   radius: z108.number(),
@@ -356164,8 +357683,8 @@ var pcb_solder_paste_circle2 = z109.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z109.string().optional(),
   subcircuit_id: z109.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   radius: z109.number(),
   layer: layer_ref3,
   pcb_component_id: z109.string().optional(),
@@ -356177,8 +357696,8 @@ var pcb_solder_paste_rect2 = z109.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z109.string().optional(),
   subcircuit_id: z109.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z109.number(),
   height: z109.number(),
   layer: layer_ref3,
@@ -356191,8 +357710,8 @@ var pcb_solder_paste_pill2 = z109.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z109.string().optional(),
   subcircuit_id: z109.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z109.number(),
   height: z109.number(),
   radius: z109.number(),
@@ -356206,11 +357725,11 @@ var pcb_solder_paste_rotated_rect2 = z109.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z109.string().optional(),
   subcircuit_id: z109.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z109.number(),
   height: z109.number(),
-  ccw_rotation: distance50,
+  ccw_rotation: distance51,
   layer: layer_ref3,
   pcb_component_id: z109.string().optional(),
   pcb_smtpad_id: z109.string().optional()
@@ -356221,8 +357740,8 @@ var pcb_solder_paste_rotated_pill2 = z109.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z109.string().optional(),
   subcircuit_id: z109.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z109.number(),
   height: z109.number(),
   radius: z109.number(),
@@ -356237,8 +357756,8 @@ var pcb_solder_paste_oval2 = z109.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z109.string().optional(),
   subcircuit_id: z109.string().optional(),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   width: z109.number(),
   height: z109.number(),
   layer: layer_ref3,
@@ -356275,9 +357794,9 @@ var pcb_text2 = z110.object({
 expectTypesMatch3(true);
 var pcb_trace_route_point_wire2 = z111.object({
   route_type: z111.literal("wire"),
-  x: distance50,
-  y: distance50,
-  width: distance50,
+  x: distance51,
+  y: distance51,
+  width: distance51,
   copper_pour_id: z111.string().optional(),
   is_inside_copper_pour: z111.boolean().optional(),
   start_pcb_port_id: z111.string().optional(),
@@ -356286,12 +357805,12 @@ var pcb_trace_route_point_wire2 = z111.object({
 });
 var pcb_trace_route_point_via2 = z111.object({
   route_type: z111.literal("via"),
-  x: distance50,
-  y: distance50,
+  x: distance51,
+  y: distance51,
   copper_pour_id: z111.string().optional(),
   is_inside_copper_pour: z111.boolean().optional(),
-  hole_diameter: distance50.optional(),
-  outer_diameter: distance50.optional(),
+  hole_diameter: distance51.optional(),
+  outer_diameter: distance51.optional(),
   from_layer: layer_ref3,
   to_layer: layer_ref3
 });
@@ -356299,7 +357818,7 @@ var pcb_trace_route_point_through_pad2 = z111.object({
   route_type: z111.literal("through_pad"),
   start: point10,
   end: point10,
-  width: distance50,
+  width: distance51,
   start_layer: layer_ref3,
   end_layer: layer_ref3,
   pcb_smtpad_id: z111.string().optional(),
@@ -356347,8 +357866,8 @@ var pcb_trace_too_long_warning2 = z1132.object({
   pcb_trace_id: z1132.string(),
   source_net_id: z1132.string().optional(),
   source_trace_id: z1132.string().optional(),
-  actual_trace_length: distance50,
-  maximum_trace_length: distance50,
+  actual_trace_length: distance51,
+  maximum_trace_length: distance51,
   subcircuit_id: z1132.string().optional()
 }).describe("Warning emitted when a PCB trace is longer than its maximum allowed length");
 expectTypesMatch3(true);
@@ -356418,10 +357937,10 @@ var pcb_via2 = z120.object({
   pcb_group_id: z120.string().optional(),
   subcircuit_id: z120.string().optional(),
   subcircuit_connectivity_map_key: z120.string().optional(),
-  x: distance50,
-  y: distance50,
-  outer_diameter: distance50.default("0.6mm"),
-  hole_diameter: distance50.default("0.25mm"),
+  x: distance51,
+  y: distance51,
+  outer_diameter: distance51.default("0.6mm"),
+  hole_diameter: distance51.default("0.25mm"),
   from_layer: layer_ref3.optional(),
   to_layer: layer_ref3.optional(),
   layers: z120.array(layer_ref3),
@@ -356509,11 +358028,11 @@ var pcb_silkscreen_line2 = z127.object({
   pcb_component_id: z127.string(),
   pcb_group_id: z127.string().optional(),
   subcircuit_id: z127.string().optional(),
-  stroke_width: distance50.default("0.1mm"),
-  x1: distance50,
-  y1: distance50,
-  x2: distance50,
-  y2: distance50,
+  stroke_width: distance51.default("0.1mm"),
+  x1: distance51,
+  y1: distance51,
+  x2: distance51,
+  y2: distance51,
   layer: visible_layer2
 }).describe("Defines a silkscreen line on the PCB");
 expectTypesMatch3(true);
@@ -356534,7 +358053,7 @@ var pcb_silkscreen_text2 = z129.object({
   pcb_group_id: z129.string().optional(),
   subcircuit_id: z129.string().optional(),
   font: z129.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance50.default("0.2mm"),
+  font_size: distance51.default("0.2mm"),
   pcb_component_id: z129.string(),
   text: z129.string(),
   is_knockout: z129.boolean().default(false).optional(),
@@ -356562,7 +358081,7 @@ var pcb_copper_text2 = z130.object({
   pcb_group_id: z130.string().optional(),
   subcircuit_id: z130.string().optional(),
   font: z130.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance50.default("0.2mm"),
+  font_size: distance51.default("0.2mm"),
   pcb_component_id: z130.string(),
   text: z130.string(),
   is_knockout: z130.boolean().default(false).optional(),
@@ -356622,8 +358141,8 @@ var pcb_silkscreen_oval2 = z1332.object({
   pcb_group_id: z1332.string().optional(),
   subcircuit_id: z1332.string().optional(),
   center: point10,
-  radius_x: distance50,
-  radius_y: distance50,
+  radius_x: distance51,
+  radius_y: distance51,
   layer: visible_layer2,
   ccw_rotation: rotation12.optional()
 }).describe("Defines a silkscreen oval on the PCB");
@@ -356663,7 +358182,7 @@ var pcb_fabrication_note_text3 = z136.object({
   subcircuit_id: z136.string().optional(),
   pcb_group_id: z136.string().optional(),
   font: z136.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance50.default("1mm"),
+  font_size: distance51.default("1mm"),
   pcb_component_id: z136.string(),
   text: z136.string(),
   ccw_rotation: z136.number().optional(),
@@ -356733,7 +358252,7 @@ var pcb_note_text3 = z140.object({
   subcircuit_id: z140.string().optional(),
   name: z140.string().optional(),
   font: z140.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance50.default("1mm"),
+  font_size: distance51.default("1mm"),
   text: z140.string().optional(),
   anchor_position: point10.default({ x: 0, y: 0 }),
   anchor_alignment: z140.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
@@ -356784,12 +358303,12 @@ var pcb_note_line3 = z1432.object({
   subcircuit_id: z1432.string().optional(),
   name: z1432.string().optional(),
   text: z1432.string().optional(),
-  x1: distance50,
-  y1: distance50,
-  x2: distance50,
-  y2: distance50,
+  x1: distance51,
+  y1: distance51,
+  x2: distance51,
+  y2: distance51,
   layer: visible_layer2.default("top"),
-  stroke_width: distance50.default("0.1mm"),
+  stroke_width: distance51.default("0.1mm"),
   color: z1432.string().optional(),
   is_dashed: z1432.boolean().optional()
 }).describe("Defines a straight documentation note line on the PCB");
@@ -356840,8 +358359,8 @@ var pcb_keepout3 = z147.object({
   pcb_group_id: z147.string().optional(),
   subcircuit_id: z147.string().optional(),
   center: point10,
-  width: distance50,
-  height: distance50,
+  width: distance51,
+  height: distance51,
   pcb_keepout_id: z147.string(),
   layers: z147.array(z147.string()),
   description: z147.string().optional(),
@@ -356852,7 +358371,7 @@ var pcb_keepout3 = z147.object({
   pcb_group_id: z147.string().optional(),
   subcircuit_id: z147.string().optional(),
   center: point10,
-  radius: distance50,
+  radius: distance51,
   pcb_keepout_id: z147.string(),
   layers: z147.array(z147.string()),
   description: z147.string().optional(),
@@ -357028,8 +358547,8 @@ var pcb_breakout_point2 = z158.object({
   source_port_id: z158.string().optional(),
   source_net_id: z158.string().optional(),
   layer: layer_ref3.optional(),
-  x: distance50,
-  y: distance50
+  x: distance51,
+  y: distance51
 }).describe("Defines a routing target within a pcb_group for a source_trace or source_net");
 expectTypesMatch3(true);
 var pcb_ground_plane2 = z159.object({
@@ -357057,9 +358576,9 @@ var pcb_thermal_spoke2 = z161.object({
   pcb_ground_plane_id: z161.string(),
   shape: z161.string(),
   spoke_count: z161.number(),
-  spoke_thickness: distance50,
-  spoke_inner_diameter: distance50,
-  spoke_outer_diameter: distance50,
+  spoke_thickness: distance51,
+  spoke_inner_diameter: distance51,
+  spoke_outer_diameter: distance51,
   pcb_plated_hole_id: z161.string().optional(),
   subcircuit_id: z161.string().optional()
 }).describe("Pattern for connecting a ground plane to a plated hole");
@@ -357141,8 +358660,8 @@ var pcb_via_clearance_error2 = base_circuit_json_error2.extend({
   pcb_error_id: getZodPrefixedIdWithDefault2("pcb_error"),
   error_type: z166.literal("pcb_via_clearance_error").default("pcb_via_clearance_error"),
   pcb_via_ids: z166.array(z166.string()).min(2),
-  minimum_clearance: distance50.optional(),
-  actual_clearance: distance50.optional(),
+  minimum_clearance: distance51.optional(),
+  actual_clearance: distance51.optional(),
   pcb_center: z166.object({
     x: z166.number().optional(),
     y: z166.number().optional()
@@ -357156,8 +358675,8 @@ var pcb_via_trace_clearance_error2 = base_circuit_json_error2.extend({
   error_type: z167.literal("pcb_via_trace_clearance_error").default("pcb_via_trace_clearance_error"),
   pcb_via_id: z167.string(),
   pcb_trace_id: z167.string(),
-  minimum_clearance: distance50.optional(),
-  actual_clearance: distance50.optional(),
+  minimum_clearance: distance51.optional(),
+  actual_clearance: distance51.optional(),
   center: z167.object({
     x: z167.number().optional(),
     y: z167.number().optional()
@@ -357170,8 +358689,8 @@ var pcb_pad_pad_clearance_error2 = base_circuit_json_error2.extend({
   pcb_pad_pad_clearance_error_id: getZodPrefixedIdWithDefault2("pcb_pad_pad_clearance_error"),
   error_type: z168.literal("pcb_pad_pad_clearance_error").default("pcb_pad_pad_clearance_error"),
   pcb_pad_ids: z168.array(z168.string()).min(2),
-  minimum_clearance: distance50.optional(),
-  actual_clearance: distance50.optional(),
+  minimum_clearance: distance51.optional(),
+  actual_clearance: distance51.optional(),
   center: z168.object({
     x: z168.number().optional(),
     y: z168.number().optional()
@@ -357185,8 +358704,8 @@ var pcb_pad_trace_clearance_error2 = base_circuit_json_error2.extend({
   error_type: z169.literal("pcb_pad_trace_clearance_error").default("pcb_pad_trace_clearance_error"),
   pcb_pad_id: z169.string(),
   pcb_trace_id: z169.string(),
-  minimum_clearance: distance50.optional(),
-  actual_clearance: distance50.optional(),
+  minimum_clearance: distance51.optional(),
+  actual_clearance: distance51.optional(),
   center: z169.object({
     x: z169.number().optional(),
     y: z169.number().optional()