@tscircuit/cli 0.1.2211 → 0.1.2212

package/dist/cli/main.js

@@ -154298,7 +154298,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.2210";
+var version = "0.1.2211";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -154317,7 +154317,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.11.tgz",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.33.tgz",
     "@tscircuit/circuit-json-util": "^0.0.116",
     "@tscircuit/eval": "0.0.1402",
     "@tscircuit/fake-snippets": "^0.0.182",
@@ -330754,7 +330754,7 @@ var registerCheckRoutingDifficulty = (program) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ConnectorPlacementSolver/ConnectorPlacementSolver.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/MosfetGateNetworkPlacementSolver/MosfetGateNetworkPlacementSolver.ts
 import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/format.ts
@@ -330775,21 +330775,6 @@ var addAttr = (attrs, key, value, options) => {
   attrs.push(`${key}="${stringValue}"`);
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
-function centeredRect(cx, cy, w, h) {
-  return {
-    left: cx - w / 2,
-    right: cx + w / 2,
-    top: cy + h / 2,
-    bottom: cy - h / 2
-  };
-}
-function rectOverlap(a, b) {
-  const ow = Math.min(a.right, b.right) - Math.max(a.left, b.left);
-  const oh = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
-  return ow > 0 && oh > 0 ? { ow, oh } : null;
-}
-
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/source-connectivity.ts
 function getSourceConnectivity(circuitJson) {
   const parent = new Map;
@@ -330934,8 +330919,632 @@ function append2(map, key, value) {
     map.set(key, [value]);
 }
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ConnectorPlacementSolver/ConnectorPlacementSolver.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/MosfetGateNetworkPlacementSolver/MosfetGateNetworkPlacementSolver.ts
+class MosfetGateNetworkPlacementSolver extends BaseSolver5 {
+  params;
+  index;
+  mosfetIds;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.mosfetIds = [...this.index.components.keys()].filter((id) => this.mosfetPorts(id));
+    this.solved = this.mosfetIds.length === 0;
+  }
+  _step() {
+    const id = this.mosfetIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.mosfetIds.length;
+    if (!id)
+      return;
+    const index = this.index;
+    const mosfet = index.placement(id);
+    const roles = this.mosfetPorts(id);
+    if (!mosfet)
+      return;
+    const gateNet = index.connected(roles.gate.source_port_id);
+    const sourceNet = index.connected(roles.sources[0].source_port_id);
+    const drainNet = index.connected(roles.drains[0].source_port_id);
+    if (new Set([gateNet, sourceNet, drainNet]).size !== 3 || index.isRail(gateNet))
+      return;
+    if ([roles.gate, ...roles.sources, ...roles.drains].some((p) => {
+      const pin = index.port(p);
+      return !pin || pin.schematic_sheet_id !== mosfet.schematicSheetId;
+    }))
+      return;
+    const peers = (index.portsByNet.get(gateNet) ?? []).filter((p) => p.source_component_id !== id);
+    if (peers.length !== 2)
+      return;
+    const resistors = peers.map((p) => {
+      const resistorId = p.source_component_id;
+      const component = index.components.get(resistorId);
+      const placement = index.placement(resistorId);
+      const nets = index.twoTerminalNets(resistorId);
+      if (component?.ftype !== "simple_resistor" || !Number.isFinite(component.resistance) || component.resistance <= 0 || !placement || !nets || !index.sameLocalScope(mosfet, placement) || index.portsByComponent.get(resistorId).some((port) => {
+        const pin = index.port(port);
+        return port.do_not_connect || !pin || pin.schematic_sheet_id !== mosfet.schematicSheetId;
+      }))
+        return;
+      return { placement, otherNet: nets.find((net) => net !== gateNet) };
+    });
+    if (resistors.some((r) => !r))
+      return;
+    const shunts = resistors.filter((r) => r.otherNet === sourceNet);
+    const series = resistors.filter((r) => r.otherNet !== sourceNet);
+    if (shunts.length !== 1 || series.length !== 1)
+      return;
+    const gateSourceResistor = shunts[0].placement;
+    const seriesGateResistor = series[0].placement;
+    if (series[0].otherNet === drainNet || index.isRail(series[0].otherNet))
+      return;
+    const maxRecommendedBodyGap = Math.max(6, 3 * Math.max(mosfet.width, mosfet.height));
+    const maxBodyGap = Math.max(bodyGap(mosfet, seriesGateResistor), bodyGap(mosfet, gateSourceResistor));
+    if (maxBodyGap <= maxRecommendedBodyGap)
+      return;
+    this.params.issues.push({
+      lineItemType: "MosfetGateNetworkNotGrouped",
+      mosfetSchematicBox: mosfet,
+      seriesGateResistorSchematicBox: seriesGateResistor,
+      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.`
+    });
+  }
+  mosfetPorts(id) {
+    const type = this.index.components.get(id)?.ftype;
+    if (type !== "simple_mosfet" && type !== "simple_chip")
+      return;
+    const ports = this.index.portsByComponent.get(id) ?? [];
+    const gate = ports.filter((p) => hasRole(p, /^(G|GATE)$/));
+    const sources = ports.filter((p) => hasRole(p, /^(S|SOURCE)[0-9]*$/));
+    const drains = ports.filter((p) => hasRole(p, /^(D|DRAIN)[0-9]*$/));
+    if (gate.length !== 1 || !sources.length || !drains.length || gate.length + sources.length + drains.length !== ports.length || new Set([...gate, ...sources, ...drains]).size !== ports.length || ports.some((p) => p.do_not_connect))
+      return;
+    for (const group of [sources, drains])
+      if (new Set(group.map((p) => this.index.connected(p.source_port_id))).size !== 1)
+        return;
+    return { gate: gate[0], sources, drains };
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "mosfetName", issue.mosfetSchematicBox.sourceComponentName);
+    addAttr(attrs, "seriesGateResistorName", issue.seriesGateResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "gateSourceResistorName", issue.gateSourceResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "maxBodyGap", issue.maxBodyGap);
+    addAttr(attrs, "maxRecommendedBodyGap", issue.maxRecommendedBodyGap);
+    addAttr(attrs, "message", issue.message);
+    return `<MosfetGateNetworkNotGrouped ${attrs.join(" ")} />`;
+  }
+}
+function hasRole(port, pattern) {
+  return [port.name, ...port.port_hints ?? []].some((hint) => pattern.test(hint.toUpperCase().replace(/[\s_]/g, "")));
+}
+function 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));
+}
+
+// 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 {
+  params;
+  index;
+  relayIds;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.relayIds = [...this.index.components.keys()].filter((id) => this.coilPorts(id));
+    this.solved = this.relayIds.length === 0;
+  }
+  _step() {
+    const relayId = this.relayIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.relayIds.length;
+    if (!relayId)
+      return;
+    const index = this.index;
+    const relay = index.placement(relayId);
+    const coil = this.coilPorts(relayId);
+    if (!relay || coil.some((p) => p.do_not_connect))
+      return;
+    const nets = coil.map((p) => index.connected(p.source_port_id));
+    if (nets[0] === nets[1])
+      return;
+    if (this.relayIds.some((id) => id !== relayId && this.coilPorts(id).every((p) => nets.includes(index.connected(p.source_port_id)))))
+      return;
+    const diodeIds = new Set((index.portsByNet.get(nets[0]) ?? []).filter((p) => index.components.get(p.source_component_id)?.ftype === "simple_diode").map((p) => p.source_component_id).filter((id) => index.twoTerminalNets(id)?.includes(nets[1])));
+    if (diodeIds.size !== 1)
+      return;
+    const diodeId = [...diodeIds][0];
+    const diode = index.placement(diodeId);
+    const anode = this.uniquePort(diodeId, /^(?:ANODE|A)$/);
+    const cathode = this.uniquePort(diodeId, /^(?:CATHODE|K)$/);
+    if (!diode || !index.sameLocalScope(relay, diode) || !anode || !cathode || anode === cathode || anode.do_not_connect || cathode.do_not_connect)
+      return;
+    const anodeNet = index.connected(anode.source_port_id);
+    const cathodeNet = index.connected(cathode.source_port_id);
+    if (index.isRail(anodeNet) || index.groundNets.has(cathodeNet) || !this.hasGroundedDriver(anodeNet, cathodeNet))
+      return;
+    const coilPins = coil.map((p) => index.port(p));
+    const diodePins = [anode, cathode].map((p) => index.port(p));
+    if ([...coilPins, ...diodePins].some((p) => !p || p.schematic_sheet_id !== relay.schematicSheetId))
+      return;
+    const [first, second] = coilPins;
+    const left = Math.min(first.center.x, second.center.x);
+    const right = Math.max(first.center.x, second.center.x);
+    const bottom = Math.min(first.center.y, second.center.y);
+    const top = Math.max(first.center.y, second.center.y);
+    const gapX = Math.max(left - (diode.schX + diode.width / 2), diode.schX - diode.width / 2 - right, 0);
+    const gapY = Math.max(bottom - (diode.schY + diode.height / 2), diode.schY - diode.height / 2 - top, 0);
+    const distanceFromCoilPins = Math.hypot(gapX, gapY);
+    const pinSpan = Math.hypot(right - left, top - bottom);
+    if (distanceFromCoilPins <= Math.max(1.5, 2 * pinSpan) || distanceFromCoilPins > Math.max(8, 4 * Math.max(relay.width, relay.height)))
+      return;
+    if (!this.params.ctx.circuitJson.some((e) => e.type === "schematic_net_label" && e.schematic_sheet_id === relay.schematicSheetId && e.anchor_position && diodePins.some((p) => Math.hypot(p.center.x - e.anchor_position.x, p.center.y - e.anchor_position.y) < 0.01 && !this.hasWireAtPin(p))))
+      return;
+    this.params.issues.push({
+      lineItemType: "FlybackDiodeSeparatedFromRelayCoil",
+      relaySchematicBox: relay,
+      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.`
+    });
+  }
+  hasWireAtPin(pin) {
+    return this.params.ctx.circuitJson.some((e) => e.type === "schematic_trace" && e.schematic_sheet_id === pin.schematic_sheet_id && e.edges.some(({ from, to }) => {
+      const dx = to.x - from.x, dy = to.y - from.y;
+      const lengthSquared = dx * dx + dy * dy;
+      const t = lengthSquared ? Math.max(0, Math.min(1, ((pin.center.x - from.x) * dx + (pin.center.y - from.y) * dy) / lengthSquared)) : 0;
+      return Math.hypot(pin.center.x - from.x - t * dx, pin.center.y - from.y - t * dy) < 0.01;
+    }));
+  }
+  uniquePort(id, pattern) {
+    const ports = this.index.portsByComponent.get(id)?.filter((p) => hasHint(p, pattern));
+    return ports?.length === 1 ? ports[0] : undefined;
+  }
+  coilPorts(id) {
+    if (this.index.components.get(id)?.ftype !== "simple_chip")
+      return;
+    const ports = this.index.portsByComponent.get(id) ?? [];
+    if (!this.uniquePort(id, /^(?:COM|COMMON)$/) || !ports.some((p) => hasHint(p, /^(?:NO|NC|NORMALLYOPEN|NORMALLYCLOSED)$/)))
+      return;
+    const coil = ports.filter((p) => hasHint(p, /^(?:COIL[A-B12]|A[12])$/));
+    if (coil.length !== 2)
+      return;
+    for (const [a, b] of [
+      ["COILA", "COILB"],
+      ["COIL1", "COIL2"],
+      ["A1", "A2"]
+    ]) {
+      const first = this.uniquePort(id, new RegExp(`^${a}$`));
+      const second = this.uniquePort(id, new RegExp(`^${b}$`));
+      if (first && second && first !== second && !hasHint(first, new RegExp(`^${b}$`)) && !hasHint(second, new RegExp(`^${a}$`)))
+        return [first, second];
+    }
+  }
+  hasGroundedDriver(anodeNet, cathodeNet) {
+    return (this.index.portsByNet.get(anodeNet) ?? []).some((p) => {
+      const id = p.source_component_id;
+      const component = this.index.components.get(id);
+      if (component?.ftype !== "simple_chip" && !(component?.ftype === "simple_transistor" && component.transistor_type === "npn"))
+        return false;
+      if (this.index.portsByComponent.get(id)?.length !== 3)
+        return false;
+      const c = this.uniquePort(id, /^(?:C|COLLECTOR)$/);
+      const e = this.uniquePort(id, /^(?:E|EMITTER)$/);
+      const b = this.uniquePort(id, /^(?:B|BASE)$/);
+      if (!c || !e || !b || new Set([c, e, b]).size !== 3 || [c, e, b].some((p) => p.do_not_connect) || c.source_port_id !== p.source_port_id)
+        return false;
+      const emitterNet = this.index.connected(e.source_port_id), baseNet = this.index.connected(b.source_port_id);
+      return this.index.groundNets.has(emitterNet) && !this.index.powerNets.has(emitterNet) && new Set([anodeNet, cathodeNet, emitterNet, baseNet]).size === 4;
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "relayName", issue.relaySchematicBox.sourceComponentName);
+    addAttr(attrs, "diodeName", issue.diodeSchematicBox.sourceComponentName);
+    addAttr(attrs, "distanceFromCoilPins", issue.distanceFromCoilPins);
+    addAttr(attrs, "message", issue.message);
+    return `<FlybackDiodeSeparatedFromRelayCoil ${attrs.join(" ")} />`;
+  }
+}
+function hasHint(port, pattern) {
+  return [port.name, ...port.port_hints ?? []].some((hint) => pattern.test(hint.toUpperCase().replace(/[\s_]/g, "")));
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CurrentSenseShuntPlacementSolver/CurrentSenseShuntPlacementSolver.ts
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
 var EPSILON3 = 0.01;
+
+class CurrentSenseShuntPlacementSolver extends BaseSolver7 {
+  params;
+  index;
+  hostIds;
+  traces;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.hostIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_chip").map((component) => component.source_component_id);
+    this.traces = params2.ctx.circuitJson.filter((element) => element.type === "schematic_trace");
+    this.solved = this.hostIds.length === 0;
+  }
+  _step() {
+    const hostId = this.hostIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.hostIds.length;
+    if (!hostId)
+      return;
+    const index = this.index;
+    const host = index.placement(hostId);
+    const ports = index.portsByComponent.get(hostId) ?? [];
+    const positive = ports.filter((port) => inputRole(port) === "positive");
+    const negative = ports.filter((port) => inputRole(port) === "negative");
+    const outputs = ports.filter((port) => hasHint2(port, /^(?:OUT|VOUT|OUTPUT)$/));
+    if (!host || positive.length !== 1 || negative.length !== 1 || outputs.length !== 1 || !ports.some((port) => hasHint2(port, /^(?:VS|VCC|VDD)$/)) || !ports.some((port) => hasHint2(port, /^(?:GND|GROUND|VSS)$/)))
+      return;
+    const inputs = [positive[0], negative[0]];
+    const nets = inputs.map((port) => index.connected(port.source_port_id));
+    if (inputs.some((port) => port.do_not_connect) || nets[0] === nets[1] || nets.includes(index.connected(outputs[0].source_port_id)))
+      return;
+    const pins = inputs.map((port) => index.port(port));
+    const [positivePin, negativePin] = pins;
+    if (!positivePin || !negativePin || !positivePin.facing_direction || positivePin.facing_direction !== negativePin.facing_direction || pins.some((pin) => pin.schematic_sheet_id !== host.schematicSheetId))
+      return;
+    const resistorIds = new Set((index.portsByNet.get(nets[0]) ?? []).filter((port) => index.components.get(port.source_component_id)?.ftype === "simple_resistor").map((port) => port.source_component_id).filter((id) => index.twoTerminalNets(id)?.includes(nets[1])));
+    if (resistorIds.size !== 1)
+      return;
+    const shuntId = [...resistorIds][0];
+    const component = index.components.get(shuntId);
+    if (component?.ftype !== "simple_resistor" || !Number.isFinite(component.resistance) || component.resistance <= 0 || component.resistance > 1)
+      return;
+    if (nets.some((net) => (index.portsByNet.get(net) ?? []).some((port) => port.source_component_id !== hostId && inputRole(port) !== undefined && index.components.get(port.source_component_id)?.ftype === "simple_chip")))
+      return;
+    const shunt = index.placement(shuntId);
+    if (!shunt || !index.sameLocalScope(host, shunt))
+      return;
+    const shuntPorts = index.portsByComponent.get(shuntId);
+    if (shuntPorts.some((port) => port.do_not_connect))
+      return;
+    const shuntPins = nets.map((net) => index.port(shuntPorts.find((port) => index.connected(port.source_port_id) === net)));
+    if (shuntPins.some((pin) => !pin || pin.schematic_sheet_id !== host.schematicSheetId))
+      return;
+    const horizontalInputs = positivePin.facing_direction === "left" || positivePin.facing_direction === "right";
+    const across = (point) => horizontalInputs ? point.y : point.x;
+    const first = across(positivePin.center), second = across(negativePin.center);
+    const span = Math.abs(first - second);
+    if (span < EPSILON3)
+      return;
+    const shuntAcross = horizontalInputs ? shunt.schY : shunt.schX;
+    const halfSize = (horizontalInputs ? shunt.height : shunt.width) / 2;
+    const inputBandGap = Math.max(Math.min(first, second) - (shuntAcross + halfSize), shuntAcross - halfSize - Math.max(first, second));
+    if (inputBandGap <= Math.max(1.5, 2 * span) || Math.hypot(shunt.schX - host.schX, shunt.schY - host.schY) > Math.max(8, 4 * Math.max(host.width, host.height)))
+      return;
+    const visible = pins.map((pin, i) => this.hasVisibleConnection(shuntPins[i], pin, nets[i]));
+    if (visible[0] === visible[1])
+      return;
+    const labeledIndex = visible[0] ? 1 : 0;
+    const labeledNet = nets[labeledIndex];
+    if (!this.params.ctx.circuitJson.some((element) => {
+      if (element.type !== "schematic_net_label" || element.schematic_sheet_id !== host.schematicSheetId)
+        return false;
+      if (element.source_net_id && (index.connected(element.source_net_id) === labeledNet || index.connected(`connectivity:${element.source_net_id}`) === labeledNet))
+        return true;
+      const pin = shuntPins[labeledIndex].center;
+      if (element.anchor_position && Math.hypot(element.anchor_position.x - pin.x, element.anchor_position.y - pin.y) < EPSILON3)
+        return true;
+      return element.source_trace_id !== undefined && this.sourceTraceTouchesNet(element.source_trace_id, labeledNet);
+    }))
+      return;
+    this.params.issues.push({
+      lineItemType: "CurrentSenseShuntSeparatedFromInputs",
+      amplifierSchematicBox: host,
+      shuntSchematicBox: shunt,
+      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.`
+    });
+  }
+  hasVisibleConnection(from, to, net) {
+    const edges = this.traces.filter((trace) => {
+      if (trace.schematic_sheet_id !== from.schematic_sheet_id)
+        return false;
+      if (trace.subcircuit_connectivity_map_key)
+        return this.index.connected(`connectivity:${trace.subcircuit_connectivity_map_key}`) === net;
+      if (this.sourceTraceTouchesNet(trace.source_trace_id, net))
+        return true;
+      const endpoints = [trace.edges[0]?.from, trace.edges.at(-1)?.to];
+      const endpointNets = new Set(this.params.ctx.circuitJson.flatMap((element) => element.type === "schematic_port" && element.source_port_id && element.schematic_sheet_id === trace.schematic_sheet_id && endpoints.some((point) => point && Math.hypot(point.x - element.center.x, point.y - element.center.y) < EPSILON3) ? [this.index.connected(element.source_port_id)] : []));
+      return endpointNets.size === 1 && endpointNets.has(net);
+    }).flatMap((trace) => trace.edges);
+    const reached = edges.filter((edge) => onSegment4(from.center, edge.from, edge.to));
+    const visited = new Set;
+    for (let i = 0;i < reached.length; i++) {
+      const current = reached[i];
+      if (onSegment4(to.center, current.from, current.to))
+        return true;
+      for (const [edgeIndex, edge] of edges.entries()) {
+        if (visited.has(edgeIndex) || ![current.from, current.to].some((point) => onSegment4(point, edge.from, edge.to)) && ![edge.from, edge.to].some((point) => onSegment4(point, current.from, current.to)))
+          continue;
+        visited.add(edgeIndex);
+        reached.push(edge);
+      }
+    }
+    return false;
+  }
+  sourceTraceTouchesNet(traceId, net) {
+    if (!traceId)
+      return false;
+    const source = this.params.ctx.circuitJson.find((element) => element.type === "source_trace" && element.source_trace_id === traceId);
+    return source?.type === "source_trace" && source.connected_source_port_ids.some((id) => this.index.connected(id) === net);
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "amplifierName", issue.amplifierSchematicBox.sourceComponentName);
+    addAttr(attrs, "shuntName", issue.shuntSchematicBox.sourceComponentName);
+    addAttr(attrs, "inputBandGap", issue.inputBandGap);
+    addAttr(attrs, "message", issue.message);
+    return `<CurrentSenseShuntSeparatedFromInputs ${attrs.join(" ")} />`;
+  }
+}
+function hasHint2(port, pattern) {
+  return [port.name, ...port.port_hints ?? []].some((hint) => pattern.test(hint.toUpperCase().replace(/[\s_]/g, "")));
+}
+function inputRole(port) {
+  const positive = hasHint2(port, /^(?:IN\+|VIN\+|INPOS|VINPOS)$/);
+  const negative = hasHint2(port, /^(?:IN-|VIN-|INNEG|VINNEG)$/);
+  return positive === negative ? undefined : positive ? "positive" : "negative";
+}
+function onSegment4(point, from, to) {
+  const dx = to.x - from.x, dy = to.y - from.y;
+  const length = Math.hypot(dx, dy);
+  if (length < EPSILON3)
+    return Math.hypot(point.x - from.x, point.y - from.y) < EPSILON3;
+  const projection = ((point.x - from.x) * dx + (point.y - from.y) * dy) / length;
+  return projection >= -EPSILON3 && projection <= length + EPSILON3 && Math.abs((point.x - from.x) * dy - (point.y - from.y) * dx) / length < EPSILON3;
+}
+
+// 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 {
+  params;
+  index;
+  positiveNets = new Set;
+  resistorIds;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.resistorIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_resistor").map((component) => component.source_component_id);
+    for (const element of params2.ctx.circuitJson) {
+      if (element.type === "source_net" && element.is_positive_voltage_source)
+        this.positiveNets.add(this.index.connected(element.source_net_id));
+    }
+    this.solved = this.resistorIds.length === 0;
+  }
+  _step() {
+    const supplyId = this.resistorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.resistorIds.length;
+    if (!supplyId || !this.isResistor(supplyId))
+      return;
+    const index = this.index;
+    const nets = index.twoTerminalNets(supplyId);
+    if (!nets)
+      return;
+    const rails = nets.filter((net) => index.isRail(net));
+    if (rails.length !== 1)
+      return;
+    const supplyNet = rails[0];
+    if (!this.positiveNets.has(supplyNet) || index.groundNets.has(supplyNet))
+      return;
+    const tap = nets.find((net) => net !== supplyNet);
+    const tapPorts = index.portsByNet.get(tap) ?? [];
+    const resistorIds = new Set(tapPorts.filter((port) => index.components.get(port.source_component_id)?.ftype === "simple_resistor").map((port) => port.source_component_id));
+    if (resistorIds.size !== 2)
+      return;
+    const groundId = [...resistorIds].find((id) => id !== supplyId);
+    if (!this.isResistor(groundId))
+      return;
+    const groundNets = index.twoTerminalNets(groundId);
+    const groundNet = groundNets?.find((net) => net !== tap);
+    if (!groundNets?.includes(tap) || !groundNet || !index.groundNets.has(groundNet) || index.powerNets.has(groundNet) || !tapPorts.some((port) => !resistorIds.has(port.source_component_id)))
+      return;
+    const supply = index.placement(supplyId);
+    const ground = index.placement(groundId);
+    if (!supply || !ground || !index.sameLocalScope(supply, ground))
+      return;
+    const supplyTap = this.getDownwardResistorPorts(supplyId, supplyNet, tap);
+    const groundTap = this.getDownwardResistorPorts(groundId, tap, groundNet);
+    if (!supplyTap || !groundTap)
+      return;
+    const reversedBodyGap = ground.schY - ground.height / 2 - (supply.schY + supply.height / 2);
+    if (reversedBodyGap <= 1.5)
+      return;
+    this.params.issues.push({
+      lineItemType: "VoltageDividerSupplyResistorBelowGroundResistor",
+      supplyResistorSchematicBox: supply,
+      groundResistorSchematicBox: ground,
+      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.`
+    });
+  }
+  isResistor(id) {
+    const component = this.index.components.get(id);
+    return component?.ftype === "simple_resistor" && Number.isFinite(component.resistance) && component.resistance > 0;
+  }
+  getDownwardResistorPorts(id, topNet, bottomNet) {
+    const index = this.index;
+    const placement = index.placement(id);
+    const ports = index.portsByComponent.get(id);
+    if (ports.some((port) => port.do_not_connect))
+      return;
+    const top = ports.find((port) => index.connected(port.source_port_id) === topNet);
+    const bottom = ports.find((port) => index.connected(port.source_port_id) === bottomNet);
+    if (!top || !bottom)
+      return;
+    const topPin = index.port(top);
+    const bottomPin = index.port(bottom);
+    if (!topPin || !bottomPin || topPin.schematic_sheet_id !== placement.schematicSheetId || bottomPin.schematic_sheet_id !== placement.schematicSheetId || topPin.facing_direction !== "up" || bottomPin.facing_direction !== "down" || topPin.center.y <= bottomPin.center.y)
+      return;
+    return { top, bottom };
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "supplyResistorName", issue.supplyResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "groundResistorName", issue.groundResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "reversedBodyGap", issue.reversedBodyGap);
+    addAttr(attrs, "message", issue.message);
+    return `<VoltageDividerSupplyResistorBelowGroundResistor ${attrs.join(" ")} />`;
+  }
+}
+
+// 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 {
+  params;
+  index;
+  hostIds;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.hostIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_chip").map((component) => component.source_component_id);
+    this.solved = this.hostIds.length === 0;
+  }
+  _step() {
+    const hostId = this.hostIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.hostIds.length;
+    if (!hostId)
+      return;
+    const index = this.index;
+    const host = index.placement(hostId);
+    const ports = index.portsByComponent.get(hostId) ?? [];
+    if (!host || ports.some((port) => !portRole(port)))
+      return;
+    const inputs = ports.filter((port) => portRole(port) === "input");
+    const outputs = ports.filter((port) => portRole(port) === "output");
+    const grounds = ports.filter((port) => portRole(port) === "ground");
+    if (inputs.length !== 1 || outputs.length !== 1 || !grounds.length)
+      return;
+    const input = inputs[0];
+    const output = outputs[0];
+    if ([input, output, ...grounds].some((port) => port.do_not_connect))
+      return;
+    const inputNet = index.connected(input.source_port_id);
+    const outputNet = index.connected(output.source_port_id);
+    const groundNets = new Set(grounds.map((port) => index.connected(port.source_port_id)));
+    if (groundNets.size !== 1)
+      return;
+    const groundNet = [...groundNets][0];
+    if (new Set([inputNet, outputNet, groundNet]).size !== 3 || !(index.groundNets.has(groundNet) || grounds.some((port) => port.requires_ground || port.provides_ground)) || !(index.powerNets.has(inputNet) || input.requires_power) || !(index.powerNets.has(outputNet) || output.provides_power))
+      return;
+    const inputPin = index.port(input);
+    const outputPin = index.port(output);
+    if (!inputPin || !outputPin || inputPin.schematic_sheet_id !== host.schematicSheetId || outputPin.schematic_sheet_id !== host.schematicSheetId)
+      return;
+    const horizontal = inputPin.facing_direction === "left" && outputPin.facing_direction === "right" || inputPin.facing_direction === "right" && outputPin.facing_direction === "left";
+    const vertical = inputPin.facing_direction === "up" && outputPin.facing_direction === "down" || inputPin.facing_direction === "down" && outputPin.facing_direction === "up";
+    if (!horizontal && !vertical)
+      return;
+    const sign = outputPin.facing_direction === "right" || outputPin.facing_direction === "up" ? 1 : -1;
+    const pinSeparation = sign * (horizontal ? outputPin.center.x - inputPin.center.x : outputPin.center.y - inputPin.center.y);
+    if (pinSeparation <= 0.01)
+      return;
+    const inputCap = this.localCapacitor(host, inputNet, groundNet);
+    const outputCap = this.localCapacitor(host, outputNet, groundNet);
+    if (!inputCap || !outputCap)
+      return;
+    const beyondOppositeSide = (cap, side) => {
+      const distance = side * sign * (horizontal ? cap.schX - host.schX : cap.schY - host.schY);
+      const halfBodies = horizontal ? (host.width + cap.width) / 2 : (host.height + cap.height) / 2;
+      return distance > halfBodies + 0.2;
+    };
+    if (!beyondOppositeSide(inputCap, 1) || !beyondOppositeSide(outputCap, -1))
+      return;
+    const name = host.sourceComponentName ?? hostId;
+    this.params.issues.push({
+      lineItemType: "RegulatorCapacitorsOnWrongSides",
+      regulatorSchematicBox: host,
+      inputCapacitorSchematicBox: inputCap,
+      outputCapacitorSchematicBox: outputCap,
+      inputSourcePortId: input.source_port_id,
+      outputSourcePortId: output.source_port_id,
+      message: `Place ${inputCap.sourceComponentName} near ${name}.${input.name} on the ${inputPin.facing_direction} side and ${outputCap.sourceComponentName} near ${name}.${output.name} on the ${outputPin.facing_direction} side. Preserve all connections and leave room for labels; exact alignment is not required.`
+    });
+  }
+  localCapacitor(host, rail, ground) {
+    const index = this.index;
+    const candidates = [];
+    const maxDistance = Math.max(6, 4 * Math.max(host.width, host.height));
+    const ids = new Set((index.portsByNet.get(rail) ?? []).map((port) => port.source_component_id));
+    for (const id of ids) {
+      if (index.components.get(id)?.ftype !== "simple_capacitor")
+        continue;
+      const nets = index.twoTerminalNets(id);
+      const cap = index.placement(id);
+      if (!nets?.includes(ground) || !cap || !index.sameLocalScope(host, cap))
+        continue;
+      if (Math.hypot(cap.schX - host.schX, cap.schY - host.schY) > maxDistance)
+        continue;
+      const ports = index.portsByComponent.get(id);
+      if (ports.some((port) => port.do_not_connect || !index.port(port) || index.port(port).schematic_sheet_id !== host.schematicSheetId))
+        continue;
+      candidates.push(cap);
+    }
+    return candidates.length === 1 ? candidates[0] : undefined;
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "regulatorName", issue.regulatorSchematicBox.sourceComponentName);
+    addAttr(attrs, "inputCapacitorName", issue.inputCapacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "outputCapacitorName", issue.outputCapacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "message", issue.message);
+    return `<RegulatorCapacitorsOnWrongSides ${attrs.join(" ")} />`;
+  }
+}
+function portRole(port) {
+  const roles = new Set;
+  for (const hint of [port.name, ...port.port_hints ?? []]) {
+    const name = hint.toUpperCase().replace(/[ _-]/g, "");
+    if (/^(?:VIN|IN|INPUT)$/.test(name))
+      roles.add("input");
+    else if (/^(?:VOUT|OUT|OUTPUT)$/.test(name))
+      roles.add("output");
+    else if (/^(?:GND\d*|VSS)$/.test(name))
+      roles.add("ground");
+    else if (/^(?:EN|ENABLE|CE|SHDN|NC\d*|EP|PAD|ADJ|FB|BYP|BYPASS|NR|PG|PGOOD)$/.test(name))
+      roles.add("control");
+  }
+  return roles.size === 1 ? [...roles][0] : undefined;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ConnectorPlacementSolver/ConnectorPlacementSolver.ts
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
+function centeredRect(cx, cy, w, h) {
+  return {
+    left: cx - w / 2,
+    right: cx + w / 2,
+    top: cy + h / 2,
+    bottom: cy - h / 2
+  };
+}
+function rectOverlap(a, b) {
+  const ow = Math.min(a.right, b.right) - Math.max(a.left, b.left);
+  const oh = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+  return ow > 0 && oh > 0 ? { ow, oh } : null;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ConnectorPlacementSolver/ConnectorPlacementSolver.ts
+var EPSILON4 = 0.01;
 var directions = {
   right: { x: 1, y: 0 },
   left: { x: -1, y: 0 },
@@ -330944,10 +331553,10 @@ var directions = {
 };
 var dot2 = (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) <= EPSILON3;
+var near = (a, b) => distance49(a, b) <= EPSILON4;
 var round = (value) => Math.round(value * 100) / 100;
 
-class ConnectorPlacementSolver extends BaseSolver5 {
+class ConnectorPlacementSolver extends BaseSolver10 {
   params;
   constructor(params2) {
     super();
@@ -331015,7 +331624,7 @@ class ConnectorPlacementSolver extends BaseSolver5 {
         continue;
       const detours = detouredConnections.flat();
       const ordered = [...connections].sort((a, b) => dot2(a.pin.center, across) - dot2(b.pin.center, across));
-      if (ordered.some((c, i) => i > 0 && dot2(c.peer.center, across) <= dot2(ordered[i - 1].peer.center, across) + EPSILON3))
+      if (ordered.some((c, i) => i > 0 && dot2(c.peer.center, across) <= dot2(ordered[i - 1].peer.center, across) + EPSILON4))
         continue;
       const center = { x: connector.schX, y: connector.schY };
       const pinOffset = Math.max(...connections.map((c) => dot2(c.pin.center, along) - dot2(center, along)));
@@ -331031,7 +331640,7 @@ class ConnectorPlacementSolver extends BaseSolver5 {
         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) + EPSILON3))
+      if (connections.some((c) => distance49(movedPin(c.pin), c.peer.center) > distance49(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);
@@ -331118,7 +331727,7 @@ function bendCount(trace) {
       return 0;
     if (near(edge.from, edge.to))
       continue;
-    const axis = Math.abs(edge.from.y - edge.to.y) < EPSILON3 ? "x" : Math.abs(edge.from.x - edge.to.x) < EPSILON3 ? "y" : undefined;
+    const axis = Math.abs(edge.from.y - edge.to.y) < EPSILON4 ? "x" : Math.abs(edge.from.x - edge.to.x) < EPSILON4 ? "y" : undefined;
     if (!axis)
       return 0;
     if (previousAxis && previousAxis !== axis)
@@ -331133,8 +331742,8 @@ function segmentCrossesBox(a, b, box) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/LowSideTransistorPlacementSolver/LowSideTransistorPlacementSolver.ts
-import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
-class LowSideTransistorPlacementSolver extends BaseSolver6 {
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+class LowSideTransistorPlacementSolver extends BaseSolver11 {
   index;
   positiveNets = new Set;
   transistorIds;
@@ -331253,8 +331862,129 @@ class LowSideTransistorPlacementSolver extends BaseSolver6 {
   }
 }
 
+// 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 {
+  params;
+  index;
+  hostIds;
+  reportedPairs = new Set;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.hostIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_chip").map((component) => component.source_component_id);
+    this.solved = this.hostIds.length === 0;
+  }
+  _step() {
+    const hostId = this.hostIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.hostIds.length;
+    if (!hostId)
+      return;
+    const ports = this.index.portsByComponent.get(hostId) ?? [];
+    const positivePorts = ports.filter((port) => usbRole(port) === "positive");
+    const negativePorts = ports.filter((port) => usbRole(port) === "negative");
+    if (positivePorts.length !== 1 || negativePorts.length !== 1)
+      return;
+    const positivePort = positivePorts[0];
+    const negativePort = negativePorts[0];
+    const positive = this.seriesResistor(positivePort);
+    const negative = this.seriesResistor(negativePort);
+    if (!positive || !negative || positive.axis !== negative.axis || !this.index.sameLocalScope(positive.placement, negative.placement) || new Set([
+      positive.hostNet,
+      negative.hostNet,
+      positive.interfaceNet,
+      negative.interfaceNet
+    ]).size !== 4 || !this.shareInterface(positive, negative, hostId))
+      return;
+    const pairKey = [positive.id, negative.id].sort().join("\x00");
+    if (this.reportedPairs.has(pairKey))
+      return;
+    const a = positive.placement;
+    const b = negative.placement;
+    const horizontal = positive.axis === "horizontal";
+    const along = Math.abs(horizontal ? a.schX - b.schX : a.schY - b.schY);
+    const across = Math.abs(horizontal ? a.schY - b.schY : a.schX - b.schX);
+    const alongA = horizontal ? a.width : a.height;
+    const alongB = horizontal ? b.width : b.height;
+    const acrossA = horizontal ? a.height : a.width;
+    const acrossB = horizontal ? b.height : b.width;
+    const bodyGap = along - (alongA + alongB) / 2;
+    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;
+    this.params.issues.push({
+      lineItemType: "UsbSeriesResistorsNotAligned",
+      positiveResistorSchematicBox: a,
+      negativeResistorSchematicBox: b,
+      hostSourceComponentId: hostId,
+      positiveSourcePortId: positivePort.source_port_id,
+      negativeSourcePortId: negativePort.source_port_id,
+      signalAxis: positive.axis,
+      message: `Place ${positiveName} (D+) and ${negativeName} (D−) near each other and draw clear traces to their corresponding USB ports. Exact alignment is not required; preserve pin assignments and leave space for labels.`
+    });
+  }
+  seriesResistor(hostPort) {
+    const index = this.index;
+    const hostNet = index.connected(hostPort.source_port_id);
+    if (index.isRail(hostNet))
+      return;
+    const candidates = new Set((index.portsByNet.get(hostNet) ?? []).filter((port) => index.components.get(port.source_component_id)?.ftype === "simple_resistor").map((port) => port.source_component_id));
+    if (candidates.size !== 1)
+      return;
+    const id = [...candidates][0];
+    const nets = index.twoTerminalNets(id);
+    const interfaceNet = nets?.find((net) => net !== hostNet);
+    const placement = index.placement(id);
+    if (!interfaceNet || index.isRail(interfaceNet) || !placement)
+      return;
+    if ((index.portsByNet.get(interfaceNet) ?? []).some((port) => port.source_component_id !== id && index.components.get(port.source_component_id)?.ftype === "simple_resistor"))
+      return;
+    const pins = index.portsByComponent.get(id).map((port) => index.port(port));
+    const [first, second] = pins;
+    if (!first || !second)
+      return;
+    const facing = new Set([first.facing_direction, second.facing_direction]);
+    let axis;
+    if (facing.has("left") && facing.has("right") && Math.abs(first.center.y - second.center.y) < 0.01)
+      axis = "horizontal";
+    else if (facing.has("up") && facing.has("down") && Math.abs(first.center.x - second.center.x) < 0.01)
+      axis = "vertical";
+    else
+      return;
+    return { id, placement, hostNet, interfaceNet, axis };
+  }
+  shareInterface(positive, negative, hostId) {
+    const peerIds = (net) => new Set((this.index.portsByNet.get(net) ?? []).map((port) => port.source_component_id).filter((id) => id !== hostId && id !== positive.id && id !== negative.id && (this.index.portsByComponent.get(id)?.length ?? 0) > 2));
+    const positivePeers = peerIds(positive.interfaceNet);
+    return [...peerIds(negative.interfaceNet)].some((id) => positivePeers.has(id));
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "positiveResistorName", issue.positiveResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "negativeResistorName", issue.negativeResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "signalAxis", issue.signalAxis);
+    addAttr(attrs, "message", issue.message);
+    return `<UsbSeriesResistorsNotAligned ${attrs.join(" ")} />`;
+  }
+}
+function usbRole(port) {
+  const roles = new Set;
+  for (const hint of [port.name, ...port.port_hints ?? []]) {
+    const name = hint.toUpperCase();
+    if (/^(?:USB_?)?D(?:P|\+|_POS)$/.test(name))
+      roles.add("positive");
+    if (/^(?:USB_?)?D(?:M|N|-|_NEG)$/.test(name))
+      roles.add("negative");
+  }
+  return roles.size === 1 ? [...roles][0] : undefined;
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/graphics.ts
 import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
@@ -331289,7 +332019,7 @@ function visualizeCircuitJson(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-class CapacitorOrientationSolver extends BaseSolver7 {
+class CapacitorOrientationSolver extends BaseSolver13 {
   static EPSILON = 0.01;
   static ORIENTATION_MESSAGE = 'Use schOrientation="vertical" on this capacitor to fix the symbol orientation';
   ctx;
@@ -331434,8 +332164,8 @@ class CapacitorOrientationSolver extends BaseSolver7 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DecouplingCapacitorGroupingSolver/DecouplingCapacitorGroupingSolver.ts
-import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
-class DecouplingCapacitorGroupingSolver extends BaseSolver8 {
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+class DecouplingCapacitorGroupingSolver extends BaseSolver14 {
   params;
   static MIN_BODY_GAP = 4;
   banks = [];
@@ -331567,8 +332297,8 @@ function getNetLabelBounds(label) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
-class ComponentNetLabelCollisionSolver extends BaseSolver9 {
+import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
+class ComponentNetLabelCollisionSolver extends BaseSolver15 {
   params;
   placements;
   netLabelsByComponentId;
@@ -331892,8 +332622,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver9 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver10 {
+import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver16 {
   static ALIGNMENT_EPSILON = 0.01;
   ctx;
   out;
@@ -332027,8 +332757,8 @@ class ComponentPinAlignmentSolver extends BaseSolver10 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CrystalLoadCapacitorPlacementSolver/CrystalLoadCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
-class CrystalLoadCapacitorPlacementSolver extends BaseSolver11 {
+import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
+class CrystalLoadCapacitorPlacementSolver extends BaseSolver17 {
   static ALIGNMENT_TOLERANCE = 0.1;
   issues;
   networks;
@@ -332188,9 +332918,9 @@ var distance50 = (first, second) => Math.hypot(first.schX - second.schX, first.s
 var round2 = (value) => Math.round(value * 100) / 100;
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
-import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
 import { getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2 } from "circuit-json-to-connectivity-map";
-class DiodeResistorAlignmentSolver extends BaseSolver12 {
+class DiodeResistorAlignmentSolver extends BaseSolver18 {
   static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
   ctx;
   out;
@@ -332356,8 +333086,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver12 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/FeedbackNetworkPlacementSolver/FeedbackNetworkPlacementSolver.ts
-import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
-class FeedbackNetworkPlacementSolver extends BaseSolver13 {
+import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
+class FeedbackNetworkPlacementSolver extends BaseSolver19 {
   static MIN_BODY_GAP = 4;
   index;
   amplifierIds;
@@ -332442,11 +333172,75 @@ function distanceBetweenBoxes(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
-class PullResistorPlacementSolver extends BaseSolver14 {
+import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/switch-pull-resistor-pairs.ts
+function getSwitchPullResistorPairs(index) {
+  const pairs = [];
+  const isHorizontal = (id) => {
+    const ports = index.portsByComponent.get(id);
+    if (ports?.length !== 2)
+      return false;
+    const a = index.port(ports[0]);
+    const b = index.port(ports[1]);
+    return !!a && !!b && Math.abs(a.center.y - b.center.y) < 0.01 && Math.abs(a.center.x - b.center.x) > 0.01;
+  };
+  for (const component of index.components.values()) {
+    if (component.ftype !== "simple_resistor" || component.resistance <= 0)
+      continue;
+    const id = component.source_component_id;
+    const nets = index.twoTerminalNets(id);
+    if (!nets || nets.filter((net) => index.isRail(net)).length !== 1)
+      continue;
+    const rail = nets.find((net) => index.isRail(net));
+    if (index.powerNets.has(rail) && index.groundNets.has(rail))
+      continue;
+    const signal = nets.find((net) => net !== rail);
+    const peers = index.portsByNet.get(signal) ?? [];
+    const switches = peers.filter((port) => {
+      const type = index.components.get(port.source_component_id)?.ftype;
+      return type === "simple_switch" || type === "simple_push_button";
+    });
+    if (switches.length !== 1 || peers.filter((port) => index.components.get(port.source_component_id)?.ftype === "simple_resistor").length !== 1)
+      continue;
+    const signalPort = switches[0];
+    const switchId = signalPort.source_component_id;
+    const switchType = index.components.get(switchId)?.ftype;
+    const switchNets = index.twoTerminalNets(switchId);
+    const otherRail = switchNets?.find((net) => net !== signal);
+    if (!otherRail)
+      continue;
+    const pullDirection = index.powerNets.has(rail) ? "up" : "down";
+    if (pullDirection === "up" ? !index.groundNets.has(otherRail) || index.powerNets.has(otherRail) : !index.powerNets.has(otherRail) || index.groundNets.has(otherRail))
+      continue;
+    if ([id, switchId].some((componentId) => index.portsByComponent.get(componentId)?.some((port) => port.do_not_connect)))
+      continue;
+    const resistor = index.placement(id);
+    const switchBox = index.placement(switchId);
+    const pin = index.port(signalPort);
+    if (!resistor || !switchBox || !pin || !index.sameLocalScope(resistor, switchBox))
+      continue;
+    pairs.push({
+      resistor,
+      switchBox,
+      signalPort,
+      signalSchY: pin.center.y,
+      pullDirection,
+      horizontalPushbutton: switchType === "simple_push_button" && isHorizontal(id) && isHorizontal(switchId)
+    });
+  }
+  return pairs;
+}
+function getHorizontalPushbuttonComponentIds(index) {
+  return new Set(getSwitchPullResistorPairs(index).flatMap((pair) => pair.horizontalPushbutton ? [pair.resistor.sourceComponentId, pair.switchBox.sourceComponentId] : []));
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
+class PullResistorPlacementSolver extends BaseSolver20 {
   static MIN_WRONG_SIDE_GAP = 1.5;
   index;
   resistorIds;
+  horizontalPushbuttonComponentIds;
   issues;
   currentIndex = 0;
   constructor({
@@ -332456,6 +333250,7 @@ class PullResistorPlacementSolver extends BaseSolver14 {
     super();
     this.issues = issues;
     this.index = new PlacementNetworkIndex(ctx);
+    this.horizontalPushbuttonComponentIds = getHorizontalPushbuttonComponentIds(this.index);
     this.resistorIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_resistor" && component.resistance > 0).map((component) => component.source_component_id);
     this.solved = this.resistorIds.length === 0;
   }
@@ -332464,6 +333259,8 @@ class PullResistorPlacementSolver extends BaseSolver14 {
     this.solved = this.currentIndex >= this.resistorIds.length;
     if (!id)
       return;
+    if (this.horizontalPushbuttonComponentIds.has(id))
+      return;
     const index = this.index;
     const resistor = index.placement(id);
     const nets = index.twoTerminalNets(id);
@@ -332539,14 +333336,15 @@ class PullResistorPlacementSolver extends BaseSolver14 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentRailOrientationSolver/TwoPinComponentRailOrientationSolver.ts
-import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
-class TwoPinComponentRailOrientationSolver extends BaseSolver15 {
+import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
+class TwoPinComponentRailOrientationSolver extends BaseSolver21 {
   static EPSILON = 0.01;
   index;
   powerNets;
   groundNets;
   positiveVoltageNets = new Set;
   componentIds;
+  horizontalPushbuttonComponentIds;
   issues;
   currentIndex = 0;
   constructor({
@@ -332556,6 +333354,7 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver15 {
     super();
     this.issues = issues;
     this.index = new PlacementNetworkIndex(ctx);
+    this.horizontalPushbuttonComponentIds = getHorizontalPushbuttonComponentIds(this.index);
     this.powerNets = new Set(this.index.powerNets);
     this.groundNets = new Set(this.index.groundNets);
     for (const element of ctx.circuitJson) {
@@ -332579,10 +333378,13 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver15 {
       return;
     const index = this.index;
     const component = index.placement(id);
+    const sourceComponent = index.components.get(id);
     const nets = index.twoTerminalNets(id);
     if (!component || !nets)
       return;
-    if (index.components.get(id)?.ftype === "simple_inductor" && !nets.some((net) => this.groundNets.has(net)))
+    if (sourceComponent?.ftype === "simple_inductor" && !nets.some((net) => this.groundNets.has(net)))
+      return;
+    if (sourceComponent?.ftype === "simple_diode" && nets.every((net) => this.powerNets.has(net)))
       return;
     if (nets.some((net) => this.powerNets.has(net) && this.groundNets.has(net)))
       return;
@@ -332617,6 +333419,8 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver15 {
     const horizontal = Math.abs(railPort.center.y - otherPort.center.y) <= TwoPinComponentRailOrientationSolver.EPSILON && Math.abs(railPort.center.x - otherPort.center.x) > TwoPinComponentRailOrientationSolver.EPSILON && (railPort.facing_direction === "left" && otherPort.facing_direction === "right" || railPort.facing_direction === "right" && otherPort.facing_direction === "left");
     if (!horizontal)
       return;
+    if (this.horizontalPushbuttonComponentIds.has(id))
+      return;
     const suggestedRailFacingDirection = railType === "power" ? "up" : "down";
     const deltaSchRotation = railPort.facing_direction === "left" === (railType === "power") ? -90 : 90;
     this.issues.push({
@@ -332648,8 +333452,8 @@ function getSchematicBoxComponentIds(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver16 {
+import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver22 {
   params;
   MESSAGE = "Inner labels are colliding. Increase the schWidth or schHeight.";
   PIN_LABEL_EDGE_PADDING = 0.1;
@@ -332846,8 +333650,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver16 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
-import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver17 {
+import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver23 {
   params;
   placements;
   firstIndex = 0;
@@ -332966,8 +333770,8 @@ class SchematicBoxOverlapSolver extends BaseSolver17 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver18 {
+import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver24 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
@@ -333147,8 +333951,8 @@ class SchematicBoxTooWideSolver extends BaseSolver18 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver19 {
+import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver25 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
   PIN_NAME_CHARACTER_WIDTH = 0.095;
@@ -333204,7 +334008,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver19 {
           continue;
         const measuredPadding = this.getPinPaddingToEdge(schematicBox, outerPin, edgeSide);
         const maxAllowedPadding = useLabelAwareMaxPadding ? this.getMaxAllowedPinPadding(pinSpacing, edgeSide, maxLabelLengthBySide) : pinSpacing;
-        if (!this.exceedsMaxAllowedGap(measuredPadding, maxAllowedPadding))
+        if (!this.exceedsMaxAllowedGap(measuredPadding, maxAllowedPadding + pinSpacing))
           continue;
         candidates.push({
           schematicBox,
@@ -333527,6 +334331,47 @@ var buildSolverContext = (circuitJson) => {
   return { circuitJson, componentPlacements };
 };
 
+// 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 {
+  params;
+  constructor(params2) {
+    super();
+    this.params = params2;
+  }
+  _step() {
+    const index = new PlacementNetworkIndex(this.params.ctx);
+    for (const pair of getSwitchPullResistorPairs(index)) {
+      const { resistor, switchBox, signalPort, signalSchY, pullDirection } = pair;
+      if (pair.horizontalPushbutton)
+        continue;
+      const signal = index.connected(signalPort.source_port_id);
+      if (index.portsByNet.get(signal)?.length !== 2)
+        continue;
+      if (signalPort.needs_external_pullup || signalPort.needs_external_pulldown)
+        continue;
+      const wrongSideGap = pullDirection === "up" ? signalSchY - (resistor.schY + resistor.height / 2) : resistor.schY - resistor.height / 2 - signalSchY;
+      if (wrongSideGap <= 1.5)
+        continue;
+      const preferredSide = pullDirection === "up" ? "above" : "below";
+      this.params.issues.push({
+        lineItemType: "PullResistorOnWrongSide",
+        resistorSchematicBox: resistor,
+        hostSchematicBox: switchBox,
+        signalSourcePortId: signalPort.source_port_id,
+        signalPinName: signalPort.name,
+        signalSchY,
+        pullDirection,
+        preferredSide,
+        wrongSideGap,
+        maxRecommendedWrongSideGap: 1.5,
+        message: `place ${resistor.sourceComponentName} ${preferredSide} ${switchBox.sourceComponentName} so the pull-${pullDirection} branch reads toward ${pullDirection === "up" ? "power" : "ground"}`
+      });
+    }
+    this.solved = true;
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/trace-name.ts
 function getTraceName(circuitJson, trace) {
   const sourceTrace = circuitJson.find((e) => e.type === "source_trace" && e.source_trace_id === trace.source_trace_id);
@@ -333679,8 +334524,8 @@ var polygonBounds = (polygons) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
-import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
-class TraceSimplificationSolver extends BaseSolver20 {
+import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver27 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -334038,7 +334883,7 @@ class TraceSimplificationSolver extends BaseSolver20 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/getPowerOrGroundConnectionIds.ts
 import {
@@ -334077,7 +334922,7 @@ function getPowerOrGroundConnectionIds(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-class TwoPinComponentOrientationSolver extends BaseSolver21 {
+class TwoPinComponentOrientationSolver extends BaseSolver28 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -334323,8 +335168,8 @@ class TwoPinComponentOrientationSolver extends BaseSolver21 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver22 {
+import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver29 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -334433,8 +335278,8 @@ class VerboseNetLabelSolver extends BaseSolver22 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
-import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
-class SchematicTextClearanceSolver extends BaseSolver23 {
+import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
+class SchematicTextClearanceSolver extends BaseSolver30 {
   params;
   texts;
   obstacles;
@@ -334585,8 +335430,8 @@ class SchematicTextClearanceSolver extends BaseSolver23 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ResetNetworkGroupingSolver/ResetNetworkGroupingSolver.ts
-import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
-class ResetNetworkGroupingSolver extends BaseSolver24 {
+import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
+class ResetNetworkGroupingSolver extends BaseSolver31 {
   params;
   static MIN_DISTANCE = 6;
   networks;
@@ -334740,6 +335585,50 @@ class ResetNetworkGroupingSolver extends BaseSolver24 {
 var resetPinName = (port) => [port.name, ...port.port_hints ?? []].find((name) => /^N?(RESET|RST)(N|B)?$/.test(name.toUpperCase().replace(/[_\-!~#/]/g, "")));
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
+var solversByIssueType = {
+  MosfetGateNetworkNotGrouped: [MosfetGateNetworkPlacementSolver],
+  FlybackDiodeSeparatedFromRelayCoil: [RelayFlybackDiodePlacementSolver],
+  ComponentOverlap: [SchematicBoxOverlapSolver],
+  SchematicBoxHasALotOfSurroundingWhitespace: [],
+  CapacitorSymbolHorizontal: [
+    CapacitorOrientationSolver,
+    TwoPinComponentRailOrientationSolver
+  ],
+  VerboseSchematicNetLabel: [VerboseNetLabelSolver],
+  PinHeaderSchematicBoxTooWide: [SchematicBoxTooWideSolver],
+  GenericSchematicBoxTooWide: [SchematicBoxTooWideSolver],
+  SchematicBoxInnerLabelCollision: [SchematicBoxInnerLabelCollisionSolver],
+  SchematicPinPaddingToEdgeTooLarge: [SchematicPinPaddingToEdgeSolver],
+  DiodeResistorNotAligned: [DiodeResistorAlignmentSolver],
+  ComponentPinsWouldAlignWithVerticalShift: [ComponentPinAlignmentSolver],
+  TraceCanBeSimplifiedByMovingComponent: [TraceSimplificationSolver],
+  CrystalNotCenteredOverLoadCapacitors: [CrystalLoadCapacitorPlacementSolver],
+  ComponentNetLabelCollision: [ComponentNetLabelCollisionSolver],
+  ComponentBoxNetLabelCollision: [ComponentNetLabelCollisionSolver],
+  NetLabelCollision: [ComponentNetLabelCollisionSolver],
+  FeedbackNetworkNotCompact: [FeedbackNetworkPlacementSolver],
+  PullResistorOnWrongSide: [
+    PullResistorPlacementSolver,
+    SwitchPullResistorPlacementSolver
+  ],
+  SchematicTextCollision: [SchematicTextClearanceSolver],
+  ResetNetworkNotGrouped: [ResetNetworkGroupingSolver],
+  TwoPinComponentCouldBeFlipped: [TwoPinComponentOrientationSolver],
+  TwoPinComponentShouldBeVertical: [TwoPinComponentRailOrientationSolver],
+  TwoPinComponentHasInvertedRails: [TwoPinComponentRailOrientationSolver],
+  DecouplingCapacitorsNotCloseTogether: [DecouplingCapacitorGroupingSolver],
+  ConnectorPositionCausesTraceDetours: [ConnectorPlacementSolver],
+  LowSideTransistorNotAlignedWithLoad: [LowSideTransistorPlacementSolver],
+  UsbSeriesResistorsNotAligned: [UsbSeriesResistorPlacementSolver],
+  CurrentSenseShuntSeparatedFromInputs: [CurrentSenseShuntPlacementSolver],
+  VoltageDividerSupplyResistorBelowGroundResistor: [
+    VoltageDividerPlacementSolver
+  ],
+  RegulatorCapacitorsOnWrongSides: [
+    RegulatorInputOutputCapacitorPlacementSolver
+  ]
+};
+
 class SchematicPlacementPipeline extends BasePipelineSolver2 {
   ctx;
   issues = [];
@@ -334792,6 +335681,9 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     definePipelineStep3("PullResistorPlacementSolver", PullResistorPlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
+    definePipelineStep3("SwitchPullResistorPlacementSolver", SwitchPullResistorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("ComponentNetLabelCollisionSolver", ComponentNetLabelCollisionSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
@@ -334803,15 +335695,42 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     ]),
     definePipelineStep3("LowSideTransistorPlacementSolver", LowSideTransistorPlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("UsbSeriesResistorPlacementSolver", UsbSeriesResistorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("RegulatorInputOutputCapacitorPlacementSolver", RegulatorInputOutputCapacitorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("VoltageDividerPlacementSolver", VoltageDividerPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("CurrentSenseShuntPlacementSolver", CurrentSenseShuntPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("RelayFlybackDiodePlacementSolver", RelayFlybackDiodePlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("MosfetGateNetworkPlacementSolver", MosfetGateNetworkPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
     ])
   ];
+  selectedIssueTypes;
+  constructor(circuitJson, options = {}) {
+    super(circuitJson);
+    if (options.issueTypes !== undefined) {
+      this.selectedIssueTypes = new Set(options.issueTypes);
+      const selectedSolvers = new Set(options.issueTypes.flatMap((type) => solversByIssueType[type]));
+      this.pipelineDef = this.pipelineDef.filter((step) => selectedSolvers.has(step.solverClass));
+    }
+  }
   _setup() {
     this.ctx = buildSolverContext(this.inputProblem);
   }
   getOutput() {
     const railOrientationComponentIds = new Set(this.issues.flatMap((issue) => issue.lineItemType === "TwoPinComponentShouldBeVertical" && issue.schematicBox.schematicComponentId ? [issue.schematicBox.schematicComponentId] : []));
     return {
-      issues: this.issues.filter((issue) => issue.lineItemType !== "CapacitorSymbolHorizontal" || !railOrientationComponentIds.has(issue.schematicBox.schematicComponentId ?? "")),
+      issues: this.issues.filter((issue) => issue.lineItemType !== "CapacitorSymbolHorizontal" || !railOrientationComponentIds.has(issue.schematicBox.schematicComponentId ?? "")).filter((issue) => this.selectedIssueTypes === undefined || this.selectedIssueTypes.has(issue.lineItemType)),
       componentPlacements: this.ctx.componentPlacements
     };
   }
@@ -334854,6 +335773,32 @@ var getRelevantPlacementsForIssues = ({
   };
   for (const issue of issues) {
     switch (issue.lineItemType) {
+      case "MosfetGateNetworkNotGrouped":
+        addPlacement(issue.mosfetSchematicBox);
+        addPlacement(issue.seriesGateResistorSchematicBox);
+        addPlacement(issue.gateSourceResistorSchematicBox);
+        break;
+      case "FlybackDiodeSeparatedFromRelayCoil":
+        addPlacement(issue.relaySchematicBox);
+        addPlacement(issue.diodeSchematicBox);
+        break;
+      case "CurrentSenseShuntSeparatedFromInputs":
+        addPlacement(issue.amplifierSchematicBox);
+        addPlacement(issue.shuntSchematicBox);
+        break;
+      case "VoltageDividerSupplyResistorBelowGroundResistor":
+        addPlacement(issue.supplyResistorSchematicBox);
+        addPlacement(issue.groundResistorSchematicBox);
+        break;
+      case "RegulatorCapacitorsOnWrongSides":
+        addPlacement(issue.regulatorSchematicBox);
+        addPlacement(issue.inputCapacitorSchematicBox);
+        addPlacement(issue.outputCapacitorSchematicBox);
+        break;
+      case "UsbSeriesResistorsNotAligned":
+        addPlacement(issue.positiveResistorSchematicBox);
+        addPlacement(issue.negativeResistorSchematicBox);
+        break;
       case "LowSideTransistorNotAlignedWithLoad":
         addPlacement(issue.transistorSchematicBox);
         addPlacement(issue.loadSchematicBox);
@@ -335027,6 +335972,7 @@ class SchematicPlacementAnalysis {
   }
   getIssueCounts(filter = {}) {
     const counts = {
+      FlybackDiodeSeparatedFromRelayCoil: 0,
       ComponentOverlap: 0,
       SchematicBoxHasALotOfSurroundingWhitespace: 0,
       CapacitorSymbolHorizontal: 0,
@@ -335051,7 +335997,12 @@ class SchematicPlacementAnalysis {
       TwoPinComponentHasInvertedRails: 0,
       DecouplingCapacitorsNotCloseTogether: 0,
       ConnectorPositionCausesTraceDetours: 0,
-      LowSideTransistorNotAlignedWithLoad: 0
+      LowSideTransistorNotAlignedWithLoad: 0,
+      UsbSeriesResistorsNotAligned: 0,
+      RegulatorCapacitorsOnWrongSides: 0,
+      VoltageDividerSupplyResistorBelowGroundResistor: 0,
+      CurrentSenseShuntSeparatedFromInputs: 0,
+      MosfetGateNetworkNotGrouped: 0
     };
     for (const issue of this.getIssues(filter))
       counts[issue.lineItemType]++;
@@ -335072,6 +336023,10 @@ class SchematicPlacementAnalysis {
   }
   schematicIssuesToString(issue) {
     switch (issue.lineItemType) {
+      case "MosfetGateNetworkNotGrouped":
+        return MosfetGateNetworkPlacementSolver.issueToString(issue);
+      case "CurrentSenseShuntSeparatedFromInputs":
+        return CurrentSenseShuntPlacementSolver.issueToString(issue);
       case "ComponentOverlap":
         return SchematicBoxOverlapSolver.issueToString(issue);
       case "CapacitorSymbolHorizontal":
@@ -335114,6 +336069,14 @@ class SchematicPlacementAnalysis {
         return ConnectorPlacementSolver.issueToString(issue);
       case "LowSideTransistorNotAlignedWithLoad":
         return LowSideTransistorPlacementSolver.issueToString(issue);
+      case "FlybackDiodeSeparatedFromRelayCoil":
+        return RelayFlybackDiodePlacementSolver.issueToString(issue);
+      case "VoltageDividerSupplyResistorBelowGroundResistor":
+        return VoltageDividerPlacementSolver.issueToString(issue);
+      case "RegulatorCapacitorsOnWrongSides":
+        return RegulatorInputOutputCapacitorPlacementSolver.issueToString(issue);
+      case "UsbSeriesResistorsNotAligned":
+        return UsbSeriesResistorPlacementSolver.issueToString(issue);
       default:
         return "";
     }
@@ -335171,8 +336134,8 @@ class SchematicPlacementAnalysis {
     ];
   }
 }
-var analyzeSchematicPlacement = (circuitJson) => {
-  const pipeline = new SchematicPlacementPipeline(circuitJson);
+var analyzeSchematicPlacement = (circuitJson, options = {}) => {
+  const pipeline = new SchematicPlacementPipeline(circuitJson, options);
   pipeline.solve();
   const { issues, componentPlacements } = pipeline.getOutput();
   const relevantPlacements = getRelevantPlacementsForIssues({