@tscircuit/cli 0.1.2126 → 0.1.2127

package/dist/cli/main.js

@@ -154317,7 +154317,7 @@ var package_default = {
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.24.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.15",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#41260fc05b736c0f3fdc33892b6da0ece40107b9",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.11.tgz",
     "@tscircuit/circuit-json-util": "^0.0.113",
     "@tscircuit/eval": "0.0.1402",
     "@tscircuit/fake-snippets": "^0.0.182",
@@ -331022,8 +331022,129 @@ function segmentCrossesBox(a, b, box) {
   return Math.max(a.x, b.x) > bounds.left && Math.min(a.x, b.x) < bounds.right && Math.max(a.y, b.y) > bounds.bottom && Math.min(a.y, b.y) < bounds.top;
 }
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
+// 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 {
+  index;
+  positiveNets = new Set;
+  transistorIds;
+  issues;
+  currentIndex = 0;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.issues = issues;
+    this.index = new PlacementNetworkIndex(ctx);
+    for (const element of ctx.circuitJson) {
+      if (element.type === "source_net" && element.is_positive_voltage_source)
+        this.positiveNets.add(this.index.connected(element.source_net_id));
+    }
+    this.transistorIds = [...this.index.components.values()].filter((component) => component.ftype === "simple_transistor" && component.transistor_type === "npn").map((component) => component.source_component_id);
+    this.solved = this.transistorIds.length === 0;
+  }
+  _step() {
+    const id = this.transistorIds[this.currentIndex++];
+    this.solved = this.currentIndex >= this.transistorIds.length;
+    if (!id)
+      return;
+    const index = this.index;
+    const transistor = index.placement(id);
+    if (!transistor || index.portsByComponent.get(id)?.length !== 3)
+      return;
+    const base = index.namedPort(id, "base");
+    const collector = index.namedPort(id, "collector");
+    const emitter = index.namedPort(id, "emitter");
+    if (!base || !collector || !emitter)
+      return;
+    const baseNet = index.connected(base.source_port_id);
+    const collectorNet = index.connected(collector.source_port_id);
+    const emitterNet = index.connected(emitter.source_port_id);
+    if (new Set([baseNet, collectorNet, emitterNet]).size !== 3 || !index.groundNets.has(emitterNet) || index.powerNets.has(emitterNet) || index.isRail(baseNet) || index.isRail(collectorNet))
+      return;
+    const basePeers = (index.portsByNet.get(baseNet) ?? []).filter((port) => port.source_component_id !== id);
+    if (basePeers.length !== 1)
+      return;
+    const resistorId = basePeers[0].source_component_id;
+    const resistor = index.components.get(resistorId);
+    const baseResistor = index.placement(resistorId);
+    const resistorNets = index.twoTerminalNets(resistorId);
+    const inputNet = resistorNets?.find((net) => net !== baseNet);
+    if (resistor?.ftype !== "simple_resistor" || resistor.resistance <= 0 || !baseResistor || !index.sameLocalScope(transistor, baseResistor) || !inputNet || index.isRail(inputNet) || inputNet === collectorNet)
+      return;
+    const collectorPeers = (index.portsByNet.get(collectorNet) ?? []).filter((port) => port.source_component_id !== id);
+    const loadPeers = collectorPeers.filter((port) => {
+      const type = index.components.get(port.source_component_id)?.ftype;
+      return type === "simple_chip";
+    });
+    if (loadPeers.length !== 1)
+      return;
+    const loadId = loadPeers[0].source_component_id;
+    const load2 = index.placement(loadId);
+    const loadNets = index.twoTerminalNets(loadId);
+    const supplyNet = loadNets?.find((net) => net !== collectorNet);
+    if (!load2 || !index.sameLocalScope(transistor, load2) || !supplyNet || !this.positiveNets.has(supplyNet) || index.groundNets.has(supplyNet))
+      return;
+    const clampPeers = collectorPeers.filter((port) => port.source_component_id !== loadId);
+    if (clampPeers.length !== 1)
+      return;
+    const clampId = clampPeers[0].source_component_id;
+    const clamp = index.placement(clampId);
+    const anode = index.namedPort(clampId, "anode");
+    const cathode = index.namedPort(clampId, "cathode");
+    if (index.components.get(clampId)?.ftype !== "simple_diode" || !index.twoTerminalNets(clampId) || !anode || !cathode || index.connected(anode.source_port_id) !== collectorNet || index.connected(cathode.source_port_id) !== supplyNet || !clamp || !index.sameLocalScope(transistor, clamp))
+      return;
+    const collectorPin = index.port(collector);
+    const emitterPin = index.port(emitter);
+    const basePin = index.port(base);
+    if (!collectorPin || !emitterPin || !basePin)
+      return;
+    const collectorFacingDirection = collectorPin.facing_direction;
+    const emitterFacingDirection = emitterPin.facing_direction;
+    if (!collectorFacingDirection || !emitterFacingDirection)
+      return;
+    const placementProblems = [];
+    if (transistor.schY >= load2.schY)
+      placementProblems.push("transistor_not_below_load");
+    if (collectorFacingDirection !== "up")
+      placementProblems.push("collector_not_up");
+    if (emitterFacingDirection !== "down")
+      placementProblems.push("emitter_not_down");
+    if (placementProblems.length === 0)
+      return;
+    const name = transistor.sourceComponentName ?? id;
+    const loadName = load2.sourceComponentName ?? loadId;
+    this.issues.push({
+      lineItemType: "LowSideTransistorNotAlignedWithLoad",
+      transistorSchematicBox: transistor,
+      loadSchematicBox: load2,
+      baseResistorSchematicBox: baseResistor,
+      clampDiodeSchematicBox: clamp,
+      collectorSourcePortId: collector.source_port_id,
+      emitterSourcePortId: emitter.source_port_id,
+      collectorFacingDirection,
+      emitterFacingDirection,
+      placementProblems,
+      message: `Arrange ${name} below ${loadName}, with its collector facing up toward the load and emitter facing down toward ground; place ${baseResistor.sourceComponentName ?? resistorId} beside the base. Preserve all pin connections and reroute affected traces.`
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "transistorName", issue.transistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "loadName", issue.loadSchematicBox.sourceComponentName);
+    addAttr(attrs, "baseResistorName", issue.baseResistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "clampDiodeName", issue.clampDiodeSchematicBox.sourceComponentName);
+    addAttr(attrs, "placementProblems", issue.placementProblems.join(","));
+    addAttr(attrs, "collectorFacingDirection", issue.collectorFacingDirection);
+    addAttr(attrs, "emitterFacingDirection", issue.emitterFacingDirection);
+    addAttr(attrs, "message", issue.message);
+    return `<LowSideTransistorNotAlignedWithLoad ${attrs.join(" ")} />`;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/graphics.ts
 import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
@@ -331058,7 +331179,8 @@ function visualizeCircuitJson(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-class CapacitorOrientationSolver extends BaseSolver6 {
+class CapacitorOrientationSolver extends BaseSolver7 {
+  static EPSILON = 0.01;
   static ORIENTATION_MESSAGE = 'Use schOrientation="vertical" on this capacitor to fix the symbol orientation';
   ctx;
   out;
@@ -331163,12 +331285,32 @@ class CapacitorOrientationSolver extends BaseSolver6 {
       return;
     if (this.feedbackCapacitorIds.has(placement.sourceComponentId))
       return;
+    if (this.isInlineWithHorizontalTraces(placement.schematicComponentId))
+      return;
     return {
       lineItemType: "CapacitorSymbolHorizontal",
       schematicBox: this.createIssuePlacement(placement),
       message: CapacitorOrientationSolver.ORIENTATION_MESSAGE
     };
   }
+  isInlineWithHorizontalTraces(schematicComponentId) {
+    const ports = this.ctx.circuitJson.filter((element) => element.type === "schematic_port" && element.schematic_component_id === schematicComponentId);
+    if (ports.length !== 2)
+      return false;
+    const traces = ports.map((port) => this.getOutwardHorizontalTrace(port));
+    return traces.every((trace) => trace !== undefined) && traces.some((trace) => trace !== undefined && trace.edges.every((edge) => Math.abs(edge.from.y - edge.to.y) <= CapacitorOrientationSolver.EPSILON));
+  }
+  getOutwardHorizontalTrace(port) {
+    if (port.facing_direction !== "left" && port.facing_direction !== "right")
+      return;
+    return this.ctx.circuitJson.find((element) => element.type === "schematic_trace" && element.schematic_sheet_id === port.schematic_sheet_id && element.edges.some((edge) => {
+      const other = this.pointsEqual(edge.from, port.center) ? edge.to : this.pointsEqual(edge.to, port.center) ? edge.from : undefined;
+      return other !== undefined && Math.abs(other.y - port.center.y) <= CapacitorOrientationSolver.EPSILON && (port.facing_direction === "left" ? other.x < port.center.x - CapacitorOrientationSolver.EPSILON : other.x > port.center.x + CapacitorOrientationSolver.EPSILON);
+    }));
+  }
+  pointsEqual(first, second) {
+    return Math.abs(first.x - second.x) <= CapacitorOrientationSolver.EPSILON && Math.abs(first.y - second.y) <= CapacitorOrientationSolver.EPSILON;
+  }
   static issueToString(issue) {
     const attrs = [];
     addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
@@ -331182,8 +331324,8 @@ class CapacitorOrientationSolver extends BaseSolver6 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DecouplingCapacitorGroupingSolver/DecouplingCapacitorGroupingSolver.ts
-import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
-class DecouplingCapacitorGroupingSolver extends BaseSolver7 {
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+class DecouplingCapacitorGroupingSolver extends BaseSolver8 {
   params;
   static MIN_BODY_GAP = 4;
   banks = [];
@@ -331279,13 +331421,45 @@ class DecouplingCapacitorGroupingSolver extends BaseSolver7 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/net-label-bounds.ts
+function getNetLabelBounds(label) {
+  const anchorSide = label.anchor_side;
+  const isVertical = anchorSide === "top" || anchorSide === "bottom";
+  if (isVertical) {
+    const anchorY = label.anchor_position?.y ?? label.center.y;
+    const textHalfExtent = (label.text?.length ?? 8) * 0.13 / 2 + 0.1;
+    const left = label.center.x - 0.1;
+    const right = label.center.x + 0.1;
+    if (anchorSide === "top") {
+      return {
+        left,
+        right,
+        top: anchorY,
+        bottom: anchorY - textHalfExtent * 2
+      };
+    }
+    return { left, right, top: anchorY + textHalfExtent * 2, bottom: anchorY };
+  }
+  const anchorX = label.anchor_position?.x ?? label.center.x;
+  const halfWidth = Math.abs(label.center.x - anchorX);
+  const farHalfWidth = halfWidth + 0.1;
+  const top = label.center.y + 0.1;
+  const bottom = label.center.y - 0.1;
+  if (label.center.x >= anchorX) {
+    return {
+      left: anchorX,
+      right: label.center.x + farHalfWidth,
+      top,
+      bottom
+    };
+  }
+  return { left: label.center.x - farHalfWidth, right: anchorX, top, bottom };
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
-class ComponentNetLabelCollisionSolver extends BaseSolver8 {
+import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
+class ComponentNetLabelCollisionSolver extends BaseSolver9 {
   params;
-  LABEL_HALF_HEIGHT = 0.1;
-  LABEL_BOUNDS_SLACK = 0.1;
-  SCH_CHAR_WIDTH = 0.13;
   placements;
   netLabelsByComponentId;
   rawCollisions = [];
@@ -331338,8 +331512,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver8 {
     const hits = [];
     for (const leftLabel of leftLabels) {
       for (const rightLabel of rightLabels) {
-        const leftBounds = this.getNetLabelBounds(leftLabel);
-        const rightBounds = this.getNetLabelBounds(rightLabel);
+        const leftBounds = getNetLabelBounds(leftLabel);
+        const rightBounds = getNetLabelBounds(rightLabel);
         if (rectOverlap(leftBounds, rightBounds)) {
           hits.push({
             type: "label-label",
@@ -331372,7 +331546,7 @@ class ComponentNetLabelCollisionSolver extends BaseSolver8 {
     const boxIsLeft = boxComp.schX <= labelComp.schX;
     const hits = [];
     for (const label of labels) {
-      const labelBounds = this.getNetLabelBounds(label);
+      const labelBounds = getNetLabelBounds(label);
       if (!rectOverlap(boxBounds, labelBounds))
         continue;
       let xSeparation;
@@ -331593,39 +331767,6 @@ class ComponentNetLabelCollisionSolver extends BaseSolver8 {
     }
     return result;
   }
-  getNetLabelBounds(label) {
-    const anchorSide = label.anchor_side;
-    const isVertical = anchorSide === "top" || anchorSide === "bottom";
-    if (isVertical) {
-      const anchorY = label.anchor_position?.y ?? label.center.y;
-      const textHalfExtent = (label.text?.length ?? 8) * this.SCH_CHAR_WIDTH / 2 + this.LABEL_BOUNDS_SLACK;
-      const left = label.center.x - this.LABEL_HALF_HEIGHT;
-      const right = label.center.x + this.LABEL_HALF_HEIGHT;
-      if (anchorSide === "top") {
-        return {
-          left,
-          right,
-          top: anchorY,
-          bottom: anchorY - textHalfExtent * 2
-        };
-      }
-      return { left, right, top: anchorY + textHalfExtent * 2, bottom: anchorY };
-    }
-    const anchorX = label.anchor_position?.x ?? label.center.x;
-    const halfWidth = Math.abs(label.center.x - anchorX);
-    const farHalfWidth = halfWidth + this.LABEL_BOUNDS_SLACK;
-    const top = label.center.y + this.LABEL_HALF_HEIGHT;
-    const bottom = label.center.y - this.LABEL_HALF_HEIGHT;
-    if (label.center.x >= anchorX) {
-      return {
-        left: anchorX,
-        right: label.center.x + farHalfWidth,
-        top,
-        bottom
-      };
-    }
-    return { left: label.center.x - farHalfWidth, right: anchorX, top, bottom };
-  }
   static netLabelCollisionToString(issue) {
     const pairAttrs = issue.pairs.map((pair, i) => `pair${i + 1}="${pair.comp1Name}/${pair.comp2Name}"`).join(" ");
     const moves = issue.moves.map((move) => `    <Move componentName="${move.componentName}" newSchX="${move.newSchX}" newSchY="${move.newSchY}" />`);
@@ -331641,8 +331782,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver8 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver9 {
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver10 {
   static ALIGNMENT_EPSILON = 0.01;
   ctx;
   out;
@@ -331776,8 +331917,8 @@ class ComponentPinAlignmentSolver extends BaseSolver9 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CrystalLoadCapacitorPlacementSolver/CrystalLoadCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
-class CrystalLoadCapacitorPlacementSolver extends BaseSolver10 {
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+class CrystalLoadCapacitorPlacementSolver extends BaseSolver11 {
   static ALIGNMENT_TOLERANCE = 0.1;
   issues;
   networks;
@@ -331937,13 +332078,15 @@ 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 BaseSolver11 } from "@tscircuit/solver-utils";
-class DiodeResistorAlignmentSolver extends BaseSolver11 {
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+import { getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2 } from "circuit-json-to-connectivity-map";
+class DiodeResistorAlignmentSolver extends BaseSolver12 {
   static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
   ctx;
   out;
   schematicTraces;
   currentIndex = 0;
+  sourceConnectivity;
   sourceComponentFtypeById;
   sourceComponentIdBySourcePortId;
   schematicPorts;
@@ -331956,6 +332099,7 @@ class DiodeResistorAlignmentSolver extends BaseSolver11 {
     this.ctx = ctx;
     this.out = issues;
     const { circuitJson } = ctx;
+    this.sourceConnectivity = getSourcePortConnectivityMapFromCircuitJson2(circuitJson);
     this.sourceComponentFtypeById = this.buildSourceComponentFtypeById(circuitJson);
     this.sourceComponentIdBySourcePortId = this.buildSourceComponentIdBySourcePortId(circuitJson);
     this.schematicPorts = circuitJson.filter((el) => el.type === "schematic_port");
@@ -332000,6 +332144,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver11 {
     const resistorPort = this.findNearestPort(startFtype === "simple_resistor" ? start : end, schematicSheetId);
     if (!diodePort?.center || !resistorPort?.center)
       return;
+    if (!this.sourceConnectivity.areIdsConnected(diodePort.source_port_id, resistorPort.source_port_id))
+      return;
     const diodeName = diodeBox.sourceComponentName ?? diodeCompId;
     const resistorName = resistorBox.sourceComponentName ?? resistorCompId;
     const diodePin = diodePort?.display_pin_label ?? diodePort?.pin_number?.toString();
@@ -332100,8 +332246,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver11 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/FeedbackNetworkPlacementSolver/FeedbackNetworkPlacementSolver.ts
-import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
-class FeedbackNetworkPlacementSolver extends BaseSolver12 {
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+class FeedbackNetworkPlacementSolver extends BaseSolver13 {
   static MIN_BODY_GAP = 4;
   index;
   amplifierIds;
@@ -332186,8 +332332,8 @@ function distanceBetweenBoxes(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
-class PullResistorPlacementSolver extends BaseSolver13 {
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+class PullResistorPlacementSolver extends BaseSolver14 {
   static MIN_WRONG_SIDE_GAP = 1.5;
   index;
   resistorIds;
@@ -332283,12 +332429,13 @@ class PullResistorPlacementSolver extends BaseSolver13 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentRailOrientationSolver/TwoPinComponentRailOrientationSolver.ts
-import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
-class TwoPinComponentRailOrientationSolver extends BaseSolver14 {
+import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
+class TwoPinComponentRailOrientationSolver extends BaseSolver15 {
   static EPSILON = 0.01;
   index;
   powerNets;
   groundNets;
+  positiveVoltageNets = new Set;
   componentIds;
   issues;
   currentIndex = 0;
@@ -332302,6 +332449,8 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver14 {
     this.powerNets = new Set(this.index.powerNets);
     this.groundNets = new Set(this.index.groundNets);
     for (const element of ctx.circuitJson) {
+      if (element.type === "source_net" && element.is_positive_voltage_source)
+        this.positiveVoltageNets.add(this.index.connected(element.source_net_id));
       if (element.type !== "source_port")
         continue;
       const net = this.index.connected(element.source_port_id);
@@ -332323,6 +332472,8 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver14 {
     const nets = index.twoTerminalNets(id);
     if (!component || !nets)
       return;
+    if (index.components.get(id)?.ftype === "simple_inductor" && !nets.some((net) => this.groundNets.has(net)))
+      return;
     if (nets.some((net) => this.powerNets.has(net) && this.groundNets.has(net)))
       return;
     const railTypes = nets.map((net) => this.powerNets.has(net) ? "power" : this.groundNets.has(net) ? "ground" : undefined);
@@ -332339,6 +332490,20 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver14 {
     const otherPort = index.port(otherSourcePort);
     if (!railPort || !otherPort)
       return;
+    const invertedRails = this.positiveVoltageNets.has(rail) && this.groundNets.has(index.connected(otherSourcePort.source_port_id)) && Math.abs(railPort.center.x - otherPort.center.x) <= TwoPinComponentRailOrientationSolver.EPSILON && railPort.center.y < otherPort.center.y - TwoPinComponentRailOrientationSolver.EPSILON && railPort.facing_direction === "down" && otherPort.facing_direction === "up";
+    if (invertedRails) {
+      this.issues.push({
+        lineItemType: "TwoPinComponentHasInvertedRails",
+        schematicBox: component,
+        railSourcePortId: railSourcePort.source_port_id,
+        railPinName: railSourcePort.name,
+        railType: "power",
+        deltaSchRotation: 180,
+        suggestedRailFacingDirection: "up",
+        message: `rotate ${component.sourceComponentName ?? id} by 180° so its positive-supply pin faces up and its ground pin faces down; preserve pin connections and reroute attached traces`
+      });
+      return;
+    }
     const horizontal = Math.abs(railPort.center.y - otherPort.center.y) <= TwoPinComponentRailOrientationSolver.EPSILON && Math.abs(railPort.center.x - otherPort.center.x) > TwoPinComponentRailOrientationSolver.EPSILON && (railPort.facing_direction === "left" && otherPort.facing_direction === "right" || railPort.facing_direction === "right" && otherPort.facing_direction === "left");
     if (!horizontal)
       return;
@@ -332363,13 +332528,18 @@ class TwoPinComponentRailOrientationSolver extends BaseSolver14 {
     addAttr(attrs, "deltaSchRotation", issue.deltaSchRotation);
     addAttr(attrs, "suggestedRailFacingDirection", issue.suggestedRailFacingDirection);
     addAttr(attrs, "message", issue.message);
-    return `<TwoPinComponentShouldBeVertical ${attrs.join(" ")} />`;
+    return `<${issue.lineItemType} ${attrs.join(" ")} />`;
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-box-components.ts
+function getSchematicBoxComponentIds(circuitJson) {
+  return new Set(circuitJson.flatMap((element) => element.type === "schematic_component" && element.is_box_with_pins !== false && !element.symbol_name && !element.schematic_symbol_id ? [element.schematic_component_id] : []));
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver15 {
+import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver16 {
   params;
   MESSAGE = "Inner labels are colliding. Increase the schWidth or schHeight.";
   PIN_LABEL_EDGE_PADDING = 0.1;
@@ -332388,9 +332558,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver15 {
     const { circuitJson, componentPlacements } = params2.ctx;
     this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
     this.sourcePortById = this.getSourcePortById(circuitJson);
-    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
-    const passiveComponentIds = new Set(circuitJson.filter((el) => el.type === "schematic_component").filter((el) => el.symbol_name).map((el) => el.schematic_component_id));
-    this.entries = this.entries.filter(([id]) => !passiveComponentIds.has(id));
+    const boxIds = getSchematicBoxComponentIds(circuitJson);
+    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson)).filter(([id]) => boxIds.has(id));
     this.solved = this.entries.length === 0;
   }
   _step() {
@@ -332567,8 +332736,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver15 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
-import { BaseSolver as BaseSolver16 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver16 {
+import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver17 {
   params;
   placements;
   firstIndex = 0;
@@ -332687,8 +332856,8 @@ class SchematicBoxOverlapSolver extends BaseSolver16 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver17 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver17 {
+import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver18 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
@@ -332709,7 +332878,8 @@ class SchematicBoxTooWideSolver extends BaseSolver17 {
     this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
     this.sourcePortById = this.getSourcePortById(circuitJson);
     this.sourceComponentById = this.getSourceComponentById(circuitJson);
-    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
+    const boxIds = getSchematicBoxComponentIds(circuitJson);
+    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson)).filter(([id]) => boxIds.has(id));
     this.solved = this.entries.length === 0;
   }
   _step() {
@@ -332723,6 +332893,9 @@ class SchematicBoxTooWideSolver extends BaseSolver17 {
     const schematicBox = this.placementById.get(schematicComponentId);
     if (!schematicBox)
       return;
+    const sourceComponent = schematicBox.sourceComponentId ? this.sourceComponentById.get(schematicBox.sourceComponentId) : undefined;
+    if (sourceComponent?.ftype === "simple_connector" && sourceComponent.standard === "usb_c")
+      return;
     const bounds = this.getCenteredRectBounds(schematicBox);
     const leftCol = this.getLabelColumn("left", ports, this.sourcePortById);
     const rightCol = this.getLabelColumn("right", ports, this.sourcePortById);
@@ -332790,6 +332963,7 @@ class SchematicBoxTooWideSolver extends BaseSolver17 {
     return {
       type: "source_component",
       source_component_id: el.source_component_id,
+      standard: "standard" in el && typeof el.standard === "string" ? el.standard : undefined,
       ftype: "ftype" in el && typeof el.ftype === "string" ? el.ftype : undefined
     };
   }
@@ -332863,8 +333037,8 @@ class SchematicBoxTooWideSolver extends BaseSolver17 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver18 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver18 {
+import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver19 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
   PIN_NAME_CHARACTER_WIDTH = 0.095;
@@ -332882,7 +333056,8 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver18 {
     this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
     this.schematicComponentById = this.getSchematicComponentById(circuitJson);
     this.sourcePortById = this.getSourcePortById(circuitJson);
-    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
+    const boxIds = getSchematicBoxComponentIds(circuitJson);
+    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson)).filter(([id]) => boxIds.has(id));
     this.solved = this.entries.length === 0;
   }
   _step() {
@@ -332909,7 +333084,10 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver18 {
       portsBySide.set(port.side_of_component, sidePorts);
     }
     const useLabelAwareMaxPadding = this.hasPinsOnAllSides(portsBySide);
+    const candidates = [];
     for (const [pinSide, sidePorts] of portsBySide) {
+      if (sidePorts.length === 1)
+        continue;
       for (const edgeSide of this.getBoxEdgeSidesForPinSide(pinSide)) {
         const outerPin = this.getOuterPinBySide(edgeSide, sidePorts);
         if (!outerPin)
@@ -332918,27 +333096,65 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver18 {
         const maxAllowedPadding = useLabelAwareMaxPadding ? this.getMaxAllowedPinPadding(pinSpacing, edgeSide, maxLabelLengthBySide) : pinSpacing;
         if (!this.exceedsMaxAllowedGap(measuredPadding, maxAllowedPadding))
           continue;
-        this.params.issues.push(this.createIssue({
+        candidates.push({
           schematicBox,
           pinSide,
           edgeSide,
           pinName: this.getPinName(outerPin, this.sourcePortById),
           measuredPadding,
           maxAllowedPadding
-        }));
+        });
       }
     }
+    if (!candidates.length)
+      return;
+    const details = candidates.map((candidate) => this.createIssue(candidate));
+    const representative = details.reduce((a, b) => b.excessPadding > a.excessPadding ? b : a);
+    const widths = details.flatMap((detail) => detail.suggestedSchWidth === undefined ? [] : [detail.suggestedSchWidth]);
+    const heights = details.flatMap((detail) => detail.suggestedSchHeight === undefined ? [] : [detail.suggestedSchHeight]);
+    const dimensions = [
+      widths.length ? "width" : "",
+      heights.length ? "height" : ""
+    ].filter(Boolean).join(" and ");
+    this.params.issues.push({
+      ...representative,
+      paddingDetails: details.map(({
+        pinSide,
+        edgeSide,
+        pinName,
+        measuredPadding,
+        maxAllowedPadding,
+        excessPadding
+      }) => ({
+        pinSide,
+        edgeSide,
+        pinName,
+        measuredPadding,
+        maxAllowedPadding,
+        excessPadding
+      })),
+      suggestedSchWidth: widths.length ? Math.max(...widths) : undefined,
+      suggestedSchHeight: heights.length ? Math.max(...heights) : undefined,
+      message: `${this.MESSAGE} ${dimensions}`
+    });
   }
   static issueToString(issue) {
     const attrs = [];
     addAttr(attrs, "message", issue.message);
     addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
-    addAttr(attrs, "pinSide", issue.pinSide);
-    addAttr(attrs, "edgeSide", issue.edgeSide);
-    addAttr(attrs, "pinName", issue.pinName);
-    addAttr(attrs, "measuredPadding", issue.measuredPadding);
-    addAttr(attrs, "maxAllowedPadding", issue.maxAllowedPadding);
-    addAttr(attrs, "excessPadding", issue.excessPadding);
+    if (issue.paddingDetails) {
+      addAttr(attrs, "pinSides", [...new Set(issue.paddingDetails.map((detail) => detail.pinSide))].join(","));
+      addAttr(attrs, "edgeSides", [
+        ...new Set(issue.paddingDetails.map((detail) => detail.edgeSide))
+      ].join(","));
+    } else {
+      addAttr(attrs, "pinSide", issue.pinSide);
+      addAttr(attrs, "edgeSide", issue.edgeSide);
+      addAttr(attrs, "pinName", issue.pinName);
+      addAttr(attrs, "measuredPadding", issue.measuredPadding);
+      addAttr(attrs, "maxAllowedPadding", issue.maxAllowedPadding);
+      addAttr(attrs, "excessPadding", issue.excessPadding);
+    }
     addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
     addAttr(attrs, "suggestedSchHeight", issue.suggestedSchHeight);
     return `<SchematicPinPaddingToEdgeTooLarge ${attrs.join(" ")} />`;
@@ -333201,9 +333417,160 @@ var buildSolverContext = (circuitJson) => {
   return { circuitJson, componentPlacements };
 };
 
+// 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);
+  if (sourceTrace?.type === "source_trace" && sourceTrace.name)
+    return sourceTrace.name;
+  const first = trace.edges[0];
+  const last = trace.edges.at(-1);
+  const endpointName = (point, id) => {
+    const ports = circuitJson.filter((e) => e.type === "schematic_port" && e.schematic_sheet_id === trace.schematic_sheet_id && (id ? e.schematic_port_id === id : Math.hypot(e.center.x - point.x, e.center.y - point.y) <= 0.01));
+    if (ports.length !== 1 || ports[0]?.type !== "schematic_port")
+      return;
+    const port = ports[0];
+    const sourcePort = circuitJson.find((e) => e.type === "source_port" && e.source_port_id === port.source_port_id);
+    const component = circuitJson.find((e) => e.type === "schematic_component" && e.schematic_component_id === port.schematic_component_id);
+    const sourceComponentId = sourcePort?.type === "source_port" ? sourcePort.source_component_id : component?.type === "schematic_component" ? component.source_component_id : undefined;
+    const sourceComponent = circuitJson.find((e) => e.type === "source_component" && e.source_component_id === sourceComponentId);
+    if (sourceComponent?.type !== "source_component" || !sourceComponent.name)
+      return;
+    const pin = sourcePort?.type === "source_port" && sourcePort.name ? sourcePort.name : port.pin_number !== undefined ? `pin${port.pin_number}` : port.display_pin_label;
+    return pin ? `${sourceComponent.name}.${pin}` : sourceComponent.name;
+  };
+  const from = first && endpointName(first.from, first.from_schematic_port_id);
+  const to = last && endpointName(last.to, last.to_schematic_port_id);
+  if (from && to)
+    return `${from} to ${to}`;
+  return sourceTrace?.type === "source_trace" && sourceTrace.display_name || from || to || "trace";
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
-import { BaseSolver as BaseSolver19 } from "@tscircuit/solver-utils";
-class TraceSimplificationSolver extends BaseSolver19 {
+import { calculateElbow as calculateElbow3 } from "calculate-elbow/lib";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-text-geometry.ts
+var rectPolygon = (bounds) => [
+  { x: bounds.left, y: bounds.bottom },
+  { x: bounds.right, y: bounds.bottom },
+  { x: bounds.right, y: bounds.top },
+  { x: bounds.left, y: bounds.top }
+];
+var advance = (character) => {
+  if (/\s/.test(character))
+    return 0.28;
+  if (/[ilI.,:;!'|]/.test(character))
+    return 0.25;
+  if (/[MW@%]/.test(character))
+    return 0.9;
+  if (/[mw]/.test(character))
+    return 0.8;
+  if (/[A-Z]/.test(character))
+    return 0.67;
+  return 0.56;
+};
+var widthInEm = (text) => Array.from(text).reduce((width, character) => width + advance(character), 0);
+function getSchematicTextPolygons(text) {
+  const size = text.font_size;
+  if (!Number.isFinite(size) || size <= 0 || !Number.isFinite(text.rotation) || !Number.isFinite(text.position.x) || !Number.isFinite(text.position.y))
+    return [];
+  const anchor = text.anchor;
+  const horizontal = anchor.includes("left") ? 0 : anchor.includes("right") ? 1 : 0.5;
+  const top = anchor.includes("top") ? 0 : anchor.includes("bottom") ? size : size / 2;
+  const radians = -text.rotation * Math.PI / 180;
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  return text.text.split(`
+`).flatMap((line, index) => {
+    const visible = line.trim();
+    if (!visible)
+      return [];
+    const leading = line.length - line.trimStart().length;
+    const left = (widthInEm(line.slice(0, leading)) - widthInEm(line) * horizontal) * size;
+    const polygon = rectPolygon({
+      left,
+      right: left + widthInEm(visible) * size,
+      top: top - index * size - size * 0.05,
+      bottom: top - (index + 1) * size + size * 0.05
+    });
+    return [
+      polygon.map(({ x, y }) => ({
+        x: text.position.x + x * cos - y * sin,
+        y: text.position.y + x * sin + y * cos
+      }))
+    ];
+  });
+}
+function polygonsOverlap(a, b) {
+  for (const polygon of [a, b]) {
+    for (let i = 0;i < polygon.length; i++) {
+      const p = polygon[i];
+      const q = polygon[(i + 1) % polygon.length];
+      const length = Math.hypot(q.x - p.x, q.y - p.y);
+      if (length < 0.000000001)
+        continue;
+      const nx = -(q.y - p.y) / length;
+      const ny = (q.x - p.x) / length;
+      const project = (points) => points.map(({ x, y }) => x * nx + y * ny);
+      const pa = project(a);
+      const pb = project(b);
+      if (Math.min(Math.max(...pa), Math.max(...pb)) - Math.max(Math.min(...pa), Math.min(...pb)) <= 0.000001)
+        return false;
+    }
+  }
+  return true;
+}
+function traceSegmentPolygon(from, to) {
+  const length = Math.hypot(to.x - from.x, to.y - from.y);
+  if (length < 0.000000001)
+    return;
+  const dx = -(to.y - from.y) / length * 0.01;
+  const dy = (to.x - from.x) / length * 0.01;
+  return [
+    { x: from.x + dx, y: from.y + dy },
+    { x: to.x + dx, y: to.y + dy },
+    { x: to.x - dx, y: to.y - dy },
+    { x: from.x - dx, y: from.y - dy }
+  ];
+}
+function segmentCrossesPolygon(from, to, polygon) {
+  if (Math.hypot(to.x - from.x, to.y - from.y) < 0.000000001)
+    return false;
+  let low = 0;
+  let high = 1;
+  for (let i = 0;i < polygon.length; i++) {
+    const p = polygon[i];
+    const q = polygon[(i + 1) % polygon.length];
+    const length = Math.hypot(q.x - p.x, q.y - p.y);
+    if (length < 0.000000001)
+      continue;
+    const nx = -(q.y - p.y) / length;
+    const ny = (q.x - p.x) / length;
+    const start = (from.x - p.x) * nx + (from.y - p.y) * ny - 0.000001;
+    const end = (to.x - p.x) * nx + (to.y - p.y) * ny - 0.000001;
+    if (start <= 0 && end <= 0)
+      return false;
+    if (start <= 0)
+      low = Math.max(low, -start / (end - start));
+    if (end <= 0)
+      high = Math.min(high, -start / (end - start));
+    if (high <= low)
+      return false;
+  }
+  return high > low;
+}
+var polygonBounds = (polygons) => {
+  const points = polygons.flat();
+  return {
+    left: Math.min(...points.map((p) => p.x)),
+    right: Math.max(...points.map((p) => p.x)),
+    top: Math.max(...points.map((p) => p.y)),
+    bottom: Math.min(...points.map((p) => p.y))
+  };
+};
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
+import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver20 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -333245,18 +333612,40 @@ class TraceSimplificationSolver extends BaseSolver19 {
           placementsByComponentId
         })
       ].filter((candidate) => Boolean(candidate));
+      for (const candidate of [...candidates]) {
+        if (!candidate.target.sourceComponentName?.startsWith("U"))
+          continue;
+        for (const point of [points[0], points.at(-1)]) {
+          const port = this.findPortAtPoint(ports, point, trace.schematic_sheet_id);
+          const target = port?.schematic_component_id ? placementsByComponentId.get(port.schematic_component_id) : undefined;
+          if (!target || !/^[CR]/.test(target.sourceComponentName ?? ""))
+            continue;
+          candidates.push({
+            target,
+            deltaSchX: -candidate.deltaSchX,
+            deltaSchY: -candidate.deltaSchY,
+            currentTurnCount,
+            suggestedTurnCount: candidate.suggestedTurnCount
+          });
+        }
+      }
+      const priority = (candidate) => /^[CR]/.test(candidate.target.sourceComponentName ?? "") ? 0 : candidate.target.sourceComponentName?.startsWith("U") ? 2 : 1;
+      candidates.sort((a, b) => priority(a) - priority(b));
       for (const candidate of candidates) {
         if (this.wouldOverlapAnotherComponent(candidate))
           continue;
+        if (!this.validateMove(trace, candidate, ports))
+          continue;
         const moveKey = [
           candidate.target.schematicComponentId,
           candidate.deltaSchX.toFixed(3),
           candidate.deltaSchY.toFixed(3)
         ].join("\x00");
         if (emittedMoves.has(moveKey))
-          continue;
+          break;
         emittedMoves.add(moveKey);
         this.out.push(this.makeIssue(trace, candidate));
+        break;
       }
     }
     this.solved = true;
@@ -333324,6 +333713,110 @@ class TraceSimplificationSolver extends BaseSolver19 {
       suggestedTurnCount
     };
   }
+  validateMove(targetTrace, candidate, ports) {
+    const componentId = candidate.target.schematicComponentId;
+    const sheetId = candidate.target.schematicSheetId;
+    const sheetPorts = ports.filter((p) => p.schematic_sheet_id === sheetId);
+    const movingPorts = sheetPorts.filter((p) => p.schematic_component_id === componentId);
+    const traces = this.ctx.circuitJson.filter((e) => e.type === "schematic_trace" && e.schematic_sheet_id === sheetId);
+    const touchesPort = (trace, port) => trace.edges.some((edge) => edge.from_schematic_port_id === port.schematic_port_id || edge.to_schematic_port_id === port.schematic_port_id || this.pointsEqual(edge.from, port.center) || this.pointsEqual(edge.to, port.center));
+    const affected = traces.filter((trace) => movingPorts.some((port) => touchesPort(trace, port)));
+    if (!affected.includes(targetTrace))
+      return false;
+    if (this.ctx.circuitJson.some((e) => e.type === "schematic_net_label" && e.schematic_sheet_id === sheetId && movingPorts.some((p) => this.pointsEqual(e.anchor_position ?? e.center, p.center))))
+      return false;
+    const shift = (point) => ({
+      x: point.x + candidate.deltaSchX,
+      y: point.y + candidate.deltaSchY
+    });
+    const directions = {
+      left: "x-",
+      right: "x+",
+      up: "y+",
+      down: "y-"
+    };
+    const endpoint = (port, moved) => ({
+      ...moved && port.schematic_component_id === componentId ? shift(port.center) : port.center,
+      facingDirection: directions[port.facing_direction]
+    });
+    const length = (points) => points.slice(1).reduce((sum, p, i) => sum + Math.abs(p.x - points[i].x) + Math.abs(p.y - points[i].y), 0);
+    const segments = (points) => points.slice(1).map((to, i) => ({ from: points[i], to }));
+    const movedBounds = centeredRect(candidate.target.schX + candidate.deltaSchX, candidate.target.schY + candidate.deltaSchY, candidate.target.width, candidate.target.height);
+    const unaffected = traces.filter((trace) => !affected.includes(trace));
+    if (unaffected.some((trace) => trace.edges.some((edge) => segmentCrossesPolygon(edge.from, edge.to, rectPolygon(movedBounds)))))
+      return false;
+    const textPolygons = this.ctx.circuitJson.flatMap((e) => {
+      if (e.type === "schematic_net_label" && e.schematic_sheet_id === sheetId)
+        return [rectPolygon(getNetLabelBounds(e))];
+      if (e.type !== "schematic_text" || e.schematic_sheet_id !== sheetId)
+        return [];
+      return getSchematicTextPolygons(e.schematic_component_id === componentId ? { ...e, position: shift(e.position) } : e);
+    });
+    if (textPolygons.some((polygon) => polygonsOverlap(polygon, rectPolygon(movedBounds))))
+      return false;
+    const proposed = [];
+    for (const trace of affected) {
+      const oldPoints = this.getTracePoints(trace);
+      if (oldPoints.length < 2 || trace.junctions?.length)
+        return false;
+      const resolve = (point, id) => {
+        const matches = sheetPorts.filter((p) => id ? p.schematic_port_id === id : this.pointsEqual(p.center, point));
+        return matches.length === 1 && this.pointsEqual(matches[0].center, point) ? matches[0] : undefined;
+      };
+      const start = resolve(oldPoints[0], trace.edges[0].from_schematic_port_id);
+      const end = resolve(oldPoints.at(-1), trace.edges.at(-1).to_schematic_port_id);
+      if (!start?.facing_direction || !end?.facing_direction)
+        return false;
+      if (movingPorts.some((p) => touchesPort(trace, p) && p !== start && p !== end))
+        return false;
+      const isInteriorConnection = (point) => !this.pointsEqual(point, start.center) && !this.pointsEqual(point, end.center) && segments(oldPoints).some(({ from, to }) => Math.abs(Math.hypot(point.x - from.x, point.y - from.y) + Math.hypot(point.x - to.x, point.y - to.y) - Math.hypot(to.x - from.x, to.y - from.y)) < 0.000001);
+      if (traces.some((other) => other !== trace && other.edges.some((edge) => isInteriorConnection(edge.from) || isInteriorConnection(edge.to))))
+        return false;
+      if (this.ctx.circuitJson.some((e) => e.type === "schematic_net_label" && e.schematic_sheet_id === sheetId && isInteriorConnection(e.anchor_position ?? e.center)))
+        return false;
+      const points = calculateElbow3(endpoint(start, true), endpoint(end, true)).filter((point, i, all) => i === 0 || !this.pointsEqual(point, all[i - 1]));
+      const turns = this.countTurns(points);
+      const oldTurns = this.countTurns(oldPoints);
+      if (points.length < 2 || turns === undefined || oldTurns === undefined || turns > oldTurns || length(points) > length(oldPoints) + 0.000001)
+        return false;
+      if (!this.isPointInFacingDirection(points[0], points[1], start.facing_direction) || !this.isPointInFacingDirection(points.at(-1), points.at(-2), end.facing_direction))
+        return false;
+      if (trace === targetTrace) {
+        const baselineTurns = this.countTurns(calculateElbow3(endpoint(start, false), endpoint(end, false)));
+        if (turns >= oldTurns || baselineTurns === undefined || turns >= baselineTurns)
+          return false;
+        candidate.suggestedTurnCount = turns;
+      }
+      for (const segment of segments(points)) {
+        if (textPolygons.some((polygon) => segmentCrossesPolygon(segment.from, segment.to, polygon)))
+          return false;
+        if (this.ctx.componentPlacements.some((p) => {
+          if (p.schematicSheetId !== sheetId)
+            return false;
+          const bounds = p.schematicComponentId === componentId ? movedBounds : centeredRect(p.schX, p.schY, p.width, p.height);
+          return segmentCrossesPolygon(segment.from, segment.to, rectPolygon(bounds));
+        }))
+          return false;
+        const polygon = traceSegmentPolygon(segment.from, segment.to);
+        if (!polygon)
+          continue;
+        const otherSegments = [
+          ...unaffected.flatMap((t) => t.edges),
+          ...proposed.flatMap((t) => segments(t.points))
+        ];
+        if (otherSegments.some((edge) => {
+          if ([start, end].some((port) => port.schematic_component_id !== componentId && [segment.from, segment.to].some((p) => this.pointsEqual(p, port.center)) && [edge.from, edge.to].some((p) => this.pointsEqual(p, port.center))) && this.getAxis(segment.from, segment.to) !== this.getAxis(edge.from, edge.to))
+            return false;
+          const other = traceSegmentPolygon(edge.from, edge.to);
+          return other && polygonsOverlap(polygon, other);
+        }))
+          return false;
+      }
+      proposed.push({ schematicTraceId: trace.schematic_trace_id, points });
+    }
+    candidate.suggestedTraces = proposed;
+    return true;
+  }
   getTracePoints(trace) {
     const firstEdge = trace.edges[0];
     if (!firstEdge)
@@ -333401,6 +333894,7 @@ class TraceSimplificationSolver extends BaseSolver19 {
     return {
       lineItemType: "TraceCanBeSimplifiedByMovingComponent",
       schematicTraceId: trace.schematic_trace_id,
+      traceName: getTraceName(this.ctx.circuitJson, trace),
       targetComponent: candidate.target,
       deltaSchX: candidate.deltaSchX,
       deltaSchY: candidate.deltaSchY,
@@ -333408,6 +333902,7 @@ class TraceSimplificationSolver extends BaseSolver19 {
       newSchY,
       currentTurnCount: candidate.currentTurnCount,
       suggestedTurnCount: candidate.suggestedTurnCount,
+      suggestedTraces: candidate.suggestedTraces,
       message: `move ${targetName} ${direction} by ${fmtNumber4(distance)} (to schX=${fmtNumber4(newSchX)}, schY=${fmtNumber4(newSchY)}) to reduce this trace from ${candidate.currentTurnCount} turns to ${candidate.suggestedTurnCount}`
     };
   }
@@ -333419,7 +333914,7 @@ class TraceSimplificationSolver extends BaseSolver19 {
   }
   static issueToString(issue) {
     const attrs = [];
-    addAttr(attrs, "schematicTraceId", issue.schematicTraceId);
+    addAttr(attrs, "traceName", issue.traceName);
     addAttr(attrs, "targetComponentName", issue.targetComponent.sourceComponentName);
     addAttr(attrs, "deltaSchX", issue.deltaSchX, { formatDelta: true });
     addAttr(attrs, "deltaSchY", issue.deltaSchY, { formatDelta: true });
@@ -333433,12 +333928,12 @@ class TraceSimplificationSolver extends BaseSolver19 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-import { BaseSolver as BaseSolver20 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/getPowerOrGroundConnectionIds.ts
 import {
   findConnectedNetworks as findConnectedNetworks3,
-  getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2
+  getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson3
 } from "circuit-json-to-connectivity-map";
 function getPowerOrGroundConnectionIds(circuitJson) {
   const powerOrGroundIds = new Set;
@@ -333457,7 +333952,7 @@ function getPowerOrGroundConnectionIds(circuitJson) {
       idsByConnectivityKey.set(key, ids);
     }
   }
-  const sourceConnectivity = getSourcePortConnectivityMapFromCircuitJson2(circuitJson);
+  const sourceConnectivity = getSourcePortConnectivityMapFromCircuitJson3(circuitJson);
   const networks = findConnectedNetworks3([
     ...Object.values(sourceConnectivity.netMap),
     ...idsByConnectivityKey.values()
@@ -333472,7 +333967,7 @@ function getPowerOrGroundConnectionIds(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-class TwoPinComponentOrientationSolver extends BaseSolver20 {
+class TwoPinComponentOrientationSolver extends BaseSolver21 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -333689,6 +334184,7 @@ class TwoPinComponentOrientationSolver extends BaseSolver20 {
     return {
       lineItemType: "TwoPinComponentCouldBeFlipped",
       schematicTraceId: candidate.trace.schematic_trace_id,
+      traceName: getTraceName(this.ctx.circuitJson, candidate.trace),
       targetComponent: candidate.targetPlacement,
       connectedComponent: candidate.connectedPlacement,
       targetPin,
@@ -333702,7 +334198,7 @@ class TwoPinComponentOrientationSolver extends BaseSolver20 {
   }
   static issueToString(issue) {
     const attrs = [];
-    addAttr(attrs, "schematicTraceId", issue.schematicTraceId);
+    addAttr(attrs, "traceName", issue.traceName);
     addAttr(attrs, "targetComponentName", issue.targetComponent.sourceComponentName);
     addAttr(attrs, "connectedComponentName", issue.connectedComponent.sourceComponentName);
     addAttr(attrs, "targetPin", issue.targetPin);
@@ -333717,8 +334213,8 @@ class TwoPinComponentOrientationSolver extends BaseSolver20 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver21 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver21 {
+import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver22 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -333827,130 +334323,8 @@ class VerboseNetLabelSolver extends BaseSolver21 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
-import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-text-geometry.ts
-var rectPolygon = (bounds) => [
-  { x: bounds.left, y: bounds.bottom },
-  { x: bounds.right, y: bounds.bottom },
-  { x: bounds.right, y: bounds.top },
-  { x: bounds.left, y: bounds.top }
-];
-var advance = (character) => {
-  if (/\s/.test(character))
-    return 0.28;
-  if (/[ilI.,:;!'|]/.test(character))
-    return 0.25;
-  if (/[MW@%]/.test(character))
-    return 0.9;
-  if (/[mw]/.test(character))
-    return 0.8;
-  if (/[A-Z]/.test(character))
-    return 0.67;
-  return 0.56;
-};
-var widthInEm = (text) => Array.from(text).reduce((width, character) => width + advance(character), 0);
-function getSchematicTextPolygons(text) {
-  const size = text.font_size;
-  if (!Number.isFinite(size) || size <= 0 || !Number.isFinite(text.rotation) || !Number.isFinite(text.position.x) || !Number.isFinite(text.position.y))
-    return [];
-  const anchor = text.anchor;
-  const horizontal = anchor.includes("left") ? 0 : anchor.includes("right") ? 1 : 0.5;
-  const top = anchor.includes("top") ? 0 : anchor.includes("bottom") ? size : size / 2;
-  const radians = -text.rotation * Math.PI / 180;
-  const cos = Math.cos(radians);
-  const sin = Math.sin(radians);
-  return text.text.split(`
-`).flatMap((line, index) => {
-    const visible = line.trim();
-    if (!visible)
-      return [];
-    const leading = line.length - line.trimStart().length;
-    const left = (widthInEm(line.slice(0, leading)) - widthInEm(line) * horizontal) * size;
-    const polygon = rectPolygon({
-      left,
-      right: left + widthInEm(visible) * size,
-      top: top - index * size - size * 0.05,
-      bottom: top - (index + 1) * size + size * 0.05
-    });
-    return [
-      polygon.map(({ x, y }) => ({
-        x: text.position.x + x * cos - y * sin,
-        y: text.position.y + x * sin + y * cos
-      }))
-    ];
-  });
-}
-function polygonsOverlap(a, b) {
-  for (const polygon of [a, b]) {
-    for (let i = 0;i < polygon.length; i++) {
-      const p = polygon[i];
-      const q = polygon[(i + 1) % polygon.length];
-      const length = Math.hypot(q.x - p.x, q.y - p.y);
-      if (length < 0.000000001)
-        continue;
-      const nx = -(q.y - p.y) / length;
-      const ny = (q.x - p.x) / length;
-      const project = (points) => points.map(({ x, y }) => x * nx + y * ny);
-      const pa = project(a);
-      const pb = project(b);
-      if (Math.min(Math.max(...pa), Math.max(...pb)) - Math.max(Math.min(...pa), Math.min(...pb)) <= 0.000001)
-        return false;
-    }
-  }
-  return true;
-}
-function traceSegmentPolygon(from, to) {
-  const length = Math.hypot(to.x - from.x, to.y - from.y);
-  if (length < 0.000000001)
-    return;
-  const dx = -(to.y - from.y) / length * 0.01;
-  const dy = (to.x - from.x) / length * 0.01;
-  return [
-    { x: from.x + dx, y: from.y + dy },
-    { x: to.x + dx, y: to.y + dy },
-    { x: to.x - dx, y: to.y - dy },
-    { x: from.x - dx, y: from.y - dy }
-  ];
-}
-function segmentCrossesPolygon(from, to, polygon) {
-  if (Math.hypot(to.x - from.x, to.y - from.y) < 0.000000001)
-    return false;
-  let low = 0;
-  let high = 1;
-  for (let i = 0;i < polygon.length; i++) {
-    const p = polygon[i];
-    const q = polygon[(i + 1) % polygon.length];
-    const length = Math.hypot(q.x - p.x, q.y - p.y);
-    if (length < 0.000000001)
-      continue;
-    const nx = -(q.y - p.y) / length;
-    const ny = (q.x - p.x) / length;
-    const start = (from.x - p.x) * nx + (from.y - p.y) * ny - 0.000001;
-    const end = (to.x - p.x) * nx + (to.y - p.y) * ny - 0.000001;
-    if (start <= 0 && end <= 0)
-      return false;
-    if (start <= 0)
-      low = Math.max(low, -start / (end - start));
-    if (end <= 0)
-      high = Math.min(high, -start / (end - start));
-    if (high <= low)
-      return false;
-  }
-  return high > low;
-}
-var polygonBounds = (polygons) => {
-  const points = polygons.flat();
-  return {
-    left: Math.min(...points.map((p) => p.x)),
-    right: Math.max(...points.map((p) => p.x)),
-    top: Math.max(...points.map((p) => p.y)),
-    bottom: Math.min(...points.map((p) => p.y))
-  };
-};
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
-class SchematicTextClearanceSolver extends BaseSolver22 {
+import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
+class SchematicTextClearanceSolver extends BaseSolver23 {
   params;
   texts;
   obstacles;
@@ -334101,8 +334475,8 @@ class SchematicTextClearanceSolver extends BaseSolver22 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ResetNetworkGroupingSolver/ResetNetworkGroupingSolver.ts
-import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
-class ResetNetworkGroupingSolver extends BaseSolver23 {
+import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
+class ResetNetworkGroupingSolver extends BaseSolver24 {
   params;
   static MIN_DISTANCE = 6;
   networks;
@@ -334316,6 +334690,9 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     ]),
     definePipelineStep3("ConnectorPlacementSolver", ConnectorPlacementSolver, (p) => [
       { ctx: p.ctx, issues: p.issues }
+    ]),
+    definePipelineStep3("LowSideTransistorPlacementSolver", LowSideTransistorPlacementSolver, (p) => [
+      { ctx: p.ctx, issues: p.issues }
     ])
   ];
   _setup() {
@@ -334367,6 +334744,12 @@ var getRelevantPlacementsForIssues = ({
   };
   for (const issue of issues) {
     switch (issue.lineItemType) {
+      case "LowSideTransistorNotAlignedWithLoad":
+        addPlacement(issue.transistorSchematicBox);
+        addPlacement(issue.loadSchematicBox);
+        addPlacement(issue.baseResistorSchematicBox);
+        addPlacement(issue.clampDiodeSchematicBox);
+        break;
       case "DecouplingCapacitorsNotCloseTogether":
         for (const placement of issue.capacitorSchematicBoxes)
           addPlacement(placement);
@@ -334444,6 +334827,7 @@ var getRelevantPlacementsForIssues = ({
           addPlacement(component);
         break;
       case "TwoPinComponentShouldBeVertical":
+      case "TwoPinComponentHasInvertedRails":
         addPlacement(issue.schematicBox);
         break;
       case "PullResistorOnWrongSide":
@@ -334554,8 +334938,10 @@ class SchematicPlacementAnalysis {
       ResetNetworkNotGrouped: 0,
       TwoPinComponentCouldBeFlipped: 0,
       TwoPinComponentShouldBeVertical: 0,
+      TwoPinComponentHasInvertedRails: 0,
       DecouplingCapacitorsNotCloseTogether: 0,
-      ConnectorPositionCausesTraceDetours: 0
+      ConnectorPositionCausesTraceDetours: 0,
+      LowSideTransistorNotAlignedWithLoad: 0
     };
     for (const issue of this.getIssues(filter))
       counts[issue.lineItemType]++;
@@ -334604,6 +334990,7 @@ class SchematicPlacementAnalysis {
       case "FeedbackNetworkNotCompact":
         return FeedbackNetworkPlacementSolver.issueToString(issue);
       case "TwoPinComponentShouldBeVertical":
+      case "TwoPinComponentHasInvertedRails":
         return TwoPinComponentRailOrientationSolver.issueToString(issue);
       case "PullResistorOnWrongSide":
         return PullResistorPlacementSolver.issueToString(issue);
@@ -334615,6 +335002,8 @@ class SchematicPlacementAnalysis {
         return ResetNetworkGroupingSolver.issueToString(issue);
       case "ConnectorPositionCausesTraceDetours":
         return ConnectorPlacementSolver.issueToString(issue);
+      case "LowSideTransistorNotAlignedWithLoad":
+        return LowSideTransistorPlacementSolver.issueToString(issue);
       default:
         return "";
     }

package/dist/lib/index.js

@@ -69128,7 +69128,7 @@ var package_default = {
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.24.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.15",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#41260fc05b736c0f3fdc33892b6da0ece40107b9",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.11.tgz",
     "@tscircuit/circuit-json-util": "^0.0.113",
     "@tscircuit/eval": "0.0.1402",
     "@tscircuit/fake-snippets": "^0.0.182",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.2126",
+  "version": "0.1.2127",
   "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.24.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.15",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#41260fc05b736c0f3fdc33892b6da0ece40107b9",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.11.tgz",
     "@tscircuit/circuit-json-util": "^0.0.113",
     "@tscircuit/eval": "0.0.1402",
     "@tscircuit/fake-snippets": "^0.0.182",