@tscircuit/cli 0.1.2274 → 0.1.2275

package/dist/cli/main.js

@@ -171749,7 +171749,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.2273";
+var version = "0.1.2274";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -171768,7 +171768,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.46.tgz",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.50.tgz",
     "@tscircuit/circuit-json-util": "^0.0.120",
     "@tscircuit/eval": "0.0.1569",
     "@tscircuit/fake-snippets": "^0.0.182",
@@ -338870,7 +338870,7 @@ var registerCheckRoutingDifficulty = (program) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ParallelDiodeResistorPlacementSolver/ParallelDiodeResistorPlacementSolver.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeCapacitorStagePlacementSolver/DiodeCapacitorStagePlacementSolver.ts
 import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/format.ts
@@ -339035,8 +339035,237 @@ function append2(map, key, value) {
     map.set(key, [value]);
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeCapacitorStagePlacementSolver/DiodeCapacitorStagePlacementSolver.ts
+class DiodeCapacitorStagePlacementSolver extends BaseSolver5 {
+  params;
+  index;
+  nets;
+  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);
+      if (e.type === "source_port") {
+        const net = this.index.connected(e.source_port_id);
+        if (e.requires_ground || e.provides_ground)
+          this.index.groundNets.add(net);
+        if (e.requires_power || e.provides_power)
+          this.index.powerNets.add(net);
+      }
+    }
+    this.nets = [...this.index.portsByNet.keys()];
+    this.solved = this.nets.length === 0;
+  }
+  _step() {
+    const net = this.nets[this.currentIndex++];
+    this.solved = this.currentIndex >= this.nets.length;
+    if (!net || this.index.isRail(net))
+      return;
+    const index = this.index;
+    const junction = index.portsByNet.get(net);
+    if (junction.length !== 3 || new Set(junction.map((p) => p.source_component_id)).size !== 3)
+      return;
+    const parts = junction.map((p) => this.localPart(p.source_component_id));
+    if (parts.some((p) => !p))
+      return;
+    const diodes = parts.filter((p) => p.component.ftype === "simple_diode");
+    const capacitors = parts.filter((p) => p.component.ftype === "simple_capacitor");
+    if (diodes.length !== 2 || capacitors.length !== 1)
+      return;
+    const capacitor = capacitors[0];
+    const first = diodes[0];
+    const second = diodes[1];
+    if (![first, second].every((p) => index.sameLocalScope(capacitor.placement, p.placement)))
+      return;
+    const otherNet = (part) => part.nets.find((n) => n !== net);
+    const diodeNets = [otherNet(first), otherNet(second)];
+    const grounds = diodeNets.filter((n) => index.groundNets.has(n));
+    if (grounds.length !== 1)
+      return;
+    const ground = grounds[0];
+    const branchNet = diodeNets.find((n) => n !== ground);
+    const capacitorNet = otherNet(capacitor);
+    if (capacitorNet === branchNet || capacitorNet === ground || index.isRail(capacitorNet))
+      return;
+    const bankIds = new Set((index.portsByNet.get(branchNet) ?? []).filter((p) => index.components.get(p.source_component_id)?.ftype === "simple_capacitor").map((p) => p.source_component_id));
+    const groundedBank = [...bankIds].filter((id) => index.twoTerminalNets(id)?.includes(ground));
+    if (!groundedBank.length || groundedBank.some((id) => {
+      const part = this.localPart(id);
+      return !part || !index.sameLocalScope(capacitor.placement, part.placement);
+    }))
+      return;
+    const placements = [capacitor.placement, first.placement, second.placement];
+    const pins = junction.map((p) => index.port(p));
+    const maxJunctionPinDistance = Math.max(...pins.flatMap((a, i) => pins.slice(i + 1).map((b) => Math.hypot(a.center.x - b.center.x, a.center.y - b.center.y))));
+    const maxRecommendedJunctionPinDistance = Math.max(4, ...placements.map((p) => 3 * Math.max(p.width, p.height)));
+    if (maxJunctionPinDistance <= maxRecommendedJunctionPinDistance)
+      return;
+    const names = placements.map((p) => p.sourceComponentName || "component");
+    this.params.issues.push({
+      lineItemType: "DiodeCapacitorJunctionTooSpreadOut",
+      capacitorSchematicBox: capacitor.placement,
+      diodeSchematicBoxes: [first.placement, second.placement],
+      maxJunctionPinDistance,
+      maxRecommendedJunctionPinDistance,
+      message: `Bring ${names.join(", ")} closer together so their shared junction can be read as one local diode-capacitor stage. Preserve pin connections, leave room for labels, and reroute affected traces.`
+    });
+  }
+  localPart(id) {
+    const component = this.index.components.get(id);
+    const placement = this.index.placement(id);
+    const ports = this.index.portsByComponent.get(id);
+    const nets = this.index.twoTerminalNets(id);
+    if (!component || !placement || !nets || this.unpopulated.has(id) || ports?.length !== 2 || ![placement.width, placement.height].every((n) => Number.isFinite(n) && n > 0) || component.ftype === "simple_capacitor" && (!Number.isFinite(component.capacitance) || component.capacitance <= 0) || 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 { component, placement, ports, nets };
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "capacitorName", issue.capacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "diodeNames", issue.diodeSchematicBoxes.map((p) => p.sourceComponentName).join(","));
+    addAttr(attrs, "maxJunctionPinDistance", issue.maxJunctionPinDistance);
+    addAttr(attrs, "maxRecommendedJunctionPinDistance", issue.maxRecommendedJunctionPinDistance);
+    addAttr(attrs, "message", issue.message);
+    return `<DiodeCapacitorJunctionTooSpreadOut ${attrs.join(" ")} />`;
+  }
+}
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ParallelRcPlacementSolver/ParallelRcPlacementSolver.ts
+import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+class ParallelRcPlacementSolver extends BaseSolver6 {
+  params;
+  index;
+  resistorIds;
+  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);
+      if (element.type === "source_port") {
+        const net = this.index.connected(element.source_port_id);
+        if (element.requires_ground || element.provides_ground)
+          this.index.groundNets.add(net);
+        if (element.requires_power || element.provides_power || element.requires_voltage !== undefined || element.provides_voltage !== undefined)
+          this.index.powerNets.add(net);
+      }
+    }
+    this.resistorIds = [...this.index.components.values()].filter((c) => c.ftype === "simple_resistor").map((c) => c.source_component_id);
+    this.solved = this.resistorIds.length === 0;
+  }
+  _step() {
+    const resistorId = this.resistorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.resistorIds.length;
+    const index = this.index;
+    const resistor = index.components.get(resistorId);
+    const nets = index.twoTerminalNets(resistorId);
+    if (resistor?.ftype !== "simple_resistor" || !Number.isFinite(resistor.resistance) || resistor.resistance <= 0 || !nets)
+      return;
+    const grounds = nets.filter((net) => index.groundNets.has(net) && !index.powerNets.has(net));
+    if (grounds.length !== 1)
+      return;
+    const ground = grounds[0];
+    const signal = nets.find((net) => net !== ground);
+    if (index.isRail(signal))
+      return;
+    const members = index.portsByNet.get(signal) ?? [];
+    if (members.length !== 3 || members.some((p) => p.do_not_connect))
+      return;
+    const capPort = members.find((p) => index.components.get(p.source_component_id)?.ftype === "simple_capacitor");
+    const chipPort = members.find((p) => index.components.get(p.source_component_id)?.ftype === "simple_chip");
+    if (!capPort || !chipPort)
+      return;
+    const capacitorId = capPort.source_component_id;
+    const capacitor = index.components.get(capacitorId);
+    if (capacitor?.ftype !== "simple_capacitor" || !Number.isFinite(capacitor.capacitance) || capacitor.capacitance <= 0 || !index.twoTerminalNets(capacitorId)?.includes(ground))
+      return;
+    const hostId = chipPort.source_component_id;
+    if ((index.portsByComponent.get(hostId)?.length ?? 0) < 3)
+      return;
+    const r = index.placement(resistorId), c = index.placement(capacitorId), host = index.placement(hostId);
+    if (!r || !c || !host || [resistorId, capacitorId, hostId].some((id) => this.unpopulated.has(id)))
+      return;
+    if ([r, c].some((box) => box.schematicSheetId !== host.schematicSheetId || box.subcircuitId !== host.subcircuitId))
+      return;
+    if ([r, c, host].some((box) => ![box.schX, box.schY, box.width, box.height].every(Number.isFinite) || box.width <= 0 || box.height <= 0))
+      return;
+    const chipPin = index.port(chipPort);
+    if (!chipPin || chipPin.schematic_sheet_id !== host.schematicSheetId)
+      return;
+    const resistorPins = this.pins(resistorId, signal, ground, r);
+    const capacitorPins = this.pins(capacitorId, signal, ground, c);
+    if (!resistorPins || !capacitorPins)
+      return;
+    const rAxis = pinAxis(...resistorPins), cAxis = pinAxis(...capacitorPins);
+    if (!rAxis || !cAxis)
+      return;
+    if (Math.abs(r.schX - c.schX) < (r.width + c.width) / 2 && Math.abs(r.schY - c.schY) < (r.height + c.height) / 2)
+      return;
+    let reason;
+    if (rAxis !== cAxis)
+      reason = "different_axes";
+    else {
+      const axis = rAxis === "horizontal" ? "x" : "y";
+      const a = resistorPins.map((p) => p.center[axis]), b = capacitorPins.map((p) => p.center[axis]);
+      if ((a[1] - a[0]) * (b[1] - b[0]) < 0)
+        reason = "crossed_connections";
+      else {
+        const overlap = Math.min(Math.max(...a), Math.max(...b)) - Math.max(Math.min(...a), Math.min(...b));
+        if (overlap > 0.01)
+          return;
+        reason = "staggered";
+      }
+    }
+    this.params.issues.push({
+      lineItemType: "ParallelRcNotAligned",
+      resistorSchematicBox: r,
+      capacitorSchematicBox: c,
+      chipSourcePortId: chipPort.source_port_id,
+      reason,
+      message: `Draw ${r.sourceComponentName || "the resistor"} and ${c.sourceComponentName || "the capacitor"} as adjacent parallel branches with their shared nets at matching ends. Preserve all pin connections and capacitor polarity, leave room for labels, and reroute affected wires.`
+    });
+  }
+  pins(id, signal, ground, box) {
+    const ports = this.index.portsByComponent.get(id) ?? [];
+    if (ports.length !== 2 || ports.some((p) => p.do_not_connect))
+      return;
+    const pins = [signal, ground].map((net) => {
+      const source = ports.find((p) => this.index.connected(p.source_port_id) === net);
+      return source && this.index.port(source);
+    });
+    const [first, second] = pins;
+    if (!first || !second || pins.some((p) => p.schematic_sheet_id !== box.schematicSheetId || !Number.isFinite(p.center.x) || !Number.isFinite(p.center.y)))
+      return;
+    return [first, second];
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "resistorComponentName", issue.resistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "capacitorComponentName", issue.capacitorSchematicBox.sourceComponentName);
+    addAttr(attrs, "reason", issue.reason);
+    addAttr(attrs, "message", issue.message);
+    return `<ParallelRcNotAligned ${attrs.join(" ")} />`;
+  }
+}
+function pinAxis(a, b) {
+  const directions = new Set([a.facing_direction, b.facing_direction]);
+  if (directions.has("left") && directions.has("right") && Math.abs(a.center.y - b.center.y) < 0.01 && Math.abs(a.center.x - b.center.x) > 0.01)
+    return "horizontal";
+  if (directions.has("up") && directions.has("down") && Math.abs(a.center.x - b.center.x) < 0.01 && Math.abs(a.center.y - b.center.y) > 0.01)
+    return "vertical";
+}
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ParallelDiodeResistorPlacementSolver/ParallelDiodeResistorPlacementSolver.ts
-class ParallelDiodeResistorPlacementSolver extends BaseSolver5 {
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+class ParallelDiodeResistorPlacementSolver extends BaseSolver7 {
   params;
   banks = [];
   bankIndex = 0;
@@ -339063,7 +339292,7 @@ class ParallelDiodeResistorPlacementSolver extends BaseSolver5 {
       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);
+        member.axis = pinAxis2(first, second);
       }
       const key = JSON.stringify(nets);
       const scopes = byNets.get(key) ?? [];
@@ -339125,19 +339354,242 @@ class ParallelDiodeResistorPlacementSolver extends BaseSolver5 {
     return `<ParallelDiodeResistorNotAligned ${attrs.join(" ")} />`;
   }
 }
-function pinAxis(first, second) {
+function pinAxis2(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/SeriesLedChainPlacementSolver/SeriesLedChainPlacementSolver.ts
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+class SeriesLedChainPlacementSolver extends BaseSolver8 {
+  params;
+  index;
+  ledIds;
+  visited = new Set;
+  unpopulated = new Set;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.index = new PlacementNetworkIndex(params2.ctx);
+    this.ledIds = new Set([...this.index.components.values()].filter((c) => c.ftype === "simple_led").map((c) => c.source_component_id));
+    for (const e of params2.ctx.circuitJson)
+      if (e.type === "pcb_component" && e.do_not_place)
+        this.unpopulated.add(e.source_component_id);
+    this.solved = this.ledIds.size === 0;
+  }
+  _step() {
+    const start = [...this.ledIds].find((id) => !this.visited.has(id));
+    if (!start) {
+      this.solved = true;
+      return;
+    }
+    const group = [start];
+    this.visited.add(start);
+    const neighbors = new Map;
+    for (let i = 0;i < group.length; i++) {
+      const id = group[i];
+      const adjacent = new Set;
+      for (const port of this.index.portsByComponent.get(id) ?? []) {
+        for (const other of this.index.portsByNet.get(this.index.connected(port.source_port_id)) ?? []) {
+          const otherId = other.source_component_id;
+          if (otherId === id || !this.ledIds.has(otherId))
+            continue;
+          adjacent.add(otherId);
+          if (!this.visited.has(otherId)) {
+            this.visited.add(otherId);
+            group.push(otherId);
+          }
+        }
+      }
+      neighbors.set(id, adjacent);
+    }
+    this.solved = this.visited.size === this.ledIds.size;
+    if (group.length < 3)
+      return;
+    const ends = group.filter((id) => neighbors.get(id).size === 1);
+    if (ends.length !== 2 || group.some((id) => neighbors.get(id).size > 2))
+      return;
+    const ordered = [ends.sort()[0]];
+    while (ordered.length < group.length) {
+      const last = ordered.at(-1);
+      const previous = ordered.at(-2);
+      const next = [...neighbors.get(last)].find((id) => id !== previous);
+      if (!next || ordered.includes(next))
+        return;
+      ordered.push(next);
+    }
+    const boxes = ordered.map((id) => this.index.placement(id));
+    if (boxes.some((box) => !box))
+      return;
+    const placements = boxes.filter((box) => box !== undefined);
+    if (placements.some((box) => !this.index.sameLocalScope(placements[0], box) || ![box.schX, box.schY, box.width, box.height].every(Number.isFinite) || box.width <= 0 || box.height <= 0))
+      return;
+    for (const id of ordered) {
+      const ports = this.index.portsByComponent.get(id) ?? [];
+      if (this.unpopulated.has(id) || !this.index.twoTerminalNets(id) || ports.some((p) => p.do_not_connect))
+        return;
+      const placement = this.index.placement(id);
+      for (const port of ports) {
+        const pin = this.index.port(port);
+        if (!pin || pin.schematic_sheet_id !== placement.schematicSheetId || !Number.isFinite(pin.center.x) || !Number.isFinite(pin.center.y) || !pin.facing_direction)
+          return;
+      }
+    }
+    const backtrackingConnections = [];
+    for (let i = 1;i < ordered.length; i++) {
+      const aId = ordered[i - 1], bId = ordered[i];
+      const aNets = this.index.twoTerminalNets(aId);
+      const common = this.index.twoTerminalNets(bId).filter((net) => aNets.includes(net));
+      if (common.length !== 1 || this.index.isRail(common[0]))
+        return;
+      const ports = this.index.portsByNet.get(common[0]) ?? [];
+      if (ports.length !== 2)
+        return;
+      const aSource = ports.find((p) => p.source_component_id === aId);
+      const bSource = ports.find((p) => p.source_component_id === bId);
+      const a = this.index.port(aSource), b = this.index.port(bSource);
+      const dx = b.center.x - a.center.x, dy = b.center.y - a.center.y;
+      const pinDistance = Math.hypot(dx, dy);
+      const span = Math.max(placements[i - 1].width, placements[i - 1].height, placements[i].width, placements[i].height);
+      if (pinDistance > Math.max(4, 3 * span) && (outwardDistance(a, dx, dy) < -span || outwardDistance(b, -dx, -dy) < -span)) {
+        backtrackingConnections.push({
+          firstSourcePortId: aSource.source_port_id,
+          secondSourcePortId: bSource.source_port_id,
+          pinDistance
+        });
+      }
+    }
+    if (!backtrackingConnections.length)
+      return;
+    const names = placements.map((box) => box.sourceComponentName || "LED").join(", ");
+    this.params.issues.push({
+      lineItemType: "SeriesLedChainNotOrdered",
+      ledSchematicBoxes: placements,
+      backtrackingConnections,
+      message: `Arrange ${names} in their connected series order so adjacent LEDs do not require long connections behind their pins. Move or rotate the symbols while preserving anode/cathode connections; allow space for labels and reroute affected traces. A horizontal, vertical, or clearly connected folded chain is acceptable.`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "ledComponents", issue.ledSchematicBoxes.map((box) => box.sourceComponentName).join(","));
+    addAttr(attrs, "backtrackingConnections", issue.backtrackingConnections.length);
+    addAttr(attrs, "maxPinDistance", Math.max(...issue.backtrackingConnections.map((link) => link.pinDistance)));
+    addAttr(attrs, "message", issue.message);
+    return `<SeriesLedChainNotOrdered ${attrs.join(" ")} />`;
+  }
+}
+function outwardDistance(pin, dx, dy) {
+  switch (pin.facing_direction) {
+    case "left":
+      return -dx;
+    case "right":
+      return dx;
+    case "up":
+      return dy;
+    case "down":
+      return -dy;
+    default:
+      return 0;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ChipPinResistorPlacementSolver/ChipPinResistorPlacementSolver.ts
+import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
+class ChipPinResistorPlacementSolver extends BaseSolver9 {
+  params;
+  index;
+  resistorIds;
+  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.resistorIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_resistor").map((component) => component.source_component_id);
+    this.solved = this.resistorIds.length === 0;
+  }
+  _step() {
+    const resistorId = this.resistorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.resistorIds.length;
+    if (!resistorId || this.unpopulated.has(resistorId))
+      return;
+    const index = this.index;
+    const component = index.components.get(resistorId);
+    const resistor = index.placement(resistorId);
+    const nets = index.twoTerminalNets(resistorId);
+    const resistorPorts = index.portsByComponent.get(resistorId) ?? [];
+    if (component?.ftype !== "simple_resistor" || !Number.isFinite(component.resistance) || component.resistance <= 0 || !resistor || !nets || resistorPorts.some((p) => p.do_not_connect))
+      return;
+    const grounds = nets.filter((net) => index.groundNets.has(net) && !index.powerNets.has(net));
+    if (grounds.length !== 1)
+      return;
+    const signal = nets.find((net) => net !== grounds[0]);
+    if (index.isRail(signal))
+      return;
+    const members = index.portsByNet.get(signal) ?? [];
+    if (members.length !== 2)
+      return;
+    const chipPort = members.find((p) => p.source_component_id !== resistorId);
+    const resistorPort = members.find((p) => p.source_component_id === resistorId);
+    if (!chipPort || !resistorPort || chipPort.do_not_connect || hasSupplyRole(chipPort))
+      return;
+    const hostId = chipPort.source_component_id;
+    const host = index.placement(hostId);
+    if (index.components.get(hostId)?.ftype !== "simple_chip" || (index.portsByComponent.get(hostId)?.length ?? 0) < 3 || this.unpopulated.has(hostId) || !host || !index.sameLocalScope(host, resistor))
+      return;
+    const chipPin = index.port(chipPort);
+    const resistorPin = index.port(resistorPort);
+    if (!chipPin || !resistorPin || [chipPin, resistorPin].some((pin) => pin.schematic_sheet_id !== host.schematicSheetId || !Number.isFinite(pin.center.x) || !Number.isFinite(pin.center.y)) || [host, resistor].some((box) => ![box.schX, box.schY, box.width, box.height].every(Number.isFinite) || box.width <= 0 || box.height <= 0))
+      return;
+    const side = chipPin.facing_direction;
+    if (!side)
+      return;
+    const horizontal = side === "left" || side === "right";
+    const sign = side === "left" || side === "down" ? -1 : 1;
+    const oppositeDistance = -sign * (horizontal ? resistor.schX - host.schX : resistor.schY - host.schY);
+    const halfBodies = horizontal ? (host.width + resistor.width) / 2 : (host.height + resistor.height) / 2;
+    if (oppositeDistance <= halfBodies + 0.2)
+      return;
+    const pinDistance = Math.hypot(chipPin.center.x - resistorPin.center.x, chipPin.center.y - resistorPin.center.y);
+    const maxRecommendedPinDistance = Math.max(4, 3 * Math.max(resistor.width, resistor.height));
+    if (pinDistance <= maxRecommendedPinDistance)
+      return;
+    this.params.issues.push({
+      lineItemType: "ResistorSeparatedFromChipPin",
+      hostSchematicBox: host,
+      resistorSchematicBox: resistor,
+      chipSourcePortId: chipPort.source_port_id,
+      resistorSourcePortId: resistorPort.source_port_id,
+      pinDistance,
+      maxRecommendedPinDistance,
+      message: `Place ${resistor.sourceComponentName || "resistor"} beside its connected pin on the ${side} side of ${host.sourceComponentName || "chip"} so the resistor-to-ground branch 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, "resistorName", issue.resistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "pinDistance", issue.pinDistance);
+    addAttr(attrs, "maxRecommendedPinDistance", issue.maxRecommendedPinDistance);
+    addAttr(attrs, "message", issue.message);
+    return `<ResistorSeparatedFromChipPin ${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/RailPathVisibilitySolver/RailPathVisibilitySolver.ts
-import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver10 } 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 {
+class RailPathVisibilitySolver extends BaseSolver10 {
   index;
   nodes = new Map;
   starts = [];
@@ -339356,8 +339808,8 @@ function pointOnSegment(p, a, b) {
 }
 
 // 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 {
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+class ChipPinPairCapacitorPlacementSolver extends BaseSolver11 {
   params;
   index;
   capacitorIds;
@@ -339383,7 +339835,7 @@ class ChipPinPairCapacitorPlacementSolver extends BaseSolver7 {
     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)))
+    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 || hasSupplyRole2(port)))
       return;
     const peers = nets.map((net) => {
       const members = index.portsByNet.get(net) ?? [];
@@ -339392,7 +339844,7 @@ class ChipPinPairCapacitorPlacementSolver extends BaseSolver7 {
       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))
+    if (!first || !second || first.source_component_id !== second.source_component_id || first.do_not_connect || second.do_not_connect || hasSupplyRole2(first) || hasSupplyRole2(second))
       return;
     const hostId = first.source_component_id;
     const host = index.placement(hostId);
@@ -339443,13 +339895,13 @@ class ChipPinPairCapacitorPlacementSolver extends BaseSolver7 {
     return `<CapacitorSeparatedFromChipPins ${attrs.join(" ")} />`;
   }
 }
-function hasSupplyRole(port) {
+function hasSupplyRole2(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 {
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+class PiFilterPlacementSolver extends BaseSolver12 {
   params;
   index;
   inductorIds;
@@ -339546,8 +339998,8 @@ class PiFilterPlacementSolver extends BaseSolver8 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/MosfetGateNetworkPlacementSolver/MosfetGateNetworkPlacementSolver.ts
-import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
-class MosfetGateNetworkPlacementSolver extends BaseSolver9 {
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+class MosfetGateNetworkPlacementSolver extends BaseSolver13 {
   params;
   index;
   mosfetIds;
@@ -339652,8 +340104,8 @@ function bodyGap(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/RelayFlybackDiodePlacementSolver/RelayFlybackDiodePlacementSolver.ts
-import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
-class RelayFlybackDiodePlacementSolver extends BaseSolver10 {
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+class RelayFlybackDiodePlacementSolver extends BaseSolver14 {
   params;
   index;
   relayIds;
@@ -339782,10 +340234,10 @@ function hasHint(port, pattern) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CurrentSenseShuntPlacementSolver/CurrentSenseShuntPlacementSolver.ts
-import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
 var EPSILON3 = 0.01;
 
-class CurrentSenseShuntPlacementSolver extends BaseSolver11 {
+class CurrentSenseShuntPlacementSolver extends BaseSolver15 {
   params;
   index;
   hostIds;
@@ -339935,8 +340387,8 @@ function onSegment4(point, from, to) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VoltageDividerPlacementSolver/VoltageDividerPlacementSolver.ts
-import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
-class VoltageDividerPlacementSolver extends BaseSolver12 {
+import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
+class VoltageDividerPlacementSolver extends BaseSolver16 {
   params;
   index;
   positiveNets = new Set;
@@ -340032,8 +340484,8 @@ class VoltageDividerPlacementSolver extends BaseSolver12 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/RegulatorInputOutputCapacitorPlacementSolver/RegulatorInputOutputCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
-class RegulatorInputOutputCapacitorPlacementSolver extends BaseSolver13 {
+import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
+class RegulatorInputOutputCapacitorPlacementSolver extends BaseSolver17 {
   params;
   index;
   hostIds;
@@ -340153,7 +340605,7 @@ function portRole(port) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ConnectorPlacementSolver/ConnectorPlacementSolver.ts
-import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
 function centeredRect(cx, cy, w, h) {
@@ -340183,7 +340635,7 @@ 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 BaseSolver14 {
+class ConnectorPlacementSolver extends BaseSolver18 {
   params;
   constructor(params2) {
     super();
@@ -340369,8 +340821,8 @@ function segmentCrossesBox(a, b, box) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/LowSideTransistorPlacementSolver/LowSideTransistorPlacementSolver.ts
-import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
-class LowSideTransistorPlacementSolver extends BaseSolver15 {
+import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
+class LowSideTransistorPlacementSolver extends BaseSolver19 {
   index;
   positiveNets = new Set;
   transistorIds;
@@ -340490,8 +340942,8 @@ class LowSideTransistorPlacementSolver extends BaseSolver15 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/UsbSeriesResistorPlacementSolver/UsbSeriesResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
-class UsbSeriesResistorPlacementSolver extends BaseSolver16 {
+import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+class UsbSeriesResistorPlacementSolver extends BaseSolver20 {
   params;
   index;
   hostIds;
@@ -340611,7 +341063,7 @@ function usbRole(port) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/graphics.ts
 import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
@@ -340646,7 +341098,7 @@ function visualizeCircuitJson(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-class CapacitorOrientationSolver extends BaseSolver17 {
+class CapacitorOrientationSolver extends BaseSolver21 {
   static EPSILON = 0.01;
   static ORIENTATION_MESSAGE = 'Use schOrientation="vertical" on this capacitor to fix the symbol orientation';
   ctx;
@@ -340791,8 +341243,8 @@ class CapacitorOrientationSolver extends BaseSolver17 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DecouplingCapacitorGroupingSolver/DecouplingCapacitorGroupingSolver.ts
-import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
-class DecouplingCapacitorGroupingSolver extends BaseSolver18 {
+import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
+class DecouplingCapacitorGroupingSolver extends BaseSolver22 {
   params;
   static MIN_BODY_GAP = 1;
   banks = [];
@@ -340936,8 +341388,8 @@ function getNetLabelBounds(label) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
-class ComponentNetLabelCollisionSolver extends BaseSolver19 {
+import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
+class ComponentNetLabelCollisionSolver extends BaseSolver23 {
   params;
   placements;
   netLabelsByComponentId;
@@ -341261,8 +341713,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver19 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver20 {
+import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver24 {
   static ALIGNMENT_EPSILON = 0.01;
   ctx;
   out;
@@ -341396,8 +341848,8 @@ class ComponentPinAlignmentSolver extends BaseSolver20 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CrystalLoadCapacitorPlacementSolver/CrystalLoadCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
-class CrystalLoadCapacitorPlacementSolver extends BaseSolver21 {
+import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
+class CrystalLoadCapacitorPlacementSolver extends BaseSolver25 {
   static ALIGNMENT_TOLERANCE = 0.1;
   issues;
   networks;
@@ -341557,9 +342009,9 @@ var distance51 = (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 BaseSolver22 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver26 } from "@tscircuit/solver-utils";
 import { getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2 } from "circuit-json-to-connectivity-map";
-class DiodeResistorAlignmentSolver extends BaseSolver22 {
+class DiodeResistorAlignmentSolver extends BaseSolver26 {
   static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
   ctx;
   out;
@@ -341725,8 +342177,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver22 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/FeedbackNetworkPlacementSolver/FeedbackNetworkPlacementSolver.ts
-import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
-class FeedbackNetworkPlacementSolver extends BaseSolver23 {
+import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
+class FeedbackNetworkPlacementSolver extends BaseSolver27 {
   static MIN_BODY_GAP = 4;
   index;
   amplifierIds;
@@ -341811,7 +342263,7 @@ function distanceBetweenBoxes(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/switch-pull-resistor-pairs.ts
 function getSwitchPullResistorPairs(index) {
@@ -341875,7 +342327,7 @@ function getHorizontalPushbuttonComponentIds(index) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-class PullResistorPlacementSolver extends BaseSolver24 {
+class PullResistorPlacementSolver extends BaseSolver28 {
   static MIN_WRONG_SIDE_GAP = 1.5;
   index;
   resistorIds;
@@ -341975,8 +342427,8 @@ class PullResistorPlacementSolver extends BaseSolver24 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentRailOrientationSolver/TwoPinComponentRailOrientationSolver.ts
-import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
-class TwoPinComponentRailOrientationSolver extends BaseSolver25 {
+import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
+class TwoPinComponentRailOrientationSolver extends BaseSolver29 {
   static EPSILON = 0.01;
   index;
   powerNets;
@@ -342291,8 +342743,8 @@ var polygonBounds = (polygons) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver26 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver26 {
+import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver30 {
   params;
   entries;
   placementById;
@@ -342397,8 +342849,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver26 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
-import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver27 {
+import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver31 {
   params;
   placements;
   firstIndex = 0;
@@ -342657,8 +343109,8 @@ function contentsFit(resized, ports, labelBankGap = INNER_LABEL_COLLISION_PADDIN
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver28 {
+import { BaseSolver as BaseSolver32 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver32 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
@@ -342818,8 +343270,8 @@ class SchematicBoxTooWideSolver extends BaseSolver28 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver29 {
+import { BaseSolver as BaseSolver33 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver33 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
   GAP_COMPARISON_EPSILON = 0.000000001;
@@ -343190,8 +343642,8 @@ var buildSolverContext = (circuitJson) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SwitchPullResistorPlacementSolver/SwitchPullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
-class SwitchPullResistorPlacementSolver extends BaseSolver30 {
+import { BaseSolver as BaseSolver34 } from "@tscircuit/solver-utils";
+class SwitchPullResistorPlacementSolver extends BaseSolver34 {
   params;
   constructor(params2) {
     super();
@@ -343260,8 +343712,8 @@ function getTraceName(circuitJson, trace) {
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
 import { calculateElbow as calculateElbow2 } from "calculate-elbow/lib";
-import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
-class TraceSimplificationSolver extends BaseSolver31 {
+import { BaseSolver as BaseSolver35 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver35 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -343619,7 +344071,7 @@ class TraceSimplificationSolver extends BaseSolver31 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-import { BaseSolver as BaseSolver32 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver36 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/getPowerOrGroundConnectionIds.ts
 import {
@@ -343658,7 +344110,7 @@ function getPowerOrGroundConnectionIds(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-class TwoPinComponentOrientationSolver extends BaseSolver32 {
+class TwoPinComponentOrientationSolver extends BaseSolver36 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -343904,8 +344356,8 @@ class TwoPinComponentOrientationSolver extends BaseSolver32 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver33 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver33 {
+import { BaseSolver as BaseSolver37 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver37 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -344014,8 +344466,8 @@ class VerboseNetLabelSolver extends BaseSolver33 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
-import { BaseSolver as BaseSolver34 } from "@tscircuit/solver-utils";
-class SchematicTextClearanceSolver extends BaseSolver34 {
+import { BaseSolver as BaseSolver38 } from "@tscircuit/solver-utils";
+class SchematicTextClearanceSolver extends BaseSolver38 {
   params;
   texts;
   obstacles;
@@ -344167,8 +344619,8 @@ class SchematicTextClearanceSolver extends BaseSolver34 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ResetNetworkGroupingSolver/ResetNetworkGroupingSolver.ts
-import { BaseSolver as BaseSolver35 } from "@tscircuit/solver-utils";
-class ResetNetworkGroupingSolver extends BaseSolver35 {
+import { BaseSolver as BaseSolver39 } from "@tscircuit/solver-utils";
+class ResetNetworkGroupingSolver extends BaseSolver39 {
   params;
   static MIN_DISTANCE = 6;
   networks;
@@ -344323,8 +344775,11 @@ 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 = {
+  SeriesLedChainNotOrdered: [SeriesLedChainPlacementSolver],
   RailPathTooSpreadOut: [RailPathVisibilitySolver],
+  ResistorSeparatedFromChipPin: [ChipPinResistorPlacementSolver],
   CapacitorSeparatedFromChipPins: [ChipPinPairCapacitorPlacementSolver],
+  DiodeCapacitorJunctionTooSpreadOut: [DiodeCapacitorStagePlacementSolver],
   PiFilterComponentsNotGrouped: [PiFilterPlacementSolver],
   MosfetGateNetworkNotGrouped: [MosfetGateNetworkPlacementSolver],
   FlybackDiodeSeparatedFromRelayCoil: [RelayFlybackDiodePlacementSolver],
@@ -344340,6 +344795,7 @@ var solversByIssueType = {
   SchematicBoxInnerLabelCollision: [SchematicBoxInnerLabelCollisionSolver],
   SchematicPinPaddingToEdgeTooLarge: [SchematicPinPaddingToEdgeSolver],
   DiodeResistorNotAligned: [DiodeResistorAlignmentSolver],
+  ParallelRcNotAligned: [ParallelRcPlacementSolver],
   ParallelDiodeResistorNotAligned: [ParallelDiodeResistorPlacementSolver],
   ComponentPinsWouldAlignWithVerticalShift: [ComponentPinAlignmentSolver],
   TraceCanBeSimplifiedByMovingComponent: [TraceSimplificationSolver],
@@ -344374,6 +344830,12 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
   ctx;
   issues = [];
   pipelineDef = [
+    definePipelineStep3("SeriesLedChainPlacementSolver", SeriesLedChainPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("ParallelRcPlacementSolver", ParallelRcPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("ParallelDiodeResistorPlacementSolver", ParallelDiodeResistorPlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
@@ -344455,12 +344917,18 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     definePipelineStep3("RelayFlybackDiodePlacementSolver", RelayFlybackDiodePlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
+    definePipelineStep3("DiodeCapacitorStagePlacementSolver", DiodeCapacitorStagePlacementSolver, (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("ChipPinResistorPlacementSolver", ChipPinResistorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
+    ]),
     definePipelineStep3("ChipPinPairCapacitorPlacementSolver", ChipPinPairCapacitorPlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
     ]),
@@ -344533,10 +345001,23 @@ var getRelevantPlacementsForIssues = ({
   };
   for (const issue of issues) {
     switch (issue.lineItemType) {
+      case "SeriesLedChainNotOrdered":
+        for (const placement of issue.ledSchematicBoxes)
+          addPlacement(placement);
+        break;
+      case "ResistorSeparatedFromChipPin":
+        addPlacement(issue.hostSchematicBox);
+        addPlacement(issue.resistorSchematicBox);
+        break;
       case "CapacitorSeparatedFromChipPins":
         addPlacement(issue.hostSchematicBox);
         addPlacement(issue.capacitorSchematicBox);
         break;
+      case "DiodeCapacitorJunctionTooSpreadOut":
+        addPlacement(issue.capacitorSchematicBox);
+        for (const diode of issue.diodeSchematicBoxes)
+          addPlacement(diode);
+        break;
       case "PiFilterComponentsNotGrouped":
         addPlacement(issue.inductorSchematicBox);
         addPlacement(issue.firstCapacitorSchematicBox);
@@ -344617,6 +345098,10 @@ var getRelevantPlacementsForIssues = ({
           addComponentName(getComponentNameFromPin(pin), issue.schematicSheetId);
         }
         break;
+      case "ParallelRcNotAligned":
+        addPlacement(issue.resistorSchematicBox);
+        addPlacement(issue.capacitorSchematicBox);
+        break;
       case "ParallelDiodeResistorNotAligned":
       case "DiodeResistorNotAligned":
         addPlacement(issue.diodeSchematicBox);
@@ -344757,6 +345242,7 @@ class SchematicPlacementAnalysis {
       SchematicBoxInnerLabelCollision: 0,
       SchematicPinPaddingToEdgeTooLarge: 0,
       DiodeResistorNotAligned: 0,
+      ParallelRcNotAligned: 0,
       ParallelDiodeResistorNotAligned: 0,
       ComponentPinsWouldAlignWithVerticalShift: 0,
       TraceCanBeSimplifiedByMovingComponent: 0,
@@ -344778,10 +345264,13 @@ class SchematicPlacementAnalysis {
       RegulatorCapacitorsOnWrongSides: 0,
       VoltageDividerSupplyResistorBelowGroundResistor: 0,
       CurrentSenseShuntSeparatedFromInputs: 0,
+      DiodeCapacitorJunctionTooSpreadOut: 0,
       PiFilterComponentsNotGrouped: 0,
       MosfetGateNetworkNotGrouped: 0,
       CapacitorSeparatedFromChipPins: 0,
-      RailPathTooSpreadOut: 0
+      ResistorSeparatedFromChipPin: 0,
+      RailPathTooSpreadOut: 0,
+      SeriesLedChainNotOrdered: 0
     };
     for (const issue of this.getIssues(filter))
       counts[issue.lineItemType]++;
@@ -344802,8 +345291,14 @@ class SchematicPlacementAnalysis {
   }
   schematicIssuesToString(issue) {
     switch (issue.lineItemType) {
+      case "SeriesLedChainNotOrdered":
+        return SeriesLedChainPlacementSolver.issueToString(issue);
+      case "ResistorSeparatedFromChipPin":
+        return ChipPinResistorPlacementSolver.issueToString(issue);
       case "CapacitorSeparatedFromChipPins":
         return ChipPinPairCapacitorPlacementSolver.issueToString(issue);
+      case "DiodeCapacitorJunctionTooSpreadOut":
+        return DiodeCapacitorStagePlacementSolver.issueToString(issue);
       case "PiFilterComponentsNotGrouped":
         return PiFilterPlacementSolver.issueToString(issue);
       case "MosfetGateNetworkNotGrouped":
@@ -344825,6 +345320,8 @@ class SchematicPlacementAnalysis {
         return SchematicBoxInnerLabelCollisionSolver.issueToString(issue);
       case "SchematicPinPaddingToEdgeTooLarge":
         return SchematicPinPaddingToEdgeSolver.issueToString(issue);
+      case "ParallelRcNotAligned":
+        return ParallelRcPlacementSolver.issueToString(issue);
       case "ParallelDiodeResistorNotAligned":
         return ParallelDiodeResistorPlacementSolver.issueToString(issue);
       case "DiodeResistorNotAligned":

package/dist/lib/index.js

@@ -69109,7 +69109,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.2273";
+var version = "0.1.2274";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -69128,7 +69128,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.46.tgz",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.50.tgz",
     "@tscircuit/circuit-json-util": "^0.0.120",
     "@tscircuit/eval": "0.0.1569",
     "@tscircuit/fake-snippets": "^0.0.182",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.2274",
+  "version": "0.1.2275",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/cli"
@@ -16,7 +16,7 @@
     "@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.46.tgz",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.50.tgz",
     "@tscircuit/circuit-json-util": "^0.0.120",
     "@tscircuit/eval": "0.0.1569",
     "@tscircuit/fake-snippets": "^0.0.182",