@tscircuit/cli 0.1.2255 → 0.1.2257

package/dist/cli/main.js

@@ -172569,7 +172569,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.2254";
+var version = "0.1.2256";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -172588,7 +172588,7 @@ var package_default = {
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.26.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.15",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.33.tgz",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.46.tgz",
     "@tscircuit/circuit-json-util": "^0.0.120",
     "@tscircuit/eval": "0.0.1569",
     "@tscircuit/fake-snippets": "^0.0.182",
@@ -172599,7 +172599,7 @@ var package_default = {
     "@tscircuit/math-utils": "0.0.36",
     "@tscircuit/modelprinter": "^0.0.11",
     "@tscircuit/props": "^0.0.694",
-    "@tscircuit/runframe": "^0.0.2923",
+    "@tscircuit/runframe": "^0.0.2924",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
     "@tscircuit/schematic-trace-solver": "^0.0.204",
     "@tscircuit/solver-utils": "0.0.16",
@@ -349717,7 +349717,7 @@ var registerCheckRoutingDifficulty = (program) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/MosfetGateNetworkPlacementSolver/MosfetGateNetworkPlacementSolver.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ParallelDiodeResistorPlacementSolver/ParallelDiodeResistorPlacementSolver.ts
 import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/format.ts
@@ -349882,8 +349882,519 @@ function append2(map, key, value) {
     map.set(key, [value]);
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ParallelDiodeResistorPlacementSolver/ParallelDiodeResistorPlacementSolver.ts
+class ParallelDiodeResistorPlacementSolver extends BaseSolver5 {
+  params;
+  banks = [];
+  bankIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const index = new PlacementNetworkIndex(params2.ctx);
+    const byNets = new Map;
+    for (const component of index.components.values()) {
+      const diode = component.ftype === "simple_diode" || component.ftype === "simple_led";
+      if (!diode && component.ftype !== "simple_resistor")
+        continue;
+      const id = component.source_component_id;
+      const box = index.placement(id);
+      const nets = index.twoTerminalNets(id)?.sort();
+      const ports = index.portsByComponent.get(id);
+      if (!box || !nets || !ports)
+        continue;
+      const pins = nets.map((net) => {
+        const port = ports.find((p) => index.connected(p.source_port_id) === net);
+        return port && index.port(port);
+      });
+      const [first, second] = pins;
+      const member = { diode, box };
+      if (first && second && !ports.some((port) => port.do_not_connect) && pins.every((pin) => pin?.schematic_sheet_id === box.schematicSheetId)) {
+        member.pins = [first, second];
+        member.axis = pinAxis(first, second);
+      }
+      const key = JSON.stringify(nets);
+      const scopes = byNets.get(key) ?? [];
+      const bank = scopes.find((items) => index.sameLocalScope(items[0].box, box));
+      if (bank)
+        bank.push(member);
+      else {
+        const items = [member];
+        scopes.push(items);
+        this.banks.push(items);
+      }
+      byNets.set(key, scopes);
+    }
+    this.solved = this.banks.length === 0;
+  }
+  _step() {
+    const bank = this.banks[this.bankIndex++];
+    this.solved = this.bankIndex >= this.banks.length;
+    if (bank.length !== 2)
+      return;
+    const diode = bank.find((member) => member.diode);
+    const resistor = bank.find((member) => !member.diode);
+    if (!diode?.pins || !diode.axis || !resistor?.pins || !resistor.axis)
+      return;
+    const a = diode.box;
+    const b = resistor.box;
+    if (Math.abs(a.schX - b.schX) < (a.width + b.width) / 2 && Math.abs(a.schY - b.schY) < (a.height + b.height) / 2)
+      return;
+    let reason;
+    if (diode.axis !== resistor.axis)
+      reason = "different_axes";
+    else {
+      const coordinate = diode.axis === "horizontal" ? "x" : "y";
+      const d = diode.pins.map((pin) => pin.center[coordinate]);
+      const r = resistor.pins.map((pin) => pin.center[coordinate]);
+      if ((d[1] - d[0]) * (r[1] - r[0]) < 0)
+        reason = "crossed_connections";
+      else {
+        const overlap = Math.min(Math.max(...d), Math.max(...r)) - Math.max(Math.min(...d), Math.min(...r));
+        if (overlap > 0.01)
+          return;
+        reason = "staggered";
+      }
+    }
+    this.params.issues.push({
+      lineItemType: "ParallelDiodeResistorNotAligned",
+      diodeSchematicBox: a,
+      resistorSchematicBox: b,
+      reason,
+      message: `Draw ${a.sourceComponentName || "the diode"} and ${b.sourceComponentName || "the resistor"} as adjacent parallel rows or columns with their shared nets at matching ends. Preserve every pin connection and diode polarity, leave room for labels, and reroute the affected wires.`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "diodeComponentName", issue.diodeSchematicBox.sourceComponentName);
+    addAttr(attrs, "resistorComponentName", issue.resistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "reason", issue.reason);
+    addAttr(attrs, "message", issue.message);
+    return `<ParallelDiodeResistorNotAligned ${attrs.join(" ")} />`;
+  }
+}
+function pinAxis(first, second) {
+  const directions = new Set([first.facing_direction, second.facing_direction]);
+  if (directions.has("left") && directions.has("right") && Math.abs(first.center.y - second.center.y) < 0.01 && Math.abs(first.center.x - second.center.x) > 0.01)
+    return "horizontal";
+  if (directions.has("up") && directions.has("down") && Math.abs(first.center.x - second.center.x) < 0.01 && Math.abs(first.center.y - second.center.y) > 0.01)
+    return "vertical";
+}
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/RailPathVisibilitySolver/RailPathVisibilitySolver.ts
+import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+var distance49 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var EPS6 = 0.001;
+
+class RailPathVisibilitySolver extends BaseSolver6 {
+  index;
+  nodes = new Map;
+  starts = [];
+  currentIndex = 0;
+  issues;
+  maxSpan;
+  maxLength;
+  constructor({
+    ctx,
+    issues,
+    maxSpan = 8,
+    maxLength = 16
+  }) {
+    super();
+    this.index = new PlacementNetworkIndex(ctx);
+    this.issues = issues;
+    if (!Number.isFinite(maxSpan) || maxSpan < 0 || !Number.isFinite(maxLength) || maxLength < 0)
+      throw new Error("Rail visibility thresholds must be finite and nonnegative");
+    this.maxSpan = maxSpan;
+    this.maxLength = maxLength;
+    const index = this.index;
+    const node = (point, net, sheet) => {
+      const id = JSON.stringify([
+        sheet,
+        net,
+        Math.round(point.x / EPS6),
+        Math.round(point.y / EPS6)
+      ]);
+      if (!this.nodes.has(id))
+        this.nodes.set(id, { point, net, sheet, links: [] });
+      return id;
+    };
+    const link = (a, b, extra) => {
+      const first = this.nodes.get(a), second = this.nodes.get(b);
+      const length = distance49(first.point, second.point);
+      first.links.push({ to: b, length, ...extra });
+      second.links.push({ to: a, length, ...extra });
+    };
+    const portNodes = new Map;
+    for (const [componentId, ports] of index.portsByComponent) {
+      for (const port of ports) {
+        const placed = index.port(port);
+        if (!placed)
+          continue;
+        const id = node(placed.center, index.connected(port.source_port_id), placed.schematic_sheet_id);
+        portNodes.set(port.source_port_id, id);
+        if (ports.length > 2)
+          this.starts.push({
+            portId: port.source_port_id,
+            componentId,
+            nodeId: id
+          });
+      }
+    }
+    for (const element of ctx.circuitJson) {
+      if (element.type !== "schematic_net_label" || !element.source_net_id || !element.anchor_position)
+        continue;
+      const net = index.connected(element.source_net_id);
+      if (!index.isRail(net) || index.powerNets.has(net) && index.groundNets.has(net))
+        continue;
+      const id = node(element.anchor_position, net, element.schematic_sheet_id);
+      this.nodes.get(id).terminal = index.groundNets.has(net) ? "ground" : "power";
+    }
+    const segments = [];
+    for (const element of ctx.circuitJson) {
+      if (element.type !== "schematic_trace")
+        continue;
+      const net = traceNet(element, ctx.circuitJson, index);
+      if (!net)
+        continue;
+      for (const edge of element.edges) {
+        segments.push({
+          from: node(edge.from, net, element.schematic_sheet_id),
+          to: node(edge.to, net, element.schematic_sheet_id),
+          traceId: element.schematic_trace_id
+        });
+      }
+    }
+    for (const segment of segments) {
+      const a = this.nodes.get(segment.from), b = this.nodes.get(segment.to);
+      const length = distance49(a.point, b.point);
+      if (length < EPS6)
+        continue;
+      const onSegment = [...this.nodes].filter(([, n]) => n.net === a.net && n.sheet === a.sheet && pointOnSegment(n.point, a.point, b.point)).sort(([, p], [, q]) => distance49(a.point, p.point) - distance49(a.point, q.point));
+      for (let i = 1;i < onSegment.length; i++)
+        link(onSegment[i - 1][0], onSegment[i][0], {
+          traceId: segment.traceId
+        });
+    }
+    for (const [id, component] of index.components) {
+      if (!["simple_resistor", "simple_capacitor", "simple_inductor"].includes(component.ftype))
+        continue;
+      const ports = index.portsByComponent.get(id);
+      if (ports?.length !== 2 || !index.twoTerminalNets(id))
+        continue;
+      const a = portNodes.get(ports[0].source_port_id), b = portNodes.get(ports[1].source_port_id);
+      if (a && b)
+        link(a, b, { componentId: id });
+    }
+    this.solved = this.starts.length === 0;
+  }
+  _step() {
+    const start = this.starts[this.currentIndex++];
+    this.solved = this.currentIndex >= this.starts.length;
+    if (!start)
+      return;
+    const sourcePort = this.index.portsByComponent.get(start.componentId)?.find((port) => port.source_port_id === start.portId);
+    const placedPort = sourcePort ? this.index.port(sourcePort) : undefined;
+    const sourcePortName = placedPort?.display_pin_label || sourcePort?.name || (placedPort?.pin_number !== undefined ? `pin${placedPort.pin_number}` : "connected pin");
+    const host = this.index.placement(start.componentId);
+    if (!host)
+      return;
+    const queue = [
+      { id: start.nodeId, length: 0, hops: 0, path: [start.nodeId], links: [] }
+    ];
+    const bestLengths = new Map([[`${start.nodeId}:0`, 0]]);
+    while (queue.length) {
+      queue.sort((a, b) => a.length - b.length);
+      const state = queue.shift();
+      const key = `${state.id}:${state.hops}`;
+      if (state.length !== bestLengths.get(key))
+        continue;
+      const current = this.nodes.get(state.id);
+      if (current.terminal) {
+        const points = state.path.map((id) => this.nodes.get(id).point);
+        const xs = points.map((p) => p.x), ys = points.map((p) => p.y);
+        const bounds = {
+          left: Math.min(...xs),
+          right: Math.max(...xs),
+          bottom: Math.min(...ys),
+          top: Math.max(...ys)
+        };
+        const span = Math.max(bounds.right - bounds.left, bounds.top - bounds.bottom);
+        if (span <= this.maxSpan && state.length <= this.maxLength)
+          return;
+        const componentIds = [
+          ...new Set(state.links.flatMap((l) => l.componentId ? [l.componentId] : []))
+        ];
+        this.issues.push({
+          lineItemType: "RailPathTooSpreadOut",
+          hostSchematicBox: host,
+          sourcePortId: start.portId,
+          sourcePortName,
+          railType: current.terminal,
+          supportSchematicBoxes: componentIds.flatMap((id) => {
+            const placement = this.index.placement(id);
+            return placement ? [placement] : [];
+          }),
+          schematicTraceIds: [
+            ...new Set(state.links.flatMap((l) => l.traceId ? [l.traceId] : []))
+          ],
+          pathPoints: points,
+          pathBounds: bounds,
+          pathLength: state.length,
+          pathSpan: span,
+          maxRecommendedSpan: this.maxSpan,
+          maxRecommendedPathLength: this.maxLength,
+          message: `Visible path from ${host.sourceComponentName || "component"}.${sourcePortName} to ${current.terminal} spans ${span.toFixed(2)} schematic units; move the connected support elements closer together near the pin and recompute their schematic traces.`
+        });
+        return;
+      }
+      for (const edge of current.links) {
+        if (state.path.includes(edge.to))
+          continue;
+        if (edge.componentId) {
+          const placement = this.index.placement(edge.componentId);
+          if (state.hops >= 3 || !placement || !this.index.sameLocalScope(host, placement))
+            continue;
+        }
+        const length = state.length + edge.length;
+        const hops = state.hops + (edge.componentId ? 1 : 0);
+        const nextKey = `${edge.to}:${hops}`;
+        if (length >= (bestLengths.get(nextKey) ?? Infinity))
+          continue;
+        bestLengths.set(nextKey, length);
+        queue.push({
+          id: edge.to,
+          length,
+          hops,
+          path: [...state.path, edge.to],
+          links: [...state.links, edge]
+        });
+      }
+    }
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "hostName", issue.hostSchematicBox.sourceComponentName);
+    addAttr(attrs, "pinName", issue.sourcePortName);
+    addAttr(attrs, "railType", issue.railType);
+    addAttr(attrs, "pathSpan", issue.pathSpan);
+    addAttr(attrs, "pathLength", issue.pathLength);
+    addAttr(attrs, "message", issue.message);
+    return `<RailPathTooSpreadOut ${attrs.join(" ")} />`;
+  }
+}
+function traceNet(trace, circuitJson, index) {
+  if (trace.subcircuit_connectivity_map_key)
+    return index.connected(`connectivity:${trace.subcircuit_connectivity_map_key}`);
+  const source = circuitJson.find((e) => e.type === "source_trace" && e.source_trace_id === trace.source_trace_id);
+  if (source?.type !== "source_trace")
+    return;
+  const ids = [
+    ...source.connected_source_port_ids,
+    ...source.connected_source_net_ids
+  ];
+  return ids[0] ? index.connected(ids[0]) : undefined;
+}
+function pointOnSegment(p, a, b) {
+  const dx = b.x - a.x, dy = b.y - a.y, length = distance49(a, b);
+  if (length < EPS6)
+    return distance49(a, p) < EPS6;
+  const projection = ((p.x - a.x) * dx + (p.y - a.y) * dy) / length;
+  const perpendicular = Math.abs((p.x - a.x) * dy - (p.y - a.y) * dx) / length;
+  return perpendicular < EPS6 && projection >= -EPS6 && projection <= length + EPS6;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ChipPinPairCapacitorPlacementSolver/ChipPinPairCapacitorPlacementSolver.ts
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+class ChipPinPairCapacitorPlacementSolver extends BaseSolver7 {
+  params;
+  index;
+  capacitorIds;
+  unpopulated = new Set;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    for (const element of params2.ctx.circuitJson)
+      if (element.type === "pcb_component" && element.do_not_place)
+        this.unpopulated.add(element.source_component_id);
+    this.capacitorIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_capacitor").map((component) => component.source_component_id);
+    this.solved = this.capacitorIds.length === 0;
+  }
+  _step() {
+    const capacitorId = this.capacitorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.capacitorIds.length;
+    if (!capacitorId || this.unpopulated.has(capacitorId))
+      return;
+    const index = this.index;
+    const component = index.components.get(capacitorId);
+    const capacitor = index.placement(capacitorId);
+    const capacitorPorts = index.portsByComponent.get(capacitorId) ?? [];
+    const nets = index.twoTerminalNets(capacitorId);
+    if (component?.ftype !== "simple_capacitor" || !Number.isFinite(component.capacitance) || component.capacitance <= 0 || !capacitor || !nets || nets.some((net) => index.isRail(net)) || capacitorPorts.some((port) => port.do_not_connect || hasSupplyRole(port)))
+      return;
+    const peers = nets.map((net) => {
+      const members = index.portsByNet.get(net) ?? [];
+      if (members.length !== 2)
+        return;
+      return members.find((port) => port.source_component_id !== capacitorId);
+    });
+    const [first, second] = peers;
+    if (!first || !second || first.source_component_id !== second.source_component_id || first.do_not_connect || second.do_not_connect || hasSupplyRole(first) || hasSupplyRole(second))
+      return;
+    const hostId = first.source_component_id;
+    const host = index.placement(hostId);
+    if (index.components.get(hostId)?.ftype !== "simple_chip" || this.unpopulated.has(hostId) || !host || !index.sameLocalScope(host, capacitor))
+      return;
+    const chipPorts = [first, second];
+    const pins = chipPorts.map((port) => index.port(port));
+    const capPins = capacitorPorts.map((port) => index.port(port));
+    if ([...pins, ...capPins].some((pin) => !pin || pin.schematic_sheet_id !== host.schematicSheetId || !Number.isFinite(pin.center.x) || !Number.isFinite(pin.center.y)) || [host, capacitor].some((box) => ![box.schX, box.schY, box.width, box.height].every(Number.isFinite) || box.width <= 0 || box.height <= 0))
+      return;
+    const firstPin = pins[0], secondPin = pins[1];
+    const side = firstPin.facing_direction;
+    if (!side || side !== secondPin.facing_direction)
+      return;
+    const horizontal = side === "left" || side === "right";
+    const sign = side === "left" || side === "down" ? -1 : 1;
+    const pinSpan = Math.hypot(firstPin.center.x - secondPin.center.x, firstPin.center.y - secondPin.center.y);
+    if (pinSpan < 0.01)
+      return;
+    const oppositeDistance = -sign * (horizontal ? capacitor.schX - host.schX : capacitor.schY - host.schY);
+    const halfBodies = horizontal ? (host.width + capacitor.width) / 2 : (host.height + capacitor.height) / 2;
+    if (oppositeDistance <= halfBodies + 0.2)
+      return;
+    const maxPinDistance = Math.max(...pins.map((pin, i) => Math.hypot(pin.center.x - capPins[i].center.x, pin.center.y - capPins[i].center.y)));
+    const maxRecommendedPinDistance = Math.max(4, 3 * Math.max(capacitor.width, capacitor.height), 2 * pinSpan);
+    if (maxPinDistance <= maxRecommendedPinDistance)
+      return;
+    this.params.issues.push({
+      lineItemType: "CapacitorSeparatedFromChipPins",
+      hostSchematicBox: host,
+      capacitorSchematicBox: capacitor,
+      chipSourcePortIds: [
+        chipPorts[0].source_port_id,
+        chipPorts[1].source_port_id
+      ],
+      maxPinDistance,
+      maxRecommendedPinDistance,
+      message: `Place ${capacitor.sourceComponentName || "component"} beside its two connected pins on the ${side} side of ${host.sourceComponentName || "component"} so their connections can be read together. Preserve pin connections, leave room for labels, and reroute affected traces; exact alignment is not required.`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "hostComponentName", issue.hostSchematicBox.sourceComponentName);
+    addAttr(attrs, "capacitorName", issue.capacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "maxPinDistance", issue.maxPinDistance);
+    addAttr(attrs, "maxRecommendedPinDistance", issue.maxRecommendedPinDistance);
+    addAttr(attrs, "message", issue.message);
+    return `<CapacitorSeparatedFromChipPins ${attrs.join(" ")} />`;
+  }
+}
+function hasSupplyRole(port) {
+  return Boolean(port.requires_power || port.provides_power || port.requires_ground || port.provides_ground || port.requires_voltage !== undefined || port.provides_voltage !== undefined);
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PiFilterPlacementSolver/PiFilterPlacementSolver.ts
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+class PiFilterPlacementSolver extends BaseSolver8 {
+  params;
+  index;
+  inductorIds;
+  unpopulated = new Set;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    for (const e of params2.ctx.circuitJson)
+      if (e.type === "pcb_component" && e.do_not_place)
+        this.unpopulated.add(e.source_component_id);
+    for (const e of params2.ctx.circuitJson)
+      if (e.type === "pcb_component" && !e.do_not_place)
+        this.unpopulated.delete(e.source_component_id);
+    this.inductorIds = [...this.index.components.values()].filter((c) => c.ftype === "simple_inductor" && !this.unpopulated.has(c.source_component_id)).map((c) => c.source_component_id);
+    this.solved = this.inductorIds.length === 0;
+  }
+  _step() {
+    const id = this.inductorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.inductorIds.length;
+    if (!id)
+      return;
+    const index = this.index;
+    const inductor = this.localPart(id);
+    const nets = index.twoTerminalNets(id);
+    if (!inductor || !nets || nets.some((net) => index.isRail(net)))
+      return;
+    const branches = nets.map((net) => {
+      const peers = index.portsByNet.get(net) ?? [];
+      if (peers.some((p) => p.source_component_id !== id && !this.unpopulated.has(p.source_component_id) && index.components.get(p.source_component_id)?.ftype === "simple_inductor"))
+        return;
+      const capacitors = peers.filter((p) => {
+        const c = index.components.get(p.source_component_id);
+        const capNets = index.twoTerminalNets(p.source_component_id);
+        return c?.ftype === "simple_capacitor" && !this.unpopulated.has(p.source_component_id) && capNets?.some((n) => n !== net && index.groundNets.has(n));
+      });
+      if (capacitors.length !== 1)
+        return;
+      const capacitorPort = capacitors[0];
+      const component = index.components.get(capacitorPort.source_component_id);
+      if (component.ftype !== "simple_capacitor" || !Number.isFinite(component.capacitance) || component.capacitance <= 0)
+        return;
+      const capacitor = this.localPart(capacitorPort.source_component_id);
+      if (!capacitor || !index.sameLocalScope(inductor.placement, capacitor.placement))
+        return;
+      const capPin = index.port(capacitorPort);
+      const seriesPin = index.port(inductor.ports.find((p) => index.connected(p.source_port_id) === net));
+      return {
+        placement: capacitor.placement,
+        ground: index.twoTerminalNets(capacitorPort.source_component_id).find((n) => n !== net),
+        distance: Math.hypot(capPin.center.x - seriesPin.center.x, capPin.center.y - seriesPin.center.y)
+      };
+    });
+    const [first, second] = branches;
+    if (!first || !second || first.ground !== second.ground)
+      return;
+    const placements = [inductor.placement, first.placement, second.placement];
+    const maxRecommendedSignalPinDistance = Math.max(4, ...placements.map((p) => 3 * Math.max(p.width, p.height)));
+    const maxSignalPinDistance = Math.max(first.distance, second.distance);
+    if (maxSignalPinDistance <= maxRecommendedSignalPinDistance)
+      return;
+    const name = (p) => p.sourceComponentName || "component";
+    this.params.issues.push({
+      lineItemType: "PiFilterComponentsNotGrouped",
+      inductorSchematicBox: inductor.placement,
+      firstCapacitorSchematicBox: first.placement,
+      secondCapacitorSchematicBox: second.placement,
+      maxSignalPinDistance,
+      maxRecommendedSignalPinDistance,
+      message: `Group ${name(first.placement)} and ${name(second.placement)} beside the connected ends of ${name(inductor.placement)} so the series path and both grounded branches of the pi filter can be read together. Preserve pin connections, allow room for labels, and reroute affected traces.`
+    });
+  }
+  localPart(id) {
+    const placement = this.index.placement(id);
+    const ports = this.index.portsByComponent.get(id);
+    if (!placement || ports?.length !== 2 || ports.some((p) => {
+      const pin = this.index.port(p);
+      return p.do_not_connect || !pin || pin.schematic_sheet_id !== placement.schematicSheetId || !Number.isFinite(pin.center.x) || !Number.isFinite(pin.center.y);
+    }))
+      return;
+    return { placement, ports };
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "inductorName", issue.inductorSchematicBox.sourceComponentName);
+    addAttr(attrs, "firstCapacitorName", issue.firstCapacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "secondCapacitorName", issue.secondCapacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "maxSignalPinDistance", issue.maxSignalPinDistance);
+    addAttr(attrs, "maxRecommendedSignalPinDistance", issue.maxRecommendedSignalPinDistance);
+    addAttr(attrs, "message", issue.message);
+    return `<PiFilterComponentsNotGrouped ${attrs.join(" ")} />`;
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/MosfetGateNetworkPlacementSolver/MosfetGateNetworkPlacementSolver.ts
-class MosfetGateNetworkPlacementSolver extends BaseSolver5 {
+import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
+class MosfetGateNetworkPlacementSolver extends BaseSolver9 {
   params;
   index;
   mosfetIds;
@@ -349951,7 +350462,7 @@ class MosfetGateNetworkPlacementSolver extends BaseSolver5 {
       gateSourceResistorSchematicBox: gateSourceResistor,
       maxBodyGap,
       maxRecommendedBodyGap,
-      message: `Group ${seriesGateResistor.sourceComponentName ?? seriesGateResistor.sourceComponentId} and ${gateSourceResistor.sourceComponentName ?? gateSourceResistor.sourceComponentId} beside ${mosfet.sourceComponentName ?? id}'s gate/source pins so the gate-drive branch can be read together. Preserve all pin connections, leave room for labels, and reroute affected traces.`
+      message: `Group ${seriesGateResistor.sourceComponentName || "component"} and ${gateSourceResistor.sourceComponentName || "component"} beside ${mosfet.sourceComponentName || "component"}'s gate/source pins so the gate-drive branch can be read together. Preserve all pin connections, leave room for labels, and reroute affected traces.`
     });
   }
   mosfetPorts(id) {
@@ -349988,8 +350499,8 @@ function bodyGap(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/RelayFlybackDiodePlacementSolver/RelayFlybackDiodePlacementSolver.ts
-import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
-class RelayFlybackDiodePlacementSolver extends BaseSolver6 {
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+class RelayFlybackDiodePlacementSolver extends BaseSolver10 {
   params;
   index;
   relayIds;
@@ -350052,7 +350563,7 @@ class RelayFlybackDiodePlacementSolver extends BaseSolver6 {
       diodeSchematicBox: diode,
       coilSourcePortIds: [coil[0].source_port_id, coil[1].source_port_id],
       distanceFromCoilPins,
-      message: `Place ${diode.sourceComponentName ?? diodeId} beside ${relay.sourceComponentName ?? relayId}'s coil pins so the flyback protection loop can be read together. Preserve diode polarity and all pin connections; leave room for labels and reroute affected traces.`
+      message: `Place ${diode.sourceComponentName || "component"} beside ${relay.sourceComponentName || "component"}'s coil pins so the flyback protection loop can be read together. Preserve diode polarity and all pin connections; leave room for labels and reroute affected traces.`
     });
   }
   hasWireAtPin(pin) {
@@ -350118,10 +350629,10 @@ function hasHint(port, pattern) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CurrentSenseShuntPlacementSolver/CurrentSenseShuntPlacementSolver.ts
-import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
 var EPSILON3 = 0.01;
 
-class CurrentSenseShuntPlacementSolver extends BaseSolver7 {
+class CurrentSenseShuntPlacementSolver extends BaseSolver11 {
   params;
   index;
   hostIds;
@@ -350208,7 +350719,7 @@ class CurrentSenseShuntPlacementSolver extends BaseSolver7 {
       positiveInputSourcePortId: inputs[0].source_port_id,
       negativeInputSourcePortId: inputs[1].source_port_id,
       inputBandGap,
-      message: `Place ${shunt.sourceComponentName ?? shuntId} near ${host.sourceComponentName ?? hostId}.${inputs[0].name}/${inputs[1].name}, so both sense connections can be read together. Move or rotate the shunt as needed; preserve all pin connections and leave room for labels.`
+      message: `Place ${shunt.sourceComponentName || "component"} near ${host.sourceComponentName || "component"}.${inputs[0].name}/${inputs[1].name}, so both sense connections can be read together. Move or rotate the shunt as needed; preserve all pin connections and leave room for labels.`
     });
   }
   hasVisibleConnection(from, to, net) {
@@ -350271,8 +350782,8 @@ function onSegment4(point, from, to) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VoltageDividerPlacementSolver/VoltageDividerPlacementSolver.ts
-import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
-class VoltageDividerPlacementSolver extends BaseSolver8 {
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+class VoltageDividerPlacementSolver extends BaseSolver12 {
   params;
   index;
   positiveNets = new Set;
@@ -350334,7 +350845,7 @@ class VoltageDividerPlacementSolver extends BaseSolver8 {
       supplyTapSourcePortId: supplyTap.bottom.source_port_id,
       groundTapSourcePortId: groundTap.top.source_port_id,
       reversedBodyGap,
-      message: `Place ${supply.sourceComponentName ?? supplyId} above ${ground.sourceComponentName ?? groundId}, close enough to read their shared divider tap. Preserve all connections and leave room for labels; exact alignment is not required.`
+      message: `Place ${supply.sourceComponentName || "component"} above ${ground.sourceComponentName || "component"}, close enough to read their shared divider tap. Preserve all connections and leave room for labels; exact alignment is not required.`
     });
   }
   isResistor(id) {
@@ -350368,8 +350879,8 @@ class VoltageDividerPlacementSolver extends BaseSolver8 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/RegulatorInputOutputCapacitorPlacementSolver/RegulatorInputOutputCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
-class RegulatorInputOutputCapacitorPlacementSolver extends BaseSolver9 {
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+class RegulatorInputOutputCapacitorPlacementSolver extends BaseSolver13 {
   params;
   index;
   hostIds;
@@ -350431,7 +350942,7 @@ class RegulatorInputOutputCapacitorPlacementSolver extends BaseSolver9 {
     };
     if (!beyondOppositeSide(inputCap, 1) || !beyondOppositeSide(outputCap, -1))
       return;
-    const name = host.sourceComponentName ?? hostId;
+    const name = host.sourceComponentName || "component";
     this.params.issues.push({
       lineItemType: "RegulatorCapacitorsOnWrongSides",
       regulatorSchematicBox: host,
@@ -350489,7 +351000,7 @@ function portRole(port) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ConnectorPlacementSolver/ConnectorPlacementSolver.ts
-import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
 function centeredRect(cx, cy, w, h) {
@@ -350515,11 +351026,11 @@ var directions = {
   down: { x: 0, y: -1 }
 };
 var dot3 = (a, b) => a.x * b.x + a.y * b.y;
-var distance49 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var near = (a, b) => distance49(a, b) <= EPSILON4;
+var distance50 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var near = (a, b) => distance50(a, b) <= EPSILON4;
 var round = (value) => Math.round(value * 100) / 100;
 
-class ConnectorPlacementSolver extends BaseSolver10 {
+class ConnectorPlacementSolver extends BaseSolver14 {
   params;
   constructor(params2) {
     super();
@@ -350603,10 +351114,10 @@ class ConnectorPlacementSolver extends BaseSolver10 {
         x: pin.center.x + delta.x,
         y: pin.center.y + delta.y
       });
-      if (connections.some((c) => distance49(movedPin(c.pin), c.peer.center) > distance49(c.pin.center, c.peer.center) + EPSILON4))
+      if (connections.some((c) => distance50(movedPin(c.pin), c.peer.center) > distance50(c.pin.center, c.peer.center) + EPSILON4))
         continue;
-      const before = connections.reduce((sum, c) => sum + distance49(c.pin.center, c.peer.center), 0);
-      const after = connections.reduce((sum, c) => sum + distance49(movedPin(c.pin), c.peer.center), 0);
+      const before = connections.reduce((sum, c) => sum + distance50(c.pin.center, c.peer.center), 0);
+      const after = connections.reduce((sum, c) => sum + distance50(movedPin(c.pin), c.peer.center), 0);
       if (before - after < 4 || after > before * 0.75)
         continue;
       const obstacles = ctx.componentPlacements.filter((p) => p.schematicSheetId === connector.schematicSheetId && p.schematicComponentId !== connector.schematicComponentId);
@@ -350638,7 +351149,7 @@ class ConnectorPlacementSolver extends BaseSolver10 {
           c.component
         ])).values()
       ];
-      const name = connector.sourceComponentName ?? connector.schematicComponentId;
+      const name = connector.sourceComponentName || "component";
       issues.push({
         lineItemType: "ConnectorPositionCausesTraceDetours",
         connectorSchematicBox: connector,
@@ -350653,7 +351164,7 @@ class ConnectorPlacementSolver extends BaseSolver10 {
         deltaSchY: round(delta.y),
         currentTotalSignalDistance: round(before),
         suggestedTotalSignalDistance: round(after),
-        message: `Move ${name} to schX=${target.x}, schY=${target.y} so its signal pins face ${connectedComponents.map((p) => p.sourceComponentName ?? p.schematicComponentId).join(", ")}. Preserve rotation and pin assignments; reroute the connections and attached rail labels.`
+        message: `Move ${name} to schX=${target.x}, schY=${target.y} so its signal pins face ${connectedComponents.map((p) => p.sourceComponentName || "component").join(", ")}. Preserve rotation and pin assignments; reroute the connections and attached rail labels.`
       });
     }
     this.solved = true;
@@ -350661,7 +351172,7 @@ class ConnectorPlacementSolver extends BaseSolver10 {
   static issueToString(issue) {
     const attrs = [];
     addAttr(attrs, "connectorComponentName", issue.connectorSchematicBox.sourceComponentName);
-    addAttr(attrs, "connectedComponents", issue.connectedComponents.map((p) => p.sourceComponentName ?? p.schematicComponentId).join(","));
+    addAttr(attrs, "connectedComponents", issue.connectedComponents.map((p) => p.sourceComponentName || "component").join(","));
     for (const key of [
       "evaluatedSignalCount",
       "newSchX",
@@ -350705,8 +351216,8 @@ function segmentCrossesBox(a, b, box) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/LowSideTransistorPlacementSolver/LowSideTransistorPlacementSolver.ts
-import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
-class LowSideTransistorPlacementSolver extends BaseSolver11 {
+import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
+class LowSideTransistorPlacementSolver extends BaseSolver15 {
   index;
   positiveNets = new Set;
   transistorIds;
@@ -350795,8 +351306,8 @@ class LowSideTransistorPlacementSolver extends BaseSolver11 {
       placementProblems.push("emitter_not_down");
     if (placementProblems.length === 0)
       return;
-    const name = transistor.sourceComponentName ?? id;
-    const loadName = load2.sourceComponentName ?? loadId;
+    const name = transistor.sourceComponentName || "component";
+    const loadName = load2.sourceComponentName || "component";
     this.issues.push({
       lineItemType: "LowSideTransistorNotAlignedWithLoad",
       transistorSchematicBox: transistor,
@@ -350808,7 +351319,7 @@ class LowSideTransistorPlacementSolver extends BaseSolver11 {
       collectorFacingDirection,
       emitterFacingDirection,
       placementProblems,
-      message: `Arrange ${name} below ${loadName}, with its collector facing up toward the load and emitter facing down toward ground; place ${baseResistor.sourceComponentName ?? resistorId} beside the base. Preserve all pin connections and reroute affected traces.`
+      message: `Arrange ${name} below ${loadName}, with its collector facing up toward the load and emitter facing down toward ground; place ${baseResistor.sourceComponentName || "component"} beside the base. Preserve all pin connections and reroute affected traces.`
     });
   }
   static issueToString(issue) {
@@ -350826,8 +351337,8 @@ class LowSideTransistorPlacementSolver extends BaseSolver11 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/UsbSeriesResistorPlacementSolver/UsbSeriesResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
-class UsbSeriesResistorPlacementSolver extends BaseSolver12 {
+import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
+class UsbSeriesResistorPlacementSolver extends BaseSolver16 {
   params;
   index;
   hostIds;
@@ -350877,8 +351388,8 @@ class UsbSeriesResistorPlacementSolver extends BaseSolver12 {
     if (bodyGap < Math.max(alongA, alongB) || across >= (acrossA + acrossB) / 2 - 0.01)
       return;
     this.reportedPairs.add(pairKey);
-    const positiveName = a.sourceComponentName ?? positive.id;
-    const negativeName = b.sourceComponentName ?? negative.id;
+    const positiveName = a.sourceComponentName || "component";
+    const negativeName = b.sourceComponentName || "component";
     this.params.issues.push({
       lineItemType: "UsbSeriesResistorsNotAligned",
       positiveResistorSchematicBox: a,
@@ -350947,7 +351458,7 @@ function usbRole(port) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/graphics.ts
 import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
@@ -350982,7 +351493,7 @@ function visualizeCircuitJson(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-class CapacitorOrientationSolver extends BaseSolver13 {
+class CapacitorOrientationSolver extends BaseSolver17 {
   static EPSILON = 0.01;
   static ORIENTATION_MESSAGE = 'Use schOrientation="vertical" on this capacitor to fix the symbol orientation';
   ctx;
@@ -351127,10 +351638,10 @@ class CapacitorOrientationSolver extends BaseSolver13 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DecouplingCapacitorGroupingSolver/DecouplingCapacitorGroupingSolver.ts
-import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
-class DecouplingCapacitorGroupingSolver extends BaseSolver14 {
+import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
+class DecouplingCapacitorGroupingSolver extends BaseSolver18 {
   params;
-  static MIN_BODY_GAP = 4;
+  static MIN_BODY_GAP = 1;
   banks = [];
   netNames = new Map;
   bankIndex = 0;
@@ -351189,19 +351700,28 @@ class DecouplingCapacitorGroupingSolver extends BaseSolver14 {
     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)));
+    const maxRecommendedBodyGap = Math.max(DecouplingCapacitorGroupingSolver.MIN_BODY_GAP, ...bank.capacitors.map((box) => 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);
+    const pending = bank.capacitors.slice(1).map((box) => ({
+      box,
+      gap: DecouplingCapacitorGroupingSolver.bodyGap(bank.capacitors[0], box)
+    }));
+    while (pending.length > 0) {
+      let closest = 0;
+      for (let i = 1;i < pending.length; i++) {
+        if (pending[i].gap < pending[closest].gap)
+          closest = i;
+      }
+      const next = pending.splice(closest, 1)[0];
+      maxBodyGap = Math.max(maxBodyGap, next.gap);
+      for (const candidate of pending) {
+        candidate.gap = Math.min(candidate.gap, DecouplingCapacitorGroupingSolver.bodyGap(next.box, candidate.box));
       }
     }
     if (maxBodyGap <= maxRecommendedBodyGap + 0.000001)
       return;
-    const railName = this.netNames.get(bank.power) ?? bank.power;
-    const groundName = this.netNames.get(bank.ground) ?? bank.ground;
+    const railName = this.netNames.get(bank.power) ?? "power";
+    const groundName = this.netNames.get(bank.ground) ?? "ground";
     this.params.issues.push({
       lineItemType: "DecouplingCapacitorsNotCloseTogether",
       railName,
@@ -351212,11 +351732,14 @@ class DecouplingCapacitorGroupingSolver extends BaseSolver14 {
       message: `Group the decoupling capacitors between ${railName} and ${groundName} closer together in this schematic block. Preserve their net connections.`
     });
   }
+  static bodyGap(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));
+  }
   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, "capacitorNames", issue.capacitorSchematicBoxes.map((box) => box.sourceComponentName || "component").join(", "));
     addAttr(attrs, "maxBodyGap", issue.maxBodyGap);
     addAttr(attrs, "maxRecommendedBodyGap", issue.maxRecommendedBodyGap);
     addAttr(attrs, "message", issue.message);
@@ -351260,8 +351783,8 @@ function getNetLabelBounds(label) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
-class ComponentNetLabelCollisionSolver extends BaseSolver15 {
+import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
+class ComponentNetLabelCollisionSolver extends BaseSolver19 {
   params;
   placements;
   netLabelsByComponentId;
@@ -351525,7 +352048,7 @@ class ComponentNetLabelCollisionSolver extends BaseSolver15 {
         if (!comp || Math.abs(newX - comp.schX) < 0.000000001)
           continue;
         result.set(compId, {
-          componentName: comp.sourceComponentName ?? compId,
+          componentName: comp.sourceComponentName || "component",
           newSchX: Math.round(newX * 100) / 100,
           newSchY: Math.round(comp.schY * 100) / 100
         });
@@ -351585,8 +352108,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver15 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver16 {
+import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver20 {
   static ALIGNMENT_EPSILON = 0.01;
   ctx;
   out;
@@ -351683,7 +352206,7 @@ class ComponentPinAlignmentSolver extends BaseSolver16 {
     if (!bestCandidate || bestCandidate.pairs.length < 2 || bestCandidate.pairs.length <= currentlyAlignedPinCount) {
       return;
     }
-    const targetName = rightPlacement.sourceComponentName ?? rightPlacement.schematicComponentId ?? "component";
+    const targetName = rightPlacement.sourceComponentName || "component";
     const deltaSchY = bestCandidate.deltaSchY;
     const newSchY = rightPlacement.schY + deltaSchY;
     return {
@@ -351720,8 +352243,8 @@ class ComponentPinAlignmentSolver extends BaseSolver16 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CrystalLoadCapacitorPlacementSolver/CrystalLoadCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
-class CrystalLoadCapacitorPlacementSolver extends BaseSolver17 {
+import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
+class CrystalLoadCapacitorPlacementSolver extends BaseSolver21 {
   static ALIGNMENT_TOLERANCE = 0.1;
   issues;
   networks;
@@ -351876,14 +352399,14 @@ class CrystalLoadCapacitorPlacementSolver extends BaseSolver17 {
     return `<CrystalNotCenteredOverLoadCapacitors ${attrs.join(" ")} />`;
   }
 }
-var pairDistance = (pair, crystal) => distance50(pair.firstConnection.capacitor, crystal) + distance50(pair.secondConnection.capacitor, crystal);
-var distance50 = (first, second) => Math.hypot(first.schX - second.schX, first.schY - second.schY);
+var pairDistance = (pair, crystal) => distance51(pair.firstConnection.capacitor, crystal) + distance51(pair.secondConnection.capacitor, crystal);
+var distance51 = (first, second) => Math.hypot(first.schX - second.schX, first.schY - second.schY);
 var round2 = (value) => Math.round(value * 100) / 100;
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
-import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
 import { getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2 } from "circuit-json-to-connectivity-map";
-class DiodeResistorAlignmentSolver extends BaseSolver18 {
+class DiodeResistorAlignmentSolver extends BaseSolver22 {
   static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
   ctx;
   out;
@@ -351949,8 +352472,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver18 {
       return;
     if (!this.sourceConnectivity.areIdsConnected(diodePort.source_port_id, resistorPort.source_port_id))
       return;
-    const diodeName = diodeBox.sourceComponentName ?? diodeCompId;
-    const resistorName = resistorBox.sourceComponentName ?? resistorCompId;
+    const diodeName = diodeBox.sourceComponentName || "component";
+    const resistorName = resistorBox.sourceComponentName || "component";
     const diodePin = diodePort?.display_pin_label ?? diodePort?.pin_number?.toString();
     const resistorPin = resistorPort?.display_pin_label ?? resistorPort?.pin_number?.toString();
     const diodeFacing = diodePort?.facing_direction;
@@ -352049,8 +352572,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver18 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/FeedbackNetworkPlacementSolver/FeedbackNetworkPlacementSolver.ts
-import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
-class FeedbackNetworkPlacementSolver extends BaseSolver19 {
+import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
+class FeedbackNetworkPlacementSolver extends BaseSolver23 {
   static MIN_BODY_GAP = 4;
   index;
   amplifierIds;
@@ -352110,7 +352633,7 @@ class FeedbackNetworkPlacementSolver extends BaseSolver19 {
     });
     if (distantComponents.length === 0)
       return;
-    const names = distantComponents.map(({ schematicBox }) => schematicBox.sourceComponentName ?? schematicBox.sourceComponentId).join(", ");
+    const names = distantComponents.map(({ schematicBox }) => schematicBox.sourceComponentName || "component").join(", ");
     this.issues.push({
       lineItemType: "FeedbackNetworkNotCompact",
       amplifierSchematicBox: amplifier,
@@ -352118,14 +352641,14 @@ class FeedbackNetworkPlacementSolver extends BaseSolver19 {
       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`
+      message: `consider grouping ${names} closer to ${amplifier.sourceComponentName || "component"}, 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, "feedbackComponentNames", issue.feedbackComponents.map((box) => box.sourceComponentName || "component").join(", "));
+    addAttr(attrs, "distantComponentNames", issue.distantComponents.map(({ schematicBox }) => schematicBox.sourceComponentName || "component").join(", "));
     addAttr(attrs, "message", issue.message);
     return `<FeedbackNetworkNotCompact ${attrs.join(" ")} />`;
   }
@@ -352135,7 +352658,7 @@ function distanceBetweenBoxes(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/switch-pull-resistor-pairs.ts
 function getSwitchPullResistorPairs(index) {
@@ -352199,7 +352722,7 @@ function getHorizontalPushbuttonComponentIds(index) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-class PullResistorPlacementSolver extends BaseSolver20 {
+class PullResistorPlacementSolver extends BaseSolver24 {
   static MIN_WRONG_SIDE_GAP = 1.5;
   index;
   resistorIds;
@@ -352281,7 +352804,7 @@ class PullResistorPlacementSolver extends BaseSolver20 {
       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"}`
+      message: `consider placing ${resistor.sourceComponentName || "component"} ${preferredSide} ${host.sourceComponentName || "component"}.${signalPort.name} so the pull-${pullDirection} branch reads toward ${pullDirection === "up" ? "power" : "ground"}`
     });
   }
   static issueToString(issue) {
@@ -352299,8 +352822,8 @@ class PullResistorPlacementSolver extends BaseSolver20 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentRailOrientationSolver/TwoPinComponentRailOrientationSolver.ts
-import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
-class TwoPinComponentRailOrientationSolver extends BaseSolver21 {
+import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
+class TwoPinComponentRailOrientationSolver extends BaseSolver25 {
   static EPSILON = 0.01;
   index;
   powerNets;
@@ -352365,7 +352888,10 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver21 {
     const otherPort = index.port(otherSourcePort);
     if (!railPort || !otherPort)
       return;
-    const invertedRails = this.positiveVoltageNets.has(rail) && this.groundNets.has(index.connected(otherSourcePort.source_port_id)) && Math.abs(railPort.center.x - otherPort.center.x) <= TwoPinComponentRailOrientationSolver.EPSILON && railPort.center.y < otherPort.center.y - TwoPinComponentRailOrientationSolver.EPSILON && railPort.facing_direction === "down" && otherPort.facing_direction === "up";
+    const otherNet = index.connected(otherSourcePort.source_port_id);
+    const otherIsGround = this.groundNets.has(otherNet);
+    const isSupplyToSignalResistor = sourceComponent?.ftype === "simple_resistor" && !this.powerNets.has(otherNet) && !otherIsGround;
+    const invertedRails = this.positiveVoltageNets.has(rail) && (otherIsGround || isSupplyToSignalResistor) && Math.abs(railPort.center.x - otherPort.center.x) <= TwoPinComponentRailOrientationSolver.EPSILON && railPort.center.y < otherPort.center.y - TwoPinComponentRailOrientationSolver.EPSILON && railPort.facing_direction === "down" && otherPort.facing_direction === "up";
     if (invertedRails) {
       this.issues.push({
         lineItemType: "TwoPinComponentHasInvertedRails",
@@ -352375,7 +352901,7 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver21 {
         railType: "power",
         deltaSchRotation: 180,
         suggestedRailFacingDirection: "up",
-        message: `rotate ${component.sourceComponentName ?? id} by 180° so its positive-supply pin faces up and its ground pin faces down; preserve pin connections and reroute attached traces`
+        message: `rotate ${component.sourceComponentName || "component"} by 180° so its positive-supply pin faces up and its ${otherIsGround ? "ground" : "signal"} pin faces down; preserve pin connections and reroute attached traces`
       });
       return;
     }
@@ -352394,7 +352920,7 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver21 {
       railType,
       deltaSchRotation,
       suggestedRailFacingDirection,
-      message: `rotate ${component.sourceComponentName ?? id} by ${deltaSchRotation}° so its ${railType}-connected pin faces ${suggestedRailFacingDirection} and the component is vertical`
+      message: `rotate ${component.sourceComponentName || "component"} by ${deltaSchRotation}° so its ${railType}-connected pin faces ${suggestedRailFacingDirection} and the component is vertical`
     });
   }
   static issueToString(issue) {
@@ -352409,32 +352935,220 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver21 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-box-labels.ts
+var PIN_LABEL_EDGE_PADDING = 0.1;
+var PIN_LABEL_TEXT_HEIGHT = 0.15;
+var INNER_LABEL_COLLISION_PADDING = 0.02;
+var COLLISION_COMPARISON_EPSILON = 0.000000001;
+function getSchematicBoxLabelRects(box, ports, getLabelLength) {
+  const bounds = {
+    left: box.schX - box.width / 2,
+    right: box.schX + box.width / 2,
+    top: box.schY + box.height / 2,
+    bottom: box.schY - box.height / 2
+  };
+  const rects = [];
+  for (const port of ports) {
+    if (!port.side_of_component)
+      continue;
+    if (!port.display_pin_label)
+      continue;
+    const labelLength = getLabelLength(port);
+    const halfTextHeight = PIN_LABEL_TEXT_HEIGHT / 2;
+    switch (port.side_of_component) {
+      case "left": {
+        const xMin = bounds.left + PIN_LABEL_EDGE_PADDING;
+        rects.push({
+          side: port.side_of_component,
+          xMin,
+          xMax: xMin + labelLength,
+          yMin: port.center.y - halfTextHeight,
+          yMax: port.center.y + halfTextHeight
+        });
+        break;
+      }
+      case "right": {
+        const xMax = bounds.right - PIN_LABEL_EDGE_PADDING;
+        rects.push({
+          side: port.side_of_component,
+          xMin: xMax - labelLength,
+          xMax,
+          yMin: port.center.y - halfTextHeight,
+          yMax: port.center.y + halfTextHeight
+        });
+        break;
+      }
+      case "top": {
+        const yMax = bounds.top - PIN_LABEL_EDGE_PADDING;
+        rects.push({
+          side: port.side_of_component,
+          xMin: port.center.x - halfTextHeight,
+          xMax: port.center.x + halfTextHeight,
+          yMin: yMax - labelLength,
+          yMax
+        });
+        break;
+      }
+      case "bottom": {
+        const yMin = bounds.bottom + PIN_LABEL_EDGE_PADDING;
+        rects.push({
+          side: port.side_of_component,
+          xMin: port.center.x - halfTextHeight,
+          xMax: port.center.x + halfTextHeight,
+          yMin,
+          yMax: yMin + labelLength
+        });
+        break;
+      }
+    }
+  }
+  return rects;
+}
+function schematicLabelRectsOverlap(a, b, padding = INNER_LABEL_COLLISION_PADDING) {
+  return schematicLabelIntervalsOverlap(a.xMin, a.xMax, b.xMin, b.xMax, padding) && schematicLabelIntervalsOverlap(a.yMin, a.yMax, b.yMin, b.yMax, padding);
+}
+function schematicLabelIntervalsOverlap(aMin, aMax, bMin, bMax, padding = INNER_LABEL_COLLISION_PADDING) {
+  return Math.min(aMax, bMax) - Math.max(aMin, bMin) + padding > COLLISION_COMPARISON_EPSILON;
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-box-components.ts
 function getSchematicBoxComponentIds(circuitJson) {
   return new Set(circuitJson.flatMap((element) => element.type === "schematic_component" && element.is_box_with_pins !== false && !element.symbol_name && !element.schematic_symbol_id ? [element.schematic_component_id] : []));
 }
 
+// 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);
+var getSchematicTextWidth = (text, fontSize) => widthInEm(text) * fontSize;
+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/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
+import { BaseSolver as BaseSolver26 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver26 {
   params;
-  MESSAGE = "Inner labels are colliding. Increase the schWidth or schHeight.";
-  PIN_LABEL_EDGE_PADDING = 0.1;
-  PIN_LABEL_TEXT_HEIGHT = 0.15;
-  PIN_NAME_CHARACTER_WIDTH = 0.095;
-  FALLBACK_CHARACTER_WIDTH = 0.13;
-  INNER_LABEL_COLLISION_PADDING = 0.02;
-  COLLISION_COMPARISON_EPSILON = 0.000000001;
   entries;
   placementById;
-  sourcePortById;
   currentIndex = 0;
   constructor(params2) {
     super();
     this.params = params2;
     const { circuitJson, componentPlacements } = params2.ctx;
     this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
-    this.sourcePortById = this.getSourcePortById(circuitJson);
     const boxIds = getSchematicBoxComponentIds(circuitJson);
     this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson)).filter(([id]) => boxIds.has(id));
     this.solved = this.entries.length === 0;
@@ -352450,8 +353164,7 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
     const schematicBox = this.placementById.get(schematicComponentId);
     if (!schematicBox)
       return;
-    const bounds = this.getCenteredRectBounds(schematicBox);
-    const labelRects = this.getLabelRects(bounds, ports, this.sourcePortById);
+    const labelRects = getSchematicBoxLabelRects(schematicBox, ports, (port) => getSchematicTextWidth(port.display_pin_label, 0.15));
     if (labelRects.length === 0)
       return;
     const collisionSummary = this.getCollisionSummary(labelRects);
@@ -352461,7 +353174,7 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
       lineItemType: "SchematicBoxInnerLabelCollision",
       schematicBox,
       overlappingSides: collisionSummary.overlappingSides,
-      message: this.MESSAGE
+      message: this.getMessage(collisionSummary.overlappingSides)
     });
   }
   static issueToString(issue) {
@@ -352473,37 +353186,16 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
     addAttr(attrs, "overlappingSides", issue.overlappingSides.join(","));
     return `<SchematicBoxInnerLabelCollision ${attrs.join(" ")} />`;
   }
+  getMessage(sides) {
+    const dimension = sides.every((side) => side === "left" || side === "right") ? "schWidth" : sides.every((side) => side === "top" || side === "bottom") ? "schHeight" : "schWidth or schHeight";
+    return `Inner labels are colliding. Increase the ${dimension}.`;
+  }
   isSchematicPort(el) {
     return el.type === "schematic_port";
   }
-  isSourcePort(el) {
-    return el.type === "source_port";
-  }
   isSchematicSide(side) {
     return side === "left" || side === "right" || side === "top" || side === "bottom";
   }
-  isPinNameLabel(label, sourcePort) {
-    if (!sourcePort)
-      return false;
-    return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
-  }
-  estimateLabelLength(label, sourcePort) {
-    return Array.from(label).length * (this.isPinNameLabel(label, sourcePort) ? this.PIN_NAME_CHARACTER_WIDTH : this.FALLBACK_CHARACTER_WIDTH);
-  }
-  hasCollision(requiredGrowth) {
-    return requiredGrowth > this.COLLISION_COMPARISON_EPSILON;
-  }
-  getCenteredRectBounds(box) {
-    return {
-      left: box.schX - box.width / 2,
-      right: box.schX + box.width / 2,
-      top: box.schY + box.height / 2,
-      bottom: box.schY - box.height / 2
-    };
-  }
-  getSourcePortById(circuitJson) {
-    return new Map(circuitJson.filter((el) => this.isSourcePort(el)).map((sp) => [sp.source_port_id, sp]));
-  }
   getPlacementBySchematicComponentId(componentPlacements) {
     return new Map(componentPlacements.filter((p) => p.schematicComponentId).map((p) => [p.schematicComponentId, p]));
   }
@@ -352522,64 +353214,6 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
     }
     return map;
   }
-  getLabelRects(bounds, ports, sourcePortById) {
-    const rects = [];
-    for (const port of ports) {
-      if (!this.isSchematicSide(port.side_of_component))
-        continue;
-      if (!port.display_pin_label)
-        continue;
-      const labelLength = this.estimateLabelLength(port.display_pin_label, sourcePortById.get(port.source_port_id));
-      const halfTextHeight = this.PIN_LABEL_TEXT_HEIGHT / 2;
-      switch (port.side_of_component) {
-        case "left": {
-          const xMin = bounds.left + this.PIN_LABEL_EDGE_PADDING;
-          rects.push({
-            side: port.side_of_component,
-            xMin,
-            xMax: xMin + labelLength,
-            yMin: port.center.y - halfTextHeight,
-            yMax: port.center.y + halfTextHeight
-          });
-          break;
-        }
-        case "right": {
-          const xMax = bounds.right - this.PIN_LABEL_EDGE_PADDING;
-          rects.push({
-            side: port.side_of_component,
-            xMin: xMax - labelLength,
-            xMax,
-            yMin: port.center.y - halfTextHeight,
-            yMax: port.center.y + halfTextHeight
-          });
-          break;
-        }
-        case "top": {
-          const yMax = bounds.top - this.PIN_LABEL_EDGE_PADDING;
-          rects.push({
-            side: port.side_of_component,
-            xMin: port.center.x - halfTextHeight,
-            xMax: port.center.x + halfTextHeight,
-            yMin: yMax - labelLength,
-            yMax
-          });
-          break;
-        }
-        case "bottom": {
-          const yMin = bounds.bottom + this.PIN_LABEL_EDGE_PADDING;
-          rects.push({
-            side: port.side_of_component,
-            xMin: port.center.x - halfTextHeight,
-            xMax: port.center.x + halfTextHeight,
-            yMin,
-            yMax: yMin + labelLength
-          });
-          break;
-        }
-      }
-    }
-    return rects;
-  }
   getCollisionSummary(rects) {
     const overlappingSides = new Set;
     for (let i = 0;i < rects.length; i++) {
@@ -352588,7 +353222,7 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
         const b = rects[j];
         if (a.side === b.side)
           continue;
-        if (!this.rectsOverlap(a, b))
+        if (!schematicLabelRectsOverlap(a, b))
           continue;
         overlappingSides.add(a.side);
         overlappingSides.add(b.side);
@@ -352598,9 +353232,6 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
       overlappingSides: this.sortSides(Array.from(overlappingSides))
     };
   }
-  rectsOverlap(a, b) {
-    return this.hasCollision(Math.min(a.xMax, b.xMax) - Math.max(a.xMin, b.xMin) + this.INNER_LABEL_COLLISION_PADDING) && this.hasCollision(Math.min(a.yMax, b.yMax) - Math.max(a.yMin, b.yMin) + this.INNER_LABEL_COLLISION_PADDING);
-  }
   sortSides(sides) {
     const order = {
       left: 0,
@@ -352613,8 +353244,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
-import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver23 {
+import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver27 {
   params;
   placements;
   firstIndex = 0;
@@ -352732,20 +353363,158 @@ class SchematicBoxOverlapSolver extends BaseSolver23 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-box-graphics.ts
+function getSchematicBoxGraphicBounds(circuitJson, componentId) {
+  let bounds;
+  for (const element of circuitJson) {
+    if (element.type !== "schematic_path" && element.type !== "schematic_circle" && element.type !== "schematic_rect" || element.schematic_component_id !== componentId)
+      continue;
+    const stroke = (element.stroke_width ?? 0.02) / 2;
+    let current;
+    if (element.type === "schematic_path") {
+      if (!element.points.length)
+        continue;
+      current = {
+        xMin: Math.min(...element.points.map((p) => p.x)),
+        xMax: Math.max(...element.points.map((p) => p.x)),
+        yMin: Math.min(...element.points.map((p) => p.y)),
+        yMax: Math.max(...element.points.map((p) => p.y))
+      };
+    } else {
+      const angle = element.type === "schematic_rect" ? (element.rotation ?? 0) * Math.PI / 180 : 0;
+      const width = element.type === "schematic_circle" ? 2 * element.radius : element.width;
+      const height = element.type === "schematic_circle" ? 2 * element.radius : element.height;
+      const halfWidth = (Math.abs(width * Math.cos(angle)) + Math.abs(height * Math.sin(angle))) / 2;
+      const halfHeight = (Math.abs(width * Math.sin(angle)) + Math.abs(height * Math.cos(angle))) / 2;
+      current = {
+        xMin: element.center.x - halfWidth,
+        xMax: element.center.x + halfWidth,
+        yMin: element.center.y - halfHeight,
+        yMax: element.center.y + halfHeight
+      };
+    }
+    current.xMin -= stroke;
+    current.xMax += stroke;
+    current.yMin -= stroke;
+    current.yMax += stroke;
+    bounds = bounds ? {
+      xMin: Math.min(bounds.xMin, current.xMin),
+      xMax: Math.max(bounds.xMax, current.xMax),
+      yMin: Math.min(bounds.yMin, current.yMin),
+      yMax: Math.max(bounds.yMax, current.yMax)
+    } : current;
+  }
+  return bounds;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-box-resize.ts
+var MINIMUM_RESIZE_LABEL_BANK_GAP = 0.2;
+var getPinLabelLength = (port) => Array.from(port.display_pin_label ?? "").length * 0.095;
+function getSafeSchematicBoxResize(box, ports, pinSpacing, proposed, minimumReduction = 0, graphics) {
+  if (!Number.isFinite(pinSpacing) || pinSpacing <= 0)
+    return;
+  if (ports.some((port) => !port.side_of_component))
+    return;
+  if (!contentsFit(box, ports, INNER_LABEL_COLLISION_PADDING, graphics))
+    return;
+  let minWidth = 0;
+  let minHeight = 0;
+  for (const port of ports) {
+    if (port.side_of_component === "left" || port.side_of_component === "right") {
+      minHeight = Math.max(minHeight, 2 * (Math.abs(port.center.y - box.schY) + pinSpacing));
+    } else {
+      minWidth = Math.max(minWidth, 2 * (Math.abs(port.center.x - box.schX) + pinSpacing));
+    }
+  }
+  const width = proposed.width === undefined ? box.width : Math.max(proposed.width, minWidth, getContentLimitedDimension(box, ports, "width", graphics));
+  const height = proposed.height === undefined ? box.height : Math.max(proposed.height, minHeight, getContentLimitedDimension(box, ports, "height", graphics));
+  const isUsefulReduction = (reduction) => reduction > 0.000000001 && reduction >= minimumReduction - 0.000000001;
+  const suggestedWidth = isUsefulReduction(box.width - width) ? width : undefined;
+  const suggestedHeight = isUsefulReduction(box.height - height) ? height : undefined;
+  if (suggestedWidth === undefined && suggestedHeight === undefined)
+    return;
+  const candidates = [
+    { width: suggestedWidth, height: suggestedHeight }
+  ];
+  if (suggestedWidth !== undefined && suggestedHeight !== undefined) {
+    candidates.push({ width: suggestedWidth }, { height: suggestedHeight });
+  }
+  const area = (candidate) => (candidate.width ?? box.width) * (candidate.height ?? box.height);
+  candidates.sort((a, b) => area(a) - area(b));
+  return candidates.find((candidate) => contentsFit({
+    ...box,
+    width: candidate.width ?? box.width,
+    height: candidate.height ?? box.height
+  }, ports, MINIMUM_RESIZE_LABEL_BANK_GAP, graphics));
+}
+function getContentLimitedDimension(box, ports, dimension, graphics) {
+  const current = box[dimension];
+  const center = dimension === "width" ? box.schX : box.schY;
+  const minKey = dimension === "width" ? "xMin" : "yMin";
+  const maxKey = dimension === "width" ? "xMax" : "yMax";
+  const otherMinKey = dimension === "width" ? "yMin" : "xMin";
+  const otherMaxKey = dimension === "width" ? "yMax" : "xMax";
+  const speed = (label) => {
+    if (dimension === "width") {
+      return label.side === "left" ? -0.5 : label.side === "right" ? 0.5 : 0;
+    }
+    return label.side === "bottom" ? -0.5 : label.side === "top" ? 0.5 : 0;
+  };
+  let minimum = 0;
+  const constrainGap = (gap, rate, requiredGap = 0) => {
+    if (rate > 0)
+      minimum = Math.max(minimum, current + (requiredGap - gap) / rate);
+  };
+  const labels = getSchematicBoxLabelRects(box, ports, getPinLabelLength);
+  if (graphics)
+    labels.push(graphics);
+  for (let i = 0;i < labels.length; i++) {
+    const a = labels[i];
+    constrainGap(a[minKey] - (center - current / 2), speed(a) + 0.5);
+    constrainGap(center + current / 2 - a[maxKey], 0.5 - speed(a));
+    for (let j = i + 1;j < labels.length; j++) {
+      const b = labels[j];
+      const requiredGap = a.side && b.side && a.side !== b.side ? MINIMUM_RESIZE_LABEL_BANK_GAP : INNER_LABEL_COLLISION_PADDING;
+      if (!schematicLabelIntervalsOverlap(a[otherMinKey], a[otherMaxKey], b[otherMinKey], b[otherMaxKey], requiredGap))
+        continue;
+      const [first, second] = a[maxKey] <= b[minKey] ? [a, b] : [b, a];
+      constrainGap(second[minKey] - first[maxKey], speed(second) - speed(first), requiredGap);
+    }
+  }
+  return minimum;
+}
+function contentsFit(resized, ports, labelBankGap = INNER_LABEL_COLLISION_PADDING, graphics) {
+  if (!Number.isFinite(resized.width) || !Number.isFinite(resized.height))
+    return false;
+  const labels = getSchematicBoxLabelRects(resized, ports, getPinLabelLength);
+  if (graphics)
+    labels.push(graphics);
+  for (let i = 0;i < labels.length; i++) {
+    const a = labels[i];
+    if (a.xMin < resized.schX - resized.width / 2 - 0.000000001 || a.xMax > resized.schX + resized.width / 2 + 0.000000001 || a.yMin < resized.schY - resized.height / 2 - 0.000000001 || a.yMax > resized.schY + resized.height / 2 + 0.000000001)
+      return false;
+    for (let j = i + 1;j < labels.length; j++) {
+      const b = labels[j];
+      const gap = a.side && b.side && a.side !== b.side ? labelBankGap : INNER_LABEL_COLLISION_PADDING;
+      if (schematicLabelRectsOverlap(a, b, gap))
+        return false;
+    }
+  }
+  return true;
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver24 {
+import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver28 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
   GENERIC_MAX_ALLOWED_GAP = 1;
   PIN_LABEL_EDGE_PADDING = 0.1;
-  PIN_NAME_CHARACTER_WIDTH = 0.095;
-  FALLBACK_CHARACTER_WIDTH = 0.13;
   GAP_COMPARISON_EPSILON = 0.000000001;
   entries;
   placementById;
-  sourcePortById;
+  schematicComponentById;
   sourceComponentById;
   currentIndex = 0;
   constructor(params2) {
@@ -352753,7 +353522,7 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
     this.params = params2;
     const { circuitJson, componentPlacements } = params2.ctx;
     this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
-    this.sourcePortById = this.getSourcePortById(circuitJson);
+    this.schematicComponentById = new Map(circuitJson.filter((element) => element.type === "schematic_component").map((component) => [component.schematic_component_id, component]));
     this.sourceComponentById = this.getSourceComponentById(circuitJson);
     const boxIds = getSchematicBoxComponentIds(circuitJson);
     this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson)).filter(([id]) => boxIds.has(id));
@@ -352770,12 +353539,9 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
     const schematicBox = this.placementById.get(schematicComponentId);
     if (!schematicBox)
       return;
-    const sourceComponent = schematicBox.sourceComponentId ? this.sourceComponentById.get(schematicBox.sourceComponentId) : undefined;
-    if (sourceComponent?.ftype === "simple_connector" && sourceComponent.standard === "usb_c")
-      return;
     const bounds = this.getCenteredRectBounds(schematicBox);
-    const leftCol = this.getLabelColumn("left", ports, this.sourcePortById);
-    const rightCol = this.getLabelColumn("right", ports, this.sourcePortById);
+    const leftCol = this.getLabelColumn("left", ports);
+    const rightCol = this.getLabelColumn("right", ports);
     const ftype = this.getSourceComponentFtype(schematicBox, this.sourceComponentById);
     let measuredSpace;
     if (leftCol && rightCol) {
@@ -352790,11 +353556,18 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
     const maxAllowed = ftype === "simple_pin_header" ? this.PIN_HEADER_MAX_ALLOWED_GAP : this.GENERIC_MAX_ALLOWED_GAP;
     if (!this.exceedsMaxAllowedGap(measuredSpace, maxAllowed))
       return;
-    const suggestedSchWidth = this.getSuggestedWidth({
+    const proposedWidth = this.getSuggestedWidth({
       measuredInnerLabelHorizontalEmptySpace: measuredSpace,
       maxAllowedInnerLabelHorizontalEmptySpace: maxAllowed,
       currentWidth: schematicBox.width
     });
+    const pinSpacing = this.schematicComponentById.get(schematicComponentId)?.pin_spacing;
+    if (pinSpacing === undefined)
+      return;
+    const resize = getSafeSchematicBoxResize(schematicBox, ports, pinSpacing, { width: proposedWidth }, 0, getSchematicBoxGraphicBounds(this.params.ctx.circuitJson, schematicComponentId));
+    if (resize?.width === undefined)
+      return;
+    const suggestedSchWidth = resize.width;
     if (ftype === "simple_pin_header") {
       this.params.issues.push({
         lineItemType: "PinHeaderSchematicBoxTooWide",
@@ -352828,30 +353601,15 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
   isSchematicPort(el) {
     return el.type === "schematic_port";
   }
-  isSourcePort(el) {
-    return el.type === "source_port";
-  }
-  isHorizontalSide(side) {
-    return side === "left" || side === "right";
-  }
   getSourceComponentWithFtype(el) {
     if (el.type !== "source_component" || !("source_component_id" in el) || typeof el.source_component_id !== "string")
       return null;
     return {
       type: "source_component",
       source_component_id: el.source_component_id,
-      standard: "standard" in el && typeof el.standard === "string" ? el.standard : undefined,
       ftype: "ftype" in el && typeof el.ftype === "string" ? el.ftype : undefined
     };
   }
-  isPinNameLabel(label, sourcePort) {
-    if (!sourcePort)
-      return false;
-    return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
-  }
-  estimateLabelWidth(label, sourcePort) {
-    return Array.from(label).length * (this.isPinNameLabel(label, sourcePort) ? this.PIN_NAME_CHARACTER_WIDTH : this.FALLBACK_CHARACTER_WIDTH);
-  }
   exceedsMaxAllowedGap(measured, maxAllowed) {
     return measured - maxAllowed > this.GAP_COMPARISON_EPSILON;
   }
@@ -352863,9 +353621,6 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
       bottom: box.schY - box.height / 2
     };
   }
-  getSourcePortById(circuitJson) {
-    return new Map(circuitJson.filter((el) => this.isSourcePort(el)).map((sp) => [sp.source_port_id, sp]));
-  }
   getSourceComponentById(circuitJson) {
     return new Map(circuitJson.flatMap((el) => {
       const sc = this.getSourceComponentWithFtype(el);
@@ -352880,8 +353635,6 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
     for (const port of circuitJson.filter((el) => this.isSchematicPort(el))) {
       if (!port.schematic_component_id)
         continue;
-      if (!this.isHorizontalSide(port.side_of_component))
-        continue;
       const ports = map.get(port.schematic_component_id);
       if (ports)
         ports.push(port);
@@ -352893,10 +353646,8 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
   getSourceComponentFtype(schematicBox, sourceComponentById) {
     return schematicBox.sourceComponentId ? sourceComponentById.get(schematicBox.sourceComponentId)?.ftype : undefined;
   }
-  getLabelColumn(side, ports, sourcePortById) {
-    const widths = ports.filter((p) => p.side_of_component === side).flatMap((p) => p.display_pin_label ? [
-      this.estimateLabelWidth(p.display_pin_label, sourcePortById.get(p.source_port_id))
-    ] : []);
+  getLabelColumn(side, ports) {
+    const widths = ports.filter((p) => p.side_of_component === side).flatMap((p) => p.display_pin_label ? [getPinLabelLength(p)] : []);
     if (widths.length === 0)
       return null;
     return {
@@ -352914,12 +353665,10 @@ class SchematicBoxTooWideSolver extends BaseSolver24 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
+import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver29 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
-  PIN_NAME_CHARACTER_WIDTH = 0.095;
-  FALLBACK_CHARACTER_WIDTH = 0.13;
   GAP_COMPARISON_EPSILON = 0.000000001;
   entries;
   placementById;
@@ -352951,7 +353700,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
     const pinSpacing = this.getPinSpacing(schematicBox, this.schematicComponentById);
     if (pinSpacing === null)
       return;
-    const maxLabelLengthBySide = this.getMaxLabelLengthBySide(ports, this.sourcePortById);
+    const maxLabelLengthBySide = this.getMaxLabelLengthBySide(ports);
     const portsBySide = new Map;
     for (const port of ports) {
       if (!this.isSchematicSide(port.side_of_component))
@@ -352960,7 +353709,6 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
       sidePorts.push(port);
       portsBySide.set(port.side_of_component, sidePorts);
     }
-    const useLabelAwareMaxPadding = this.hasPinsOnAllSides(portsBySide);
     const candidates = [];
     for (const [pinSide, sidePorts] of portsBySide) {
       if (sidePorts.length === 1)
@@ -352970,7 +353718,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
         if (!outerPin)
           continue;
         const measuredPadding = this.getPinPaddingToEdge(schematicBox, outerPin, edgeSide);
-        const maxAllowedPadding = useLabelAwareMaxPadding ? this.getMaxAllowedPinPadding(pinSpacing, edgeSide, maxLabelLengthBySide) : pinSpacing;
+        const maxAllowedPadding = Math.max(pinSpacing, this.getMaxAllowedPinPadding(pinSpacing, edgeSide, maxLabelLengthBySide));
         if (!this.exceedsMaxAllowedGap(measuredPadding, maxAllowedPadding + pinSpacing))
           continue;
         candidates.push({
@@ -352986,16 +353734,23 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
     if (!candidates.length)
       return;
     const details = candidates.map((candidate) => this.createIssue(candidate));
-    const representative = details.reduce((a, b) => b.excessPadding > a.excessPadding ? b : a);
     const widths = details.flatMap((detail) => detail.suggestedSchWidth === undefined ? [] : [detail.suggestedSchWidth]);
     const heights = details.flatMap((detail) => detail.suggestedSchHeight === undefined ? [] : [detail.suggestedSchHeight]);
+    const resize = getSafeSchematicBoxResize(schematicBox, ports, pinSpacing, {
+      width: widths.length ? Math.max(...widths) : undefined,
+      height: heights.length ? Math.max(...heights) : undefined
+    }, 2 * pinSpacing, getSchematicBoxGraphicBounds(this.params.ctx.circuitJson, schematicComponentId));
+    if (!resize)
+      return;
+    const applicableDetails = details.filter((detail) => resize.width !== undefined && detail.suggestedSchWidth !== undefined || resize.height !== undefined && detail.suggestedSchHeight !== undefined);
+    const representative = applicableDetails.reduce((a, b) => b.excessPadding > a.excessPadding ? b : a);
     const dimensions = [
-      widths.length ? "width" : "",
-      heights.length ? "height" : ""
+      resize.width === undefined ? "" : "width",
+      resize.height === undefined ? "" : "height"
     ].filter(Boolean).join(" and ");
     this.params.issues.push({
       ...representative,
-      paddingDetails: details.map(({
+      paddingDetails: applicableDetails.map(({
         pinSide,
         edgeSide,
         pinName,
@@ -353010,8 +353765,8 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
         maxAllowedPadding,
         excessPadding
       })),
-      suggestedSchWidth: widths.length ? Math.max(...widths) : undefined,
-      suggestedSchHeight: heights.length ? Math.max(...heights) : undefined,
+      suggestedSchWidth: resize.width,
+      suggestedSchHeight: resize.height,
       message: `${this.MESSAGE} ${dimensions}`
     });
   }
@@ -353054,14 +353809,6 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
   isSchematicSide(side) {
     return this.isHorizontalSide(side) || this.isVerticalSide(side);
   }
-  isPinNameLabel(label, sourcePort) {
-    if (!sourcePort)
-      return false;
-    return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
-  }
-  estimateLabelWidth(label, sourcePort) {
-    return Array.from(label).length * (this.isPinNameLabel(label, sourcePort) ? this.PIN_NAME_CHARACTER_WIDTH : this.FALLBACK_CHARACTER_WIDTH);
-  }
   exceedsMaxAllowedGap(measured, maxAllowed) {
     return measured - maxAllowed > this.GAP_COMPARISON_EPSILON;
   }
@@ -353087,8 +353834,6 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
     for (const port of circuitJson.filter((el) => this.isSchematicPort(el))) {
       if (!port.schematic_component_id)
         continue;
-      if (!this.isSchematicSide(port.side_of_component))
-        continue;
       const ports = map.get(port.schematic_component_id);
       if (ports)
         ports.push(port);
@@ -353113,7 +353858,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
       return String(sp.pin_number);
     return;
   }
-  getMaxLabelLengthBySide(ports, sourcePortById) {
+  getMaxLabelLengthBySide(ports) {
     const result = {
       left: 0,
       right: 0,
@@ -353125,7 +353870,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
         continue;
       if (!port.display_pin_label)
         continue;
-      result[port.side_of_component] = Math.max(result[port.side_of_component], this.estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id)));
+      result[port.side_of_component] = Math.max(result[port.side_of_component], getPinLabelLength(port));
     }
     return result;
   }
@@ -353159,9 +353904,6 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
   getBoxEdgeSidesForPinSide(pinSide) {
     return this.isHorizontalSide(pinSide) ? ["top", "bottom"] : ["left", "right"];
   }
-  hasPinsOnAllSides(portsBySide) {
-    return portsBySide.has("left") && portsBySide.has("right") && portsBySide.has("top") && portsBySide.has("bottom");
-  }
   getMaxAllowedPinPadding(spacing, edgeSide, maxLabelLengthBySide) {
     const sides = this.isHorizontalSide(edgeSide) ? ["left", "right"] : ["top", "bottom"];
     return (maxLabelLengthBySide[sides[0]] + maxLabelLengthBySide[sides[1]] + spacing) / 2;
@@ -353266,8 +354008,8 @@ var schematicBoxToPlacement = (schematicBox, circuitJson, schematicSheetNameById
   const placement = {
     lineItemType: "SchematicBoxPlacement",
     positionAnchor: "center",
-    schX: schematicBox.x,
-    schY: schematicBox.y,
+    schX: schematicBox.x + schematicBox.width / 2,
+    schY: schematicBox.y + schematicBox.height / 2,
     width: schematicBox.width,
     height: schematicBox.height,
     ...getSourceComponentMetadata(schematicBox, circuitJson),
@@ -353284,7 +354026,7 @@ var schematicBoxToPlacement = (schematicBox, circuitJson, schematicSheetNameById
   return placement;
 };
 var buildSolverContext = (circuitJson) => {
-  const schematicBoxes = circuitJson.filter(isSchematicBox);
+  const schematicBoxes = circuitJson.filter(isSchematicBox).filter((box) => box.schematic_component_id || box.schematic_symbol_id);
   const schematicSheetNameById = getSchematicSheetNamesById(circuitJson);
   const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent).map((sc) => sc.schematic_component_id));
   const componentPlacements = [
@@ -353295,8 +354037,8 @@ var buildSolverContext = (circuitJson) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SwitchPullResistorPlacementSolver/SwitchPullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver26 } from "@tscircuit/solver-utils";
-class SwitchPullResistorPlacementSolver extends BaseSolver26 {
+import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
+class SwitchPullResistorPlacementSolver extends BaseSolver30 {
   params;
   constructor(params2) {
     super();
@@ -353365,130 +354107,8 @@ function getTraceName(circuitJson, trace) {
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
 import { calculateElbow as calculateElbow3 } from "calculate-elbow/lib";
-
-// 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/TraceSimplificationSolver/TraceSimplificationSolver.ts
-import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
-class TraceSimplificationSolver extends BaseSolver27 {
+import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver31 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -353804,7 +354424,7 @@ class TraceSimplificationSolver extends BaseSolver27 {
     });
   }
   makeIssue(trace, candidate) {
-    const targetName = candidate.target.sourceComponentName ?? candidate.target.schematicComponentId ?? "component";
+    const targetName = candidate.target.sourceComponentName || "component";
     const direction = this.getMoveDirection(candidate.deltaSchX, candidate.deltaSchY);
     const distance = Math.abs(candidate.deltaSchX || candidate.deltaSchY);
     const newSchX = candidate.target.schX + candidate.deltaSchX;
@@ -353846,7 +354466,7 @@ class TraceSimplificationSolver extends BaseSolver27 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver32 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/getPowerOrGroundConnectionIds.ts
 import {
@@ -353885,7 +354505,7 @@ function getPowerOrGroundConnectionIds(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-class TwoPinComponentOrientationSolver extends BaseSolver28 {
+class TwoPinComponentOrientationSolver extends BaseSolver32 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -354096,8 +354716,8 @@ class TwoPinComponentOrientationSolver extends BaseSolver28 {
     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 targetName = candidate.targetPlacement.sourceComponentName || "component";
+    const connectedName = candidate.connectedPlacement.sourceComponentName || "component";
     const targetPin = candidate.targetPort.pin_number ? `pin${candidate.targetPort.pin_number}` : candidate.targetPort.display_pin_label;
     return {
       lineItemType: "TwoPinComponentCouldBeFlipped",
@@ -354131,8 +354751,8 @@ class TwoPinComponentOrientationSolver extends BaseSolver28 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver29 {
+import { BaseSolver as BaseSolver33 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver33 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -354241,8 +354861,8 @@ class VerboseNetLabelSolver extends BaseSolver29 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
-import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
-class SchematicTextClearanceSolver extends BaseSolver30 {
+import { BaseSolver as BaseSolver34 } from "@tscircuit/solver-utils";
+class SchematicTextClearanceSolver extends BaseSolver34 {
   params;
   texts;
   obstacles;
@@ -354258,7 +354878,7 @@ class SchematicTextClearanceSolver extends BaseSolver30 {
     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)
+      if (element.schematic_component_id || element.schematic_symbol_id)
         return [];
       const polygons = getSchematicTextPolygons(element);
       if (!polygons.length)
@@ -354280,6 +354900,7 @@ class SchematicTextClearanceSolver extends BaseSolver30 {
       return [
         {
           text: element,
+          isTraceLabel: Boolean("source_trace_id" in element && element.source_trace_id),
           polygons,
           sheetId,
           object: {
@@ -354327,8 +354948,9 @@ class SchematicTextClearanceSolver extends BaseSolver30 {
     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);
+      const suggestedMove = text.isTraceLabel ? undefined : this.findClearPosition(text);
       for (const target of collisions) {
+        const targetName = target.object.componentName ?? target.object.text;
         this.params.issues.push({
           lineItemType: "SchematicTextCollision",
           schematicSheetId: text.sheetId,
@@ -354339,7 +354961,7 @@ class SchematicTextClearanceSolver extends BaseSolver30 {
           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.`
+          message: `Text "${text.text.text}" overlaps ${target.object.type}${targetName ? ` ${targetName}` : ""}; ${text.isTraceLabel ? "adjust the owning trace's label placement or remove stale duplicates to leave the visible text area clear." : "reposition the text to leave its visible area clear."}`
         });
       }
     }
@@ -354381,10 +355003,9 @@ class SchematicTextClearanceSolver extends BaseSolver30 {
   }
   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, "collidingText", issue.collidingObject.text);
     addAttr(attrs, "newSchX", issue.suggestedMove?.newSchX);
     addAttr(attrs, "newSchY", issue.suggestedMove?.newSchY);
     addAttr(attrs, "message", issue.message);
@@ -354393,8 +355014,8 @@ class SchematicTextClearanceSolver extends BaseSolver30 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ResetNetworkGroupingSolver/ResetNetworkGroupingSolver.ts
-import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
-class ResetNetworkGroupingSolver extends BaseSolver31 {
+import { BaseSolver as BaseSolver35 } from "@tscircuit/solver-utils";
+class ResetNetworkGroupingSolver extends BaseSolver35 {
   params;
   static MIN_DISTANCE = 6;
   networks;
@@ -354411,9 +355032,9 @@ class ResetNetworkGroupingSolver extends BaseSolver31 {
     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 hostName = network.host.sourceComponentName || "component";
       const resetPin = resetPinName(network.pin);
-      const memberNames = rcMembers.map((p) => p.sourceComponentName ?? p.schematicComponentId).join(", ");
+      const memberNames = rcMembers.map((p) => p.sourceComponentName || "component").join(", ");
       this.params.issues.push({
         lineItemType: "ResetNetworkNotGrouped",
         hostSchematicBox: network.host,
@@ -354538,7 +355159,7 @@ class ResetNetworkGroupingSolver extends BaseSolver31 {
     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, "supportNetworkComponents", issue.supportNetworkComponents.map((p) => p.sourceComponentName || "component").join(","));
     addAttr(attrs, "maxDistanceFromResetPin", issue.maxDistanceFromResetPin);
     addAttr(attrs, "maxRecommendedDistance", issue.maxRecommendedDistance);
     addAttr(attrs, "message", issue.message);
@@ -354549,6 +355170,9 @@ var resetPinName = (port) => [port.name, ...port.port_hints ?? []].find((name) =
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
 var solversByIssueType = {
+  RailPathTooSpreadOut: [RailPathVisibilitySolver],
+  CapacitorSeparatedFromChipPins: [ChipPinPairCapacitorPlacementSolver],
+  PiFilterComponentsNotGrouped: [PiFilterPlacementSolver],
   MosfetGateNetworkNotGrouped: [MosfetGateNetworkPlacementSolver],
   FlybackDiodeSeparatedFromRelayCoil: [RelayFlybackDiodePlacementSolver],
   ComponentOverlap: [SchematicBoxOverlapSolver],
@@ -354563,6 +355187,7 @@ var solversByIssueType = {
   SchematicBoxInnerLabelCollision: [SchematicBoxInnerLabelCollisionSolver],
   SchematicPinPaddingToEdgeTooLarge: [SchematicPinPaddingToEdgeSolver],
   DiodeResistorNotAligned: [DiodeResistorAlignmentSolver],
+  ParallelDiodeResistorNotAligned: [ParallelDiodeResistorPlacementSolver],
   ComponentPinsWouldAlignWithVerticalShift: [ComponentPinAlignmentSolver],
   TraceCanBeSimplifiedByMovingComponent: [TraceSimplificationSolver],
   CrystalNotCenteredOverLoadCapacitors: [CrystalLoadCapacitorPlacementSolver],
@@ -354596,6 +355221,9 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
   ctx;
   issues = [];
   pipelineDef = [
+    definePipelineStep3("ParallelDiodeResistorPlacementSolver", ParallelDiodeResistorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("SchematicTextClearanceSolver", SchematicTextClearanceSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
@@ -354674,13 +355302,29 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     definePipelineStep3("RelayFlybackDiodePlacementSolver", RelayFlybackDiodePlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
+    definePipelineStep3("PiFilterPlacementSolver", PiFilterPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("MosfetGateNetworkPlacementSolver", MosfetGateNetworkPlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("ChipPinPairCapacitorPlacementSolver", ChipPinPairCapacitorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("RailPathVisibilitySolver", RailPathVisibilitySolver, (p) => [
+      {
+        ctx: p.ctx,
+        issues: p.issues,
+        maxSpan: p.railPathVisibility?.maxSpan,
+        maxLength: p.railPathVisibility?.maxPathLength
+      }
     ])
   ];
   selectedIssueTypes;
+  railPathVisibility;
   constructor(circuitJson, options = {}) {
     super(circuitJson);
+    this.railPathVisibility = options.railPathVisibility;
     if (options.issueTypes !== undefined) {
       this.selectedIssueTypes = new Set(options.issueTypes);
       const selectedSolvers = new Set(options.issueTypes.flatMap((type) => solversByIssueType[type]));
@@ -354736,6 +355380,15 @@ var getRelevantPlacementsForIssues = ({
   };
   for (const issue of issues) {
     switch (issue.lineItemType) {
+      case "CapacitorSeparatedFromChipPins":
+        addPlacement(issue.hostSchematicBox);
+        addPlacement(issue.capacitorSchematicBox);
+        break;
+      case "PiFilterComponentsNotGrouped":
+        addPlacement(issue.inductorSchematicBox);
+        addPlacement(issue.firstCapacitorSchematicBox);
+        addPlacement(issue.secondCapacitorSchematicBox);
+        break;
       case "MosfetGateNetworkNotGrouped":
         addPlacement(issue.mosfetSchematicBox);
         addPlacement(issue.seriesGateResistorSchematicBox);
@@ -354811,6 +355464,7 @@ var getRelevantPlacementsForIssues = ({
           addComponentName(getComponentNameFromPin(pin), issue.schematicSheetId);
         }
         break;
+      case "ParallelDiodeResistorNotAligned":
       case "DiodeResistorNotAligned":
         addPlacement(issue.diodeSchematicBox);
         addPlacement(issue.resistorSchematicBox);
@@ -354848,6 +355502,11 @@ var getRelevantPlacementsForIssues = ({
       case "TwoPinComponentHasInvertedRails":
         addPlacement(issue.schematicBox);
         break;
+      case "RailPathTooSpreadOut":
+        addPlacement(issue.hostSchematicBox);
+        for (const placement of issue.supportSchematicBoxes)
+          addPlacement(placement);
+        break;
       case "PullResistorOnWrongSide":
         addPlacement(issue.resistorSchematicBox);
         addPlacement(issue.hostSchematicBox);
@@ -354945,6 +355604,7 @@ class SchematicPlacementAnalysis {
       SchematicBoxInnerLabelCollision: 0,
       SchematicPinPaddingToEdgeTooLarge: 0,
       DiodeResistorNotAligned: 0,
+      ParallelDiodeResistorNotAligned: 0,
       ComponentPinsWouldAlignWithVerticalShift: 0,
       TraceCanBeSimplifiedByMovingComponent: 0,
       CrystalNotCenteredOverLoadCapacitors: 0,
@@ -354965,7 +355625,10 @@ class SchematicPlacementAnalysis {
       RegulatorCapacitorsOnWrongSides: 0,
       VoltageDividerSupplyResistorBelowGroundResistor: 0,
       CurrentSenseShuntSeparatedFromInputs: 0,
-      MosfetGateNetworkNotGrouped: 0
+      PiFilterComponentsNotGrouped: 0,
+      MosfetGateNetworkNotGrouped: 0,
+      CapacitorSeparatedFromChipPins: 0,
+      RailPathTooSpreadOut: 0
     };
     for (const issue of this.getIssues(filter))
       counts[issue.lineItemType]++;
@@ -354986,6 +355649,10 @@ class SchematicPlacementAnalysis {
   }
   schematicIssuesToString(issue) {
     switch (issue.lineItemType) {
+      case "CapacitorSeparatedFromChipPins":
+        return ChipPinPairCapacitorPlacementSolver.issueToString(issue);
+      case "PiFilterComponentsNotGrouped":
+        return PiFilterPlacementSolver.issueToString(issue);
       case "MosfetGateNetworkNotGrouped":
         return MosfetGateNetworkPlacementSolver.issueToString(issue);
       case "CurrentSenseShuntSeparatedFromInputs":
@@ -355005,6 +355672,8 @@ class SchematicPlacementAnalysis {
         return SchematicBoxInnerLabelCollisionSolver.issueToString(issue);
       case "SchematicPinPaddingToEdgeTooLarge":
         return SchematicPinPaddingToEdgeSolver.issueToString(issue);
+      case "ParallelDiodeResistorNotAligned":
+        return ParallelDiodeResistorPlacementSolver.issueToString(issue);
       case "DiodeResistorNotAligned":
         return DiodeResistorAlignmentSolver.issueToString(issue);
       case "ComponentPinsWouldAlignWithVerticalShift":
@@ -355020,6 +355689,8 @@ class SchematicPlacementAnalysis {
       case "TwoPinComponentShouldBeVertical":
       case "TwoPinComponentHasInvertedRails":
         return TwoPinComponentRailOrientationSolver.issueToString(issue);
+      case "RailPathTooSpreadOut":
+        return RailPathVisibilitySolver.issueToString(issue);
       case "PullResistorOnWrongSide":
         return PullResistorPlacementSolver.issueToString(issue);
       case "NetLabelCollision":
@@ -374640,7 +375311,7 @@ __export5(dist_exports, {
   circle_shape: () => circle_shape,
   circuit_json_footprint_load_error: () => circuit_json_footprint_load_error2,
   current: () => current2,
-  distance: () => distance51,
+  distance: () => distance54,
   duration_ms: () => duration_ms,
   experiment_type: () => experiment_type,
   external_footprint_load_error: () => external_footprint_load_error2,
@@ -379129,7 +379800,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 distance51 = length67;
+var distance54 = 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;
@@ -379170,16 +379841,16 @@ expectStringUnionsMatch('T2 has extra: "c"');
 expectStringUnionsMatch('T1 has extra: "d", T2 has extra: "c"');
 expectStringUnionsMatch(true);
 var point9 = external_exports2.object({
-  x: distance51,
-  y: distance51
+  x: distance54,
+  y: distance54
 });
 var position = point9;
 expectTypesMatch2(true);
 expectTypesMatch2(true);
 var point33 = external_exports2.object({
-  x: distance51,
-  y: distance51,
-  z: distance51
+  x: distance54,
+  y: distance54,
+  z: distance54
 });
 var position3 = point33;
 expectTypesMatch2(true);
@@ -379188,8 +379859,8 @@ var size = external_exports2.object({
   height: external_exports2.number()
 });
 expectTypesMatch2(true);
-var finite_distance = distance51.pipe(external_exports2.number().finite());
-var positive_distance = distance51.pipe(external_exports2.number().finite().positive());
+var finite_distance = distance54.pipe(external_exports2.number().finite());
+var positive_distance = distance54.pipe(external_exports2.number().finite().positive());
 var circle_shape = external_exports2.object({
   shape: external_exports2.literal("circle"),
   x: finite_distance,
@@ -379284,7 +379955,7 @@ var kicadAt2 = point9.extend({
 expectTypesMatch2(true);
 var kicadFont2 = external_exports2.object({
   size: point9.optional(),
-  thickness: distance51.optional()
+  thickness: distance54.optional()
 });
 expectTypesMatch2(true);
 var kicadEffects2 = external_exports2.object({
@@ -379320,7 +379991,7 @@ var kicadFootprintPad2 = external_exports2.object({
   shape: external_exports2.string().optional(),
   at: kicadAt2.optional(),
   size: point9.optional(),
-  drill: distance51.optional(),
+  drill: distance54.optional(),
   layers: external_exports2.array(external_exports2.string()).optional(),
   removeUnusedLayers: external_exports2.boolean().optional(),
   uuid: external_exports2.string().optional()
@@ -379351,7 +380022,7 @@ var kicadSymbolPinNumbers2 = external_exports2.object({
 });
 expectTypesMatch2(true);
 var kicadSymbolPinNames2 = external_exports2.object({
-  offset: distance51.optional(),
+  offset: distance54.optional(),
   hide: external_exports2.boolean().optional()
 });
 expectTypesMatch2(true);
@@ -379425,7 +380096,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: distance51.optional()
+  max_decoupling_trace_length: distance54.optional()
 });
 expectTypesMatch2(true);
 var source_simple_resistor = source_component_base.extend({
@@ -380021,11 +380692,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: distance51,
-  height: distance51,
+  width: distance54,
+  height: distance54,
   is_dashed: external_exports2.boolean().default(false),
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   subcircuit_id: external_exports2.string().optional()
 }).describe("Draws a box on the schematic");
 expectTypesMatch2(true);
@@ -380038,10 +380709,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: distance51.nullable().optional(),
+  stroke_width: distance54.nullable().optional(),
   stroke_color: external_exports2.string().optional(),
-  dash_length: distance51.optional(),
-  dash_gap: distance51.optional(),
+  dash_length: distance54.optional(),
+  dash_gap: distance54.optional(),
   points: external_exports2.array(point9),
   subcircuit_id: external_exports2.string().optional()
 });
@@ -380120,15 +380791,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: distance51,
-  y1: distance51,
-  x2: distance51,
-  y2: distance51,
-  stroke_width: distance51.nullable().optional(),
+  x1: distance54,
+  y1: distance54,
+  x2: distance54,
+  y2: distance54,
+  stroke_width: distance54.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_dashed: external_exports2.boolean().default(false),
-  dash_length: distance51.optional(),
-  dash_gap: distance51.optional(),
+  dash_length: distance54.optional(),
+  dash_gap: distance54.optional(),
   subcircuit_id: external_exports2.string().optional()
 }).describe("Draws a styled line on the schematic");
 expectTypesMatch2(true);
@@ -380139,10 +380810,10 @@ var schematic_rect = external_exports2.object({
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
   center: point9,
-  width: distance51,
-  height: distance51,
+  width: distance54,
+  height: distance54,
   rotation: rotation11.default(0),
-  stroke_width: distance51.nullable().optional(),
+  stroke_width: distance54.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_filled: external_exports2.boolean().default(false),
   fill_color: external_exports2.string().optional(),
@@ -380157,8 +380828,8 @@ var schematic_circle = external_exports2.object({
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
   center: point9,
-  radius: distance51,
-  stroke_width: distance51.nullable().optional(),
+  radius: distance54,
+  stroke_width: distance54.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_filled: external_exports2.boolean().default(false),
   fill_color: external_exports2.string().optional(),
@@ -380173,11 +380844,11 @@ var schematic_arc = external_exports2.object({
   schematic_component_id: external_exports2.string().optional(),
   schematic_symbol_id: external_exports2.string().optional(),
   center: point9,
-  radius: distance51,
+  radius: distance54,
   start_angle_degrees: rotation11,
   end_angle_degrees: rotation11,
   direction: external_exports2.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
-  stroke_width: distance51.nullable().optional(),
+  stroke_width: distance54.nullable().optional(),
   color: external_exports2.string().default("#000000"),
   is_dashed: external_exports2.boolean().default(false),
   subcircuit_id: external_exports2.string().optional()
@@ -380233,8 +380904,8 @@ var schematic_text = external_exports2.object({
   display_superscript: external_exports2.string().optional(),
   font_size: external_exports2.number().default(0.18),
   position: external_exports2.object({
-    x: distance51,
-    y: distance51
+    x: distance54,
+    y: distance54
   }),
   rotation: external_exports2.number().default(0),
   anchor: external_exports2.union([fivePointAnchor2.describe("legacy"), ninePointAnchor2]).default("center"),
@@ -380385,7 +381056,7 @@ var schematic_element_outside_sheet_warning = external_exports2.object({
   schematic_element_id: external_exports2.string()
 }).describe("Warning emitted when a schematic component, net label, or trace extends outside its schematic sheet");
 expectTypesMatch2(true);
-var positiveFiniteDistance = distance51.pipe(external_exports2.number().positive().finite());
+var positiveFiniteDistance = distance54.pipe(external_exports2.number().positive().finite());
 var schematic_graphic = external_exports2.object({
   type: external_exports2.literal("schematic_graphic"),
   schematic_graphic_id: getZodPrefixedIdWithDefault("schematic_graphic"),
@@ -380424,10 +381095,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(distance51),
-  row_heights: external_exports2.array(distance51),
-  cell_padding: distance51.optional(),
-  border_width: distance51.optional(),
+  column_widths: external_exports2.array(distance54),
+  row_heights: external_exports2.array(distance54),
+  cell_padding: distance54.optional(),
+  border_width: distance54.optional(),
   subcircuit_id: external_exports2.string().optional(),
   schematic_component_id: external_exports2.string().optional(),
   anchor: ninePointAnchor2.optional()
@@ -380444,11 +381115,11 @@ var schematic_table_cell = external_exports2.object({
   end_column_index: external_exports2.number(),
   text: external_exports2.string().optional(),
   center: point9,
-  width: distance51,
-  height: distance51,
+  width: distance54,
+  height: distance54,
   horizontal_align: external_exports2.enum(["left", "center", "right"]).optional(),
   vertical_align: external_exports2.enum(["top", "middle", "bottom"]).optional(),
-  font_size: distance51.optional(),
+  font_size: distance54.optional(),
   subcircuit_id: external_exports2.string().optional()
 }).describe("Defines a cell within a schematic_table");
 expectTypesMatch2(true);
@@ -380473,8 +381144,8 @@ var schematic_missing_sheet_warning = external_exports2.object({
 }).describe("Circuit-wide warning emitted when a schematic has no schematic sheet. Display as a banner without attaching it to a component or drawing a target outline or leader line.");
 expectTypesMatch2(true);
 var point_with_bulge = external_exports2.object({
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   bulge: external_exports2.number().optional()
 });
 expectTypesMatch2(true);
@@ -380565,8 +381236,8 @@ var getRotationBetweenPcbPin1Locations3 = (from, to) => {
   return null;
 };
 var pcb_route_hint = external_exports2.object({
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   via: external_exports2.boolean().optional(),
   via_to_layer: layer_ref2.optional()
 });
@@ -380574,11 +381245,11 @@ var pcb_route_hints = external_exports2.array(pcb_route_hint);
 expectTypesMatch2(true);
 expectTypesMatch2(true);
 var route_hint_point8 = external_exports2.object({
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   via: external_exports2.boolean().optional(),
   to_layer: layer_ref2.optional(),
-  trace_width: distance51.optional()
+  trace_width: distance54.optional()
 });
 expectTypesMatch2(true);
 var manufacturing_drc_properties = external_exports2.object({
@@ -380664,8 +381335,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -380680,8 +381351,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -380695,8 +381366,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -380711,8 +381382,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -380727,8 +381398,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
 });
@@ -380743,8 +381414,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   ccw_rotation: rotation11,
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
   soldermask_margin: external_exports2.number().optional()
@@ -380760,8 +381431,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -380779,8 +381450,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   ccw_rotation: rotation11,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
@@ -380800,11 +381471,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: distance51.default(0),
-  hole_offset_y: distance51.default(0),
+  hole_offset_x: distance54.default(0),
+  hole_offset_y: distance54.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -380825,11 +381496,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: distance51.default(0),
-  hole_offset_y: distance51.default(0),
+  hole_offset_x: distance54.default(0),
+  hole_offset_y: distance54.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -380851,11 +381522,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: distance51.default(0),
-  hole_offset_y: distance51.default(0),
+  hole_offset_x: distance54.default(0),
+  hole_offset_y: distance54.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -380873,14 +381544,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: distance51,
-    y: distance51
+    x: distance54,
+    y: distance54
   })).min(3),
-  hole_offset_x: distance51.default(0),
-  hole_offset_y: distance51.default(0),
+  hole_offset_x: distance54.default(0),
+  hole_offset_y: distance54.default(0),
   is_covered_with_solder_mask: external_exports2.boolean().optional(),
-  x: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   layers: external_exports2.array(layer_ref2),
   port_hints: external_exports2.array(external_exports2.string()).optional(),
   pcb_component_id: external_exports2.string().optional(),
@@ -380910,8 +381581,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   layers: external_exports2.array(layer_ref2),
   is_board_pinout: external_exports2.boolean().optional()
 }).describe("Defines a port on the PCB");
@@ -380922,8 +381593,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   radius: external_exports2.number(),
   layer: layer_ref2,
   port_hints: external_exports2.array(external_exports2.string()).optional(),
@@ -380939,8 +381610,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
@@ -380963,8 +381634,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   rect_border_radius: external_exports2.number().optional(),
@@ -380988,8 +381659,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -381007,8 +381678,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -381056,8 +381727,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   radius: external_exports2.number(),
   layer: layer_ref2,
   pcb_component_id: external_exports2.string().optional(),
@@ -381069,8 +381740,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   layer: layer_ref2,
@@ -381083,8 +381754,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -381098,11 +381769,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
-  ccw_rotation: distance51,
+  ccw_rotation: distance54,
   layer: layer_ref2,
   pcb_component_id: external_exports2.string().optional(),
   pcb_smtpad_id: external_exports2.string().optional()
@@ -381113,8 +381784,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   radius: external_exports2.number(),
@@ -381129,8 +381800,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   width: external_exports2.number(),
   height: external_exports2.number(),
   layer: layer_ref2,
@@ -381180,12 +381851,12 @@ var pcb_text = external_exports2.object({
   align: external_exports2.enum(["bottom-left"])
 }).describe("Defines text on the PCB");
 expectTypesMatch2(true);
-var positive_width = distance51.pipe(external_exports2.number().finite().positive());
+var positive_width = distance54.pipe(external_exports2.number().finite().positive());
 var pcb_trace_route_point_wire = external_exports2.object({
   route_type: external_exports2.literal("wire"),
-  x: distance51,
-  y: distance51,
-  width: distance51,
+  x: distance54,
+  y: distance54,
+  width: distance54,
   start_width: positive_width.optional(),
   end_width: positive_width.optional(),
   width_interpolation_mode: external_exports2.enum(["linear", "quadratic"]).optional(),
@@ -381224,12 +381895,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: distance51,
-  y: distance51,
+  x: distance54,
+  y: distance54,
   copper_pour_id: external_exports2.string().optional(),
   is_inside_copper_pour: external_exports2.boolean().optional(),
-  hole_diameter: distance51.optional(),
-  outer_diameter: distance51.optional(),
+  hole_diameter: distance54.optional(),
+  outer_diameter: distance54.optional(),
   tented_on_top: external_exports2.boolean().optional(),
   tented_on_bottom: external_exports2.boolean().optional(),
   from_layer: layer_ref2,
@@ -381239,7 +381910,7 @@ var pcb_trace_route_point_through_pad = external_exports2.object({
   route_type: external_exports2.literal("through_pad"),
   start: point9,
   end: point9,
-  width: distance51,
+  width: distance54,
   start_layer: layer_ref2,
   end_layer: layer_ref2,
   pcb_smtpad_id: external_exports2.string().optional(),
@@ -381304,8 +381975,8 @@ var pcb_trace_too_long_error = 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: distance51,
-  maximum_trace_length: distance51,
+  actual_trace_length: distance54,
+  maximum_trace_length: distance54,
   subcircuit_id: external_exports2.string().optional()
 }).describe("Error emitted when a PCB trace is longer than its maximum allowed length");
 expectTypesMatch2(true);
@@ -381329,8 +382000,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: distance51,
-  maximum_trace_length: distance51,
+  actual_trace_length: distance54,
+  maximum_trace_length: distance54,
   subcircuit_id: external_exports2.string().optional()
 }).describe("Warning emitted when a PCB trace is longer than its maximum allowed length");
 expectTypesMatch2(true);
@@ -381400,10 +382071,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: distance51,
-  y: distance51,
-  outer_diameter: distance51.default("0.6mm"),
-  hole_diameter: distance51.default("0.25mm"),
+  x: distance54,
+  y: distance54,
+  outer_diameter: distance54.default("0.6mm"),
+  hole_diameter: distance54.default("0.25mm"),
   topmost_drill_layer: layer_ref2.optional(),
   bottommost_drill_layer: layer_ref2.optional(),
   through_hole: external_exports2.boolean().optional(),
@@ -381570,11 +382241,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: distance51.default("0.1mm"),
-  x1: distance51,
-  y1: distance51,
-  x2: distance51,
-  y2: distance51,
+  stroke_width: distance54.default("0.1mm"),
+  x1: distance54,
+  y1: distance54,
+  x2: distance54,
+  y2: distance54,
   layer: visible_layer
 }).describe("Defines a silkscreen line on the PCB");
 expectTypesMatch2(true);
@@ -381595,7 +382266,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: distance51.default("0.2mm"),
+  font_size: distance54.default("0.2mm"),
   pcb_component_id: external_exports2.string(),
   text: external_exports2.string(),
   is_knockout: external_exports2.boolean().default(false).optional(),
@@ -381623,7 +382294,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: distance51.default("0.2mm"),
+  font_size: distance54.default("0.2mm"),
   pcb_component_id: external_exports2.string(),
   text: external_exports2.string(),
   is_knockout: external_exports2.boolean().default(false).optional(),
@@ -381683,8 +382354,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: distance51,
-  radius_y: distance51,
+  radius_x: distance54,
+  radius_y: distance54,
   layer: visible_layer,
   ccw_rotation: rotation11.optional()
 }).describe("Defines a silkscreen oval on the PCB");
@@ -381724,7 +382395,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: distance51.default("1mm"),
+  font_size: distance54.default("1mm"),
   pcb_component_id: external_exports2.string(),
   text: external_exports2.string(),
   ccw_rotation: external_exports2.number().optional(),
@@ -381794,7 +382465,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: distance51.default("1mm"),
+  font_size: distance54.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"),
@@ -381845,12 +382516,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: distance51,
-  y1: distance51,
-  x2: distance51,
-  y2: distance51,
+  x1: distance54,
+  y1: distance54,
+  x2: distance54,
+  y2: distance54,
   layer: visible_layer.default("top"),
-  stroke_width: distance51.default("0.1mm"),
+  stroke_width: distance54.default("0.1mm"),
   color: external_exports2.string().optional(),
   is_dashed: external_exports2.boolean().optional()
 }).describe("Defines a straight documentation note line on the PCB");
@@ -381916,8 +382587,8 @@ var pcb_keepout2 = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   center: point9,
-  width: distance51,
-  height: distance51,
+  width: distance54,
+  height: distance54,
   pcb_keepout_id: external_exports2.string(),
   layers: external_exports2.array(external_exports2.string()),
   description: external_exports2.string().optional(),
@@ -381931,7 +382602,7 @@ var pcb_keepout2 = external_exports2.object({
   pcb_group_id: external_exports2.string().optional(),
   subcircuit_id: external_exports2.string().optional(),
   center: point9,
-  radius: distance51,
+  radius: distance54,
   pcb_keepout_id: external_exports2.string(),
   layers: external_exports2.array(external_exports2.string()),
   description: external_exports2.string().optional(),
@@ -382154,8 +382825,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: distance51,
-  y: distance51
+  x: distance54,
+  y: distance54
 }).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({
@@ -382183,9 +382854,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: distance51,
-  spoke_inner_diameter: distance51,
-  spoke_outer_diameter: distance51,
+  spoke_thickness: distance54,
+  spoke_inner_diameter: distance54,
+  spoke_outer_diameter: distance54,
   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");
@@ -382267,8 +382938,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: distance51.optional(),
-  actual_clearance: distance51.optional(),
+  minimum_clearance: distance54.optional(),
+  actual_clearance: distance54.optional(),
   pcb_center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -382282,8 +382953,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: distance51.optional(),
-  actual_clearance: distance51.optional(),
+  minimum_clearance: distance54.optional(),
+  actual_clearance: distance54.optional(),
   center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -382296,8 +382967,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: distance51.optional(),
-  actual_clearance: distance51.optional(),
+  minimum_clearance: distance54.optional(),
+  actual_clearance: distance54.optional(),
   center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -382311,8 +382982,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: distance51.optional(),
-  actual_clearance: distance51.optional(),
+  minimum_clearance: distance54.optional(),
+  actual_clearance: distance54.optional(),
   center: external_exports2.object({
     x: external_exports2.number().optional(),
     y: external_exports2.number().optional()
@@ -394126,7 +394797,7 @@ __export6(dist_exports2, {
   circle_shape: () => circle_shape2,
   circuit_json_footprint_load_error: () => circuit_json_footprint_load_error3,
   current: () => current3,
-  distance: () => distance54,
+  distance: () => distance55,
   duration_ms: () => duration_ms2,
   experiment_type: () => experiment_type2,
   external_footprint_load_error: () => external_footprint_load_error3,
@@ -394693,7 +395364,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 distance54 = length68;
+var distance55 = 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;
@@ -394734,16 +395405,16 @@ expectStringUnionsMatch2('T2 has extra: "c"');
 expectStringUnionsMatch2('T1 has extra: "d", T2 has extra: "c"');
 expectStringUnionsMatch2(true);
 var point10 = z211.object({
-  x: distance54,
-  y: distance54
+  x: distance55,
+  y: distance55
 });
 var position2 = point10;
 expectTypesMatch3(true);
 expectTypesMatch3(true);
 var point34 = z311.object({
-  x: distance54,
-  y: distance54,
-  z: distance54
+  x: distance55,
+  y: distance55,
+  z: distance55
 });
 var position32 = point34;
 expectTypesMatch3(true);
@@ -394752,8 +395423,8 @@ var size2 = z411.object({
   height: z411.number()
 });
 expectTypesMatch3(true);
-var finite_distance2 = distance54.pipe(z57.number().finite());
-var positive_distance2 = distance54.pipe(z57.number().finite().positive());
+var finite_distance2 = distance55.pipe(z57.number().finite());
+var positive_distance2 = distance55.pipe(z57.number().finite().positive());
 var circle_shape2 = z57.object({
   shape: z57.literal("circle"),
   x: finite_distance2,
@@ -394848,7 +395519,7 @@ var kicadAt3 = point10.extend({
 expectTypesMatch3(true);
 var kicadFont3 = z103.object({
   size: point10.optional(),
-  thickness: distance54.optional()
+  thickness: distance55.optional()
 });
 expectTypesMatch3(true);
 var kicadEffects3 = z103.object({
@@ -394884,7 +395555,7 @@ var kicadFootprintPad3 = z103.object({
   shape: z103.string().optional(),
   at: kicadAt3.optional(),
   size: point10.optional(),
-  drill: distance54.optional(),
+  drill: distance55.optional(),
   layers: z103.array(z103.string()).optional(),
   removeUnusedLayers: z103.boolean().optional(),
   uuid: z103.string().optional()
@@ -394915,7 +395586,7 @@ var kicadSymbolPinNumbers3 = z113.object({
 });
 expectTypesMatch3(true);
 var kicadSymbolPinNames3 = z113.object({
-  offset: distance54.optional(),
+  offset: distance55.optional(),
   hide: z113.boolean().optional()
 });
 expectTypesMatch3(true);
@@ -394989,7 +395660,7 @@ var source_simple_capacitor2 = source_component_base2.extend({
   capacitance: capacitance5,
   max_voltage_rating: voltage6.optional(),
   display_capacitance: z153.string().optional(),
-  max_decoupling_trace_length: distance54.optional()
+  max_decoupling_trace_length: distance55.optional()
 });
 expectTypesMatch3(true);
 var source_simple_resistor2 = source_component_base2.extend({
@@ -395585,11 +396256,11 @@ var schematic_box2 = z76.object({
   schematic_sheet_id: z76.string().optional(),
   schematic_component_id: z76.string().optional(),
   schematic_symbol_id: z76.string().optional(),
-  width: distance54,
-  height: distance54,
+  width: distance55,
+  height: distance55,
   is_dashed: z76.boolean().default(false),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   subcircuit_id: z76.string().optional()
 }).describe("Draws a box on the schematic");
 expectTypesMatch3(true);
@@ -395602,10 +396273,10 @@ var schematic_path2 = z77.object({
   fill_color: z77.string().optional(),
   is_filled: z77.boolean().optional(),
   is_dashed: z77.boolean().default(false),
-  stroke_width: distance54.nullable().optional(),
+  stroke_width: distance55.nullable().optional(),
   stroke_color: z77.string().optional(),
-  dash_length: distance54.optional(),
-  dash_gap: distance54.optional(),
+  dash_length: distance55.optional(),
+  dash_gap: distance55.optional(),
   points: z77.array(point10),
   subcircuit_id: z77.string().optional()
 });
@@ -395684,15 +396355,15 @@ var schematic_line2 = z80.object({
   schematic_sheet_id: z80.string().optional(),
   schematic_component_id: z80.string().optional(),
   schematic_symbol_id: z80.string().optional(),
-  x1: distance54,
-  y1: distance54,
-  x2: distance54,
-  y2: distance54,
-  stroke_width: distance54.nullable().optional(),
+  x1: distance55,
+  y1: distance55,
+  x2: distance55,
+  y2: distance55,
+  stroke_width: distance55.nullable().optional(),
   color: z80.string().default("#000000"),
   is_dashed: z80.boolean().default(false),
-  dash_length: distance54.optional(),
-  dash_gap: distance54.optional(),
+  dash_length: distance55.optional(),
+  dash_gap: distance55.optional(),
   subcircuit_id: z80.string().optional()
 }).describe("Draws a styled line on the schematic");
 expectTypesMatch3(true);
@@ -395703,10 +396374,10 @@ var schematic_rect2 = z81.object({
   schematic_component_id: z81.string().optional(),
   schematic_symbol_id: z81.string().optional(),
   center: point10,
-  width: distance54,
-  height: distance54,
+  width: distance55,
+  height: distance55,
   rotation: rotation12.default(0),
-  stroke_width: distance54.nullable().optional(),
+  stroke_width: distance55.nullable().optional(),
   color: z81.string().default("#000000"),
   is_filled: z81.boolean().default(false),
   fill_color: z81.string().optional(),
@@ -395721,8 +396392,8 @@ var schematic_circle2 = z822.object({
   schematic_component_id: z822.string().optional(),
   schematic_symbol_id: z822.string().optional(),
   center: point10,
-  radius: distance54,
-  stroke_width: distance54.nullable().optional(),
+  radius: distance55,
+  stroke_width: distance55.nullable().optional(),
   color: z822.string().default("#000000"),
   is_filled: z822.boolean().default(false),
   fill_color: z822.string().optional(),
@@ -395737,11 +396408,11 @@ var schematic_arc2 = z832.object({
   schematic_component_id: z832.string().optional(),
   schematic_symbol_id: z832.string().optional(),
   center: point10,
-  radius: distance54,
+  radius: distance55,
   start_angle_degrees: rotation12,
   end_angle_degrees: rotation12,
   direction: z832.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
-  stroke_width: distance54.nullable().optional(),
+  stroke_width: distance55.nullable().optional(),
   color: z832.string().default("#000000"),
   is_dashed: z832.boolean().default(false),
   subcircuit_id: z832.string().optional()
@@ -395797,8 +396468,8 @@ var schematic_text2 = z87.object({
   display_superscript: z87.string().optional(),
   font_size: z87.number().default(0.18),
   position: z87.object({
-    x: distance54,
-    y: distance54
+    x: distance55,
+    y: distance55
   }),
   rotation: z87.number().default(0),
   anchor: z87.union([fivePointAnchor3.describe("legacy"), ninePointAnchor3]).default("center"),
@@ -395949,7 +396620,7 @@ var schematic_element_outside_sheet_warning2 = z97.object({
   schematic_element_id: z97.string()
 }).describe("Warning emitted when a schematic component, net label, or trace extends outside its schematic sheet");
 expectTypesMatch3(true);
-var positiveFiniteDistance2 = distance54.pipe(z98.number().positive().finite());
+var positiveFiniteDistance2 = distance55.pipe(z98.number().positive().finite());
 var schematic_graphic2 = z98.object({
   type: z98.literal("schematic_graphic"),
   schematic_graphic_id: getZodPrefixedIdWithDefault2("schematic_graphic"),
@@ -395988,10 +396659,10 @@ var schematic_table2 = z100.object({
   schematic_table_id: getZodPrefixedIdWithDefault2("schematic_table"),
   schematic_sheet_id: z100.string().optional(),
   anchor_position: point10,
-  column_widths: z100.array(distance54),
-  row_heights: z100.array(distance54),
-  cell_padding: distance54.optional(),
-  border_width: distance54.optional(),
+  column_widths: z100.array(distance55),
+  row_heights: z100.array(distance55),
+  cell_padding: distance55.optional(),
+  border_width: distance55.optional(),
   subcircuit_id: z100.string().optional(),
   schematic_component_id: z100.string().optional(),
   anchor: ninePointAnchor3.optional()
@@ -396008,11 +396679,11 @@ var schematic_table_cell2 = z101.object({
   end_column_index: z101.number(),
   text: z101.string().optional(),
   center: point10,
-  width: distance54,
-  height: distance54,
+  width: distance55,
+  height: distance55,
   horizontal_align: z101.enum(["left", "center", "right"]).optional(),
   vertical_align: z101.enum(["top", "middle", "bottom"]).optional(),
-  font_size: distance54.optional(),
+  font_size: distance55.optional(),
   subcircuit_id: z101.string().optional()
 }).describe("Defines a cell within a schematic_table");
 expectTypesMatch3(true);
@@ -396037,8 +396708,8 @@ var schematic_missing_sheet_warning2 = z1032.object({
 }).describe("Circuit-wide warning emitted when a schematic has no schematic sheet. Display as a banner without attaching it to a component or drawing a target outline or leader line.");
 expectTypesMatch3(true);
 var point_with_bulge2 = z104.object({
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   bulge: z104.number().optional()
 });
 expectTypesMatch3(true);
@@ -396129,8 +396800,8 @@ var getRotationBetweenPcbPin1Locations4 = (from, to) => {
   return null;
 };
 var pcb_route_hint2 = z107.object({
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   via: z107.boolean().optional(),
   via_to_layer: layer_ref3.optional()
 });
@@ -396138,11 +396809,11 @@ var pcb_route_hints2 = z107.array(pcb_route_hint2);
 expectTypesMatch3(true);
 expectTypesMatch3(true);
 var route_hint_point9 = z108.object({
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   via: z108.boolean().optional(),
   to_layer: layer_ref3.optional(),
-  trace_width: distance54.optional()
+  trace_width: distance55.optional()
 });
 expectTypesMatch3(true);
 var manufacturing_drc_properties2 = z109.object({
@@ -396228,8 +396899,8 @@ var pcb_hole_circle2 = z1122.object({
   pcb_component_id: z1122.string().optional(),
   hole_shape: z1122.literal("circle"),
   hole_diameter: z1122.number(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   is_covered_with_solder_mask: z1122.boolean().optional(),
   soldermask_margin: z1122.number().optional()
 });
@@ -396244,8 +396915,8 @@ var pcb_hole_rect2 = z1122.object({
   hole_shape: z1122.literal("rect"),
   hole_width: z1122.number(),
   hole_height: z1122.number(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   is_covered_with_solder_mask: z1122.boolean().optional(),
   soldermask_margin: z1122.number().optional()
 });
@@ -396259,8 +396930,8 @@ var pcb_hole_circle_or_square2 = z1122.object({
   pcb_component_id: z1122.string().optional(),
   hole_shape: z1122.enum(["circle", "square"]),
   hole_diameter: z1122.number(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   is_covered_with_solder_mask: z1122.boolean().optional(),
   soldermask_margin: z1122.number().optional()
 });
@@ -396275,8 +396946,8 @@ var pcb_hole_oval2 = z1122.object({
   hole_shape: z1122.literal("oval"),
   hole_width: z1122.number(),
   hole_height: z1122.number(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   is_covered_with_solder_mask: z1122.boolean().optional(),
   soldermask_margin: z1122.number().optional()
 });
@@ -396291,8 +396962,8 @@ var pcb_hole_pill2 = z1122.object({
   hole_shape: z1122.literal("pill"),
   hole_width: z1122.number(),
   hole_height: z1122.number(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   is_covered_with_solder_mask: z1122.boolean().optional(),
   soldermask_margin: z1122.number().optional()
 });
@@ -396307,8 +396978,8 @@ var pcb_hole_rotated_pill2 = z1122.object({
   hole_shape: z1122.literal("rotated_pill"),
   hole_width: z1122.number(),
   hole_height: z1122.number(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   ccw_rotation: rotation12,
   is_covered_with_solder_mask: z1122.boolean().optional(),
   soldermask_margin: z1122.number().optional()
@@ -396324,8 +396995,8 @@ var pcb_plated_hole_circle2 = z1132.object({
   outer_diameter: z1132.number(),
   hole_diameter: z1132.number(),
   is_covered_with_solder_mask: z1132.boolean().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   layers: z1132.array(layer_ref3),
   port_hints: z1132.array(z1132.string()).optional(),
   pcb_component_id: z1132.string().optional(),
@@ -396343,8 +397014,8 @@ var pcb_plated_hole_oval2 = z1132.object({
   hole_width: z1132.number(),
   hole_height: z1132.number(),
   is_covered_with_solder_mask: z1132.boolean().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   ccw_rotation: rotation12,
   layers: z1132.array(layer_ref3),
   port_hints: z1132.array(z1132.string()).optional(),
@@ -396364,11 +397035,11 @@ var pcb_circular_hole_with_rect_pad2 = z1132.object({
   rect_pad_width: z1132.number(),
   rect_pad_height: z1132.number(),
   rect_border_radius: z1132.number().optional(),
-  hole_offset_x: distance54.default(0),
-  hole_offset_y: distance54.default(0),
+  hole_offset_x: distance55.default(0),
+  hole_offset_y: distance55.default(0),
   is_covered_with_solder_mask: z1132.boolean().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   layers: z1132.array(layer_ref3),
   port_hints: z1132.array(z1132.string()).optional(),
   pcb_component_id: z1132.string().optional(),
@@ -396389,11 +397060,11 @@ var pcb_pill_hole_with_rect_pad2 = z1132.object({
   rect_pad_width: z1132.number(),
   rect_pad_height: z1132.number(),
   rect_border_radius: z1132.number().optional(),
-  hole_offset_x: distance54.default(0),
-  hole_offset_y: distance54.default(0),
+  hole_offset_x: distance55.default(0),
+  hole_offset_y: distance55.default(0),
   is_covered_with_solder_mask: z1132.boolean().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   layers: z1132.array(layer_ref3),
   port_hints: z1132.array(z1132.string()).optional(),
   pcb_component_id: z1132.string().optional(),
@@ -396415,11 +397086,11 @@ var pcb_rotated_pill_hole_with_rect_pad2 = z1132.object({
   rect_pad_height: z1132.number(),
   rect_border_radius: z1132.number().optional(),
   rect_ccw_rotation: rotation12,
-  hole_offset_x: distance54.default(0),
-  hole_offset_y: distance54.default(0),
+  hole_offset_x: distance55.default(0),
+  hole_offset_y: distance55.default(0),
   is_covered_with_solder_mask: z1132.boolean().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   layers: z1132.array(layer_ref3),
   port_hints: z1132.array(z1132.string()).optional(),
   pcb_component_id: z1132.string().optional(),
@@ -396437,14 +397108,14 @@ var pcb_hole_with_polygon_pad2 = z1132.object({
   hole_width: z1132.number().optional(),
   hole_height: z1132.number().optional(),
   pad_outline: z1132.array(z1132.object({
-    x: distance54,
-    y: distance54
+    x: distance55,
+    y: distance55
   })).min(3),
-  hole_offset_x: distance54.default(0),
-  hole_offset_y: distance54.default(0),
+  hole_offset_x: distance55.default(0),
+  hole_offset_y: distance55.default(0),
   is_covered_with_solder_mask: z1132.boolean().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   layers: z1132.array(layer_ref3),
   port_hints: z1132.array(z1132.string()).optional(),
   pcb_component_id: z1132.string().optional(),
@@ -396474,8 +397145,8 @@ var pcb_port2 = z114.object({
   subcircuit_id: z114.string().optional(),
   source_port_id: z114.string(),
   pcb_component_id: z114.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   layers: z114.array(layer_ref3),
   is_board_pinout: z114.boolean().optional()
 }).describe("Defines a port on the PCB");
@@ -396486,8 +397157,8 @@ var pcb_smtpad_circle2 = z115.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z115.string().optional(),
   subcircuit_id: z115.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   radius: z115.number(),
   layer: layer_ref3,
   port_hints: z115.array(z115.string()).optional(),
@@ -396503,8 +397174,8 @@ var pcb_smtpad_rect2 = z115.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z115.string().optional(),
   subcircuit_id: z115.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z115.number(),
   height: z115.number(),
   rect_border_radius: z115.number().optional(),
@@ -396527,8 +397198,8 @@ var pcb_smtpad_rotated_rect2 = z115.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z115.string().optional(),
   subcircuit_id: z115.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z115.number(),
   height: z115.number(),
   rect_border_radius: z115.number().optional(),
@@ -396552,8 +397223,8 @@ var pcb_smtpad_pill2 = z115.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z115.string().optional(),
   subcircuit_id: z115.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z115.number(),
   height: z115.number(),
   radius: z115.number(),
@@ -396571,8 +397242,8 @@ var pcb_smtpad_rotated_pill2 = z115.object({
   pcb_smtpad_id: getZodPrefixedIdWithDefault2("pcb_smtpad"),
   pcb_group_id: z115.string().optional(),
   subcircuit_id: z115.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z115.number(),
   height: z115.number(),
   radius: z115.number(),
@@ -396620,8 +397291,8 @@ var pcb_solder_paste_circle2 = z116.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z116.string().optional(),
   subcircuit_id: z116.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   radius: z116.number(),
   layer: layer_ref3,
   pcb_component_id: z116.string().optional(),
@@ -396633,8 +397304,8 @@ var pcb_solder_paste_rect2 = z116.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z116.string().optional(),
   subcircuit_id: z116.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z116.number(),
   height: z116.number(),
   layer: layer_ref3,
@@ -396647,8 +397318,8 @@ var pcb_solder_paste_pill2 = z116.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z116.string().optional(),
   subcircuit_id: z116.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z116.number(),
   height: z116.number(),
   radius: z116.number(),
@@ -396662,11 +397333,11 @@ var pcb_solder_paste_rotated_rect2 = z116.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z116.string().optional(),
   subcircuit_id: z116.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z116.number(),
   height: z116.number(),
-  ccw_rotation: distance54,
+  ccw_rotation: distance55,
   layer: layer_ref3,
   pcb_component_id: z116.string().optional(),
   pcb_smtpad_id: z116.string().optional()
@@ -396677,8 +397348,8 @@ var pcb_solder_paste_rotated_pill2 = z116.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z116.string().optional(),
   subcircuit_id: z116.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z116.number(),
   height: z116.number(),
   radius: z116.number(),
@@ -396693,8 +397364,8 @@ var pcb_solder_paste_oval2 = z116.object({
   pcb_solder_paste_id: getZodPrefixedIdWithDefault2("pcb_solder_paste"),
   pcb_group_id: z116.string().optional(),
   subcircuit_id: z116.string().optional(),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   width: z116.number(),
   height: z116.number(),
   layer: layer_ref3,
@@ -396744,12 +397415,12 @@ var pcb_text2 = z118.object({
   align: z118.enum(["bottom-left"])
 }).describe("Defines text on the PCB");
 expectTypesMatch3(true);
-var positive_width2 = distance54.pipe(z119.number().finite().positive());
+var positive_width2 = distance55.pipe(z119.number().finite().positive());
 var pcb_trace_route_point_wire2 = z119.object({
   route_type: z119.literal("wire"),
-  x: distance54,
-  y: distance54,
-  width: distance54,
+  x: distance55,
+  y: distance55,
+  width: distance55,
   start_width: positive_width2.optional(),
   end_width: positive_width2.optional(),
   width_interpolation_mode: z119.enum(["linear", "quadratic"]).optional(),
@@ -396788,12 +397459,12 @@ var pcb_trace_route_point_wire2 = z119.object({
 });
 var pcb_trace_route_point_via2 = z119.object({
   route_type: z119.literal("via"),
-  x: distance54,
-  y: distance54,
+  x: distance55,
+  y: distance55,
   copper_pour_id: z119.string().optional(),
   is_inside_copper_pour: z119.boolean().optional(),
-  hole_diameter: distance54.optional(),
-  outer_diameter: distance54.optional(),
+  hole_diameter: distance55.optional(),
+  outer_diameter: distance55.optional(),
   tented_on_top: z119.boolean().optional(),
   tented_on_bottom: z119.boolean().optional(),
   from_layer: layer_ref3,
@@ -396803,7 +397474,7 @@ var pcb_trace_route_point_through_pad2 = z119.object({
   route_type: z119.literal("through_pad"),
   start: point10,
   end: point10,
-  width: distance54,
+  width: distance55,
   start_layer: layer_ref3,
   end_layer: layer_ref3,
   pcb_smtpad_id: z119.string().optional(),
@@ -396868,8 +397539,8 @@ var pcb_trace_too_long_error2 = z121.object({
   pcb_trace_id: z121.string(),
   source_net_id: z121.string().optional(),
   source_trace_id: z121.string().optional(),
-  actual_trace_length: distance54,
-  maximum_trace_length: distance54,
+  actual_trace_length: distance55,
+  maximum_trace_length: distance55,
   subcircuit_id: z121.string().optional()
 }).describe("Error emitted when a PCB trace is longer than its maximum allowed length");
 expectTypesMatch3(true);
@@ -396893,8 +397564,8 @@ var pcb_trace_too_long_warning2 = z1232.object({
   pcb_trace_id: z1232.string(),
   source_net_id: z1232.string().optional(),
   source_trace_id: z1232.string().optional(),
-  actual_trace_length: distance54,
-  maximum_trace_length: distance54,
+  actual_trace_length: distance55,
+  maximum_trace_length: distance55,
   subcircuit_id: z1232.string().optional()
 }).describe("Warning emitted when a PCB trace is longer than its maximum allowed length");
 expectTypesMatch3(true);
@@ -396964,10 +397635,10 @@ var pcb_via2 = z130.object({
   pcb_group_id: z130.string().optional(),
   subcircuit_id: z130.string().optional(),
   subcircuit_connectivity_map_key: z130.string().optional(),
-  x: distance54,
-  y: distance54,
-  outer_diameter: distance54.default("0.6mm"),
-  hole_diameter: distance54.default("0.25mm"),
+  x: distance55,
+  y: distance55,
+  outer_diameter: distance55.default("0.6mm"),
+  hole_diameter: distance55.default("0.25mm"),
   topmost_drill_layer: layer_ref3.optional(),
   bottommost_drill_layer: layer_ref3.optional(),
   through_hole: z130.boolean().optional(),
@@ -397134,11 +397805,11 @@ var pcb_silkscreen_line2 = z139.object({
   pcb_component_id: z139.string(),
   pcb_group_id: z139.string().optional(),
   subcircuit_id: z139.string().optional(),
-  stroke_width: distance54.default("0.1mm"),
-  x1: distance54,
-  y1: distance54,
-  x2: distance54,
-  y2: distance54,
+  stroke_width: distance55.default("0.1mm"),
+  x1: distance55,
+  y1: distance55,
+  x2: distance55,
+  y2: distance55,
   layer: visible_layer2
 }).describe("Defines a silkscreen line on the PCB");
 expectTypesMatch3(true);
@@ -397159,7 +397830,7 @@ var pcb_silkscreen_text2 = z141.object({
   pcb_group_id: z141.string().optional(),
   subcircuit_id: z141.string().optional(),
   font: z141.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance54.default("0.2mm"),
+  font_size: distance55.default("0.2mm"),
   pcb_component_id: z141.string(),
   text: z141.string(),
   is_knockout: z141.boolean().default(false).optional(),
@@ -397187,7 +397858,7 @@ var pcb_copper_text2 = z1422.object({
   pcb_group_id: z1422.string().optional(),
   subcircuit_id: z1422.string().optional(),
   font: z1422.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance54.default("0.2mm"),
+  font_size: distance55.default("0.2mm"),
   pcb_component_id: z1422.string(),
   text: z1422.string(),
   is_knockout: z1422.boolean().default(false).optional(),
@@ -397247,8 +397918,8 @@ var pcb_silkscreen_oval2 = z145.object({
   pcb_group_id: z145.string().optional(),
   subcircuit_id: z145.string().optional(),
   center: point10,
-  radius_x: distance54,
-  radius_y: distance54,
+  radius_x: distance55,
+  radius_y: distance55,
   layer: visible_layer2,
   ccw_rotation: rotation12.optional()
 }).describe("Defines a silkscreen oval on the PCB");
@@ -397288,7 +397959,7 @@ var pcb_fabrication_note_text3 = z148.object({
   subcircuit_id: z148.string().optional(),
   pcb_group_id: z148.string().optional(),
   font: z148.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance54.default("1mm"),
+  font_size: distance55.default("1mm"),
   pcb_component_id: z148.string(),
   text: z148.string(),
   ccw_rotation: z148.number().optional(),
@@ -397358,7 +398029,7 @@ var pcb_note_text3 = z1522.object({
   subcircuit_id: z1522.string().optional(),
   name: z1522.string().optional(),
   font: z1522.literal("tscircuit2024").default("tscircuit2024"),
-  font_size: distance54.default("1mm"),
+  font_size: distance55.default("1mm"),
   text: z1522.string().optional(),
   anchor_position: point10.default({ x: 0, y: 0 }),
   anchor_alignment: z1522.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
@@ -397409,12 +398080,12 @@ var pcb_note_line3 = z155.object({
   subcircuit_id: z155.string().optional(),
   name: z155.string().optional(),
   text: z155.string().optional(),
-  x1: distance54,
-  y1: distance54,
-  x2: distance54,
-  y2: distance54,
+  x1: distance55,
+  y1: distance55,
+  x2: distance55,
+  y2: distance55,
   layer: visible_layer2.default("top"),
-  stroke_width: distance54.default("0.1mm"),
+  stroke_width: distance55.default("0.1mm"),
   color: z155.string().optional(),
   is_dashed: z155.boolean().optional()
 }).describe("Defines a straight documentation note line on the PCB");
@@ -397480,8 +398151,8 @@ var pcb_keepout3 = z159.object({
   pcb_group_id: z159.string().optional(),
   subcircuit_id: z159.string().optional(),
   center: point10,
-  width: distance54,
-  height: distance54,
+  width: distance55,
+  height: distance55,
   pcb_keepout_id: z159.string(),
   layers: z159.array(z159.string()),
   description: z159.string().optional(),
@@ -397495,7 +398166,7 @@ var pcb_keepout3 = z159.object({
   pcb_group_id: z159.string().optional(),
   subcircuit_id: z159.string().optional(),
   center: point10,
-  radius: distance54,
+  radius: distance55,
   pcb_keepout_id: z159.string(),
   layers: z159.array(z159.string()),
   description: z159.string().optional(),
@@ -397718,8 +398389,8 @@ var pcb_breakout_point2 = z1732.object({
   source_port_id: z1732.string().optional(),
   source_net_id: z1732.string().optional(),
   layer: layer_ref3.optional(),
-  x: distance54,
-  y: distance54
+  x: distance55,
+  y: distance55
 }).describe("Defines a routing target within a pcb_group for a source_trace or source_net");
 expectTypesMatch3(true);
 var pcb_ground_plane2 = z174.object({
@@ -397747,9 +398418,9 @@ var pcb_thermal_spoke2 = z176.object({
   pcb_ground_plane_id: z176.string(),
   shape: z176.string(),
   spoke_count: z176.number(),
-  spoke_thickness: distance54,
-  spoke_inner_diameter: distance54,
-  spoke_outer_diameter: distance54,
+  spoke_thickness: distance55,
+  spoke_inner_diameter: distance55,
+  spoke_outer_diameter: distance55,
   pcb_plated_hole_id: z176.string().optional(),
   subcircuit_id: z176.string().optional()
 }).describe("Pattern for connecting a ground plane to a plated hole");
@@ -397831,8 +398502,8 @@ var pcb_via_clearance_error2 = base_circuit_json_error2.extend({
   pcb_error_id: getZodPrefixedIdWithDefault2("pcb_error"),
   error_type: z181.literal("pcb_via_clearance_error").default("pcb_via_clearance_error"),
   pcb_via_ids: z181.array(z181.string()).min(2),
-  minimum_clearance: distance54.optional(),
-  actual_clearance: distance54.optional(),
+  minimum_clearance: distance55.optional(),
+  actual_clearance: distance55.optional(),
   pcb_center: z181.object({
     x: z181.number().optional(),
     y: z181.number().optional()
@@ -397846,8 +398517,8 @@ var pcb_via_trace_clearance_error2 = base_circuit_json_error2.extend({
   error_type: z1822.literal("pcb_via_trace_clearance_error").default("pcb_via_trace_clearance_error"),
   pcb_via_id: z1822.string(),
   pcb_trace_id: z1822.string(),
-  minimum_clearance: distance54.optional(),
-  actual_clearance: distance54.optional(),
+  minimum_clearance: distance55.optional(),
+  actual_clearance: distance55.optional(),
   center: z1822.object({
     x: z1822.number().optional(),
     y: z1822.number().optional()
@@ -397860,8 +398531,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: z1832.literal("pcb_pad_pad_clearance_error").default("pcb_pad_pad_clearance_error"),
   pcb_pad_ids: z1832.array(z1832.string()).min(2),
-  minimum_clearance: distance54.optional(),
-  actual_clearance: distance54.optional(),
+  minimum_clearance: distance55.optional(),
+  actual_clearance: distance55.optional(),
   center: z1832.object({
     x: z1832.number().optional(),
     y: z1832.number().optional()
@@ -397875,8 +398546,8 @@ var pcb_pad_trace_clearance_error2 = base_circuit_json_error2.extend({
   error_type: z184.literal("pcb_pad_trace_clearance_error").default("pcb_pad_trace_clearance_error"),
   pcb_pad_id: z184.string(),
   pcb_trace_id: z184.string(),
-  minimum_clearance: distance54.optional(),
-  actual_clearance: distance54.optional(),
+  minimum_clearance: distance55.optional(),
+  actual_clearance: distance55.optional(),
   center: z184.object({
     x: z184.number().optional(),
     y: z184.number().optional()