@tscircuit/cli 0.1.1981 → 0.1.1982

package/dist/cli/main.js

@@ -136163,7 +136163,7 @@ var package_default = {
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.19.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.9",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#2bfa85c47dd0bd0d360b85083980170c01d3afca",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#db2cd1ca2ce51490e3230e53c3d7b361eeb14446",
     "@tscircuit/circuit-json-util": "^0.0.105",
     "@tscircuit/eval": "^0.0.1016",
     "@tscircuit/fake-snippets": "^0.0.182",
@@ -301798,118 +301798,27 @@ var registerCheckRoutingDifficulty = (program2) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
-import {
-  BasePipelineSolver as BasePipelineSolver2,
-  definePipelineStep as definePipelineStep3
-} from "@tscircuit/solver-utils";
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/placements.ts
-import { cju as cju7 } from "@tscircuit/circuit-json-util";
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-sheets.ts
-var getSchematicSheetNamesById = (circuitJson) => {
-  const map = new Map;
-  for (const element of circuitJson) {
-    if (element.type === "schematic_sheet" && element.name) {
-      map.set(element.schematic_sheet_id, element.name);
-    }
-  }
-  return map;
-};
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
+import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/placements.ts
-var isSchematicBox = (el3) => el3.type === "schematic_box";
-var isSchematicComponent = (el3) => el3.type === "schematic_component";
-var getSchematicSheetId = (el3) => el3.schematic_sheet_id;
-var getSourceComponentName = (circuitJson, sourceComponentId) => {
-  if (!sourceComponentId)
-    return;
-  return cju7(circuitJson).source_component.get(sourceComponentId)?.name;
-};
-var getSourceComponentMetadata = (schematicBox, circuitJson) => {
-  if (!schematicBox.schematic_component_id)
-    return {};
-  const util2 = cju7(circuitJson);
-  const sc2 = util2.schematic_component.get(schematicBox.schematic_component_id);
-  if (!sc2?.source_component_id)
-    return {};
-  const sourceComponent = util2.source_component.get(sc2.source_component_id);
-  return {
-    sourceComponentId: sc2.source_component_id,
-    sourceComponentName: sourceComponent?.name
-  };
-};
-var schematicComponentToPlacement = (schematicComponent, circuitJson, schematicSheetNameById, schematicBox) => {
-  let schematicSheetId = getSchematicSheetId(schematicComponent);
-  if (schematicSheetId === undefined && schematicBox) {
-    schematicSheetId = getSchematicSheetId(schematicBox);
-  }
-  let schematicSheetName;
-  if (schematicSheetId) {
-    schematicSheetName = schematicSheetNameById.get(schematicSheetId);
-  }
-  const placement = {
-    lineItemType: "SchematicBoxPlacement",
-    positionAnchor: "center",
-    schX: schematicComponent.center.x,
-    schY: schematicComponent.center.y,
-    width: schematicBox?.width ?? schematicComponent.size.width,
-    height: schematicBox?.height ?? schematicComponent.size.height,
-    sourceComponentId: schematicComponent.source_component_id,
-    sourceComponentName: getSourceComponentName(circuitJson, schematicComponent.source_component_id),
-    schematicComponentId: schematicComponent.schematic_component_id,
-    schematicSymbolId: schematicBox?.schematic_symbol_id ?? schematicComponent.schematic_symbol_id,
-    subcircuitId: schematicComponent.subcircuit_id ?? schematicBox?.subcircuit_id
-  };
-  if (schematicSheetId) {
-    placement.schematicSheetId = schematicSheetId;
-  }
-  if (schematicSheetName) {
-    placement.schematicSheetName = schematicSheetName;
-  }
-  return placement;
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/format.ts
+var fmtNumber5 = (value) => {
+  if (Number.isInteger(value))
+    return String(value);
+  return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
 };
-var schematicBoxToPlacement = (schematicBox, circuitJson, schematicSheetNameById) => {
-  const schematicSheetId = getSchematicSheetId(schematicBox);
-  let schematicSheetName;
-  if (schematicSheetId) {
-    schematicSheetName = schematicSheetNameById.get(schematicSheetId);
-  }
-  const placement = {
-    lineItemType: "SchematicBoxPlacement",
-    positionAnchor: "center",
-    schX: schematicBox.x,
-    schY: schematicBox.y,
-    width: schematicBox.width,
-    height: schematicBox.height,
-    ...getSourceComponentMetadata(schematicBox, circuitJson),
-    schematicComponentId: schematicBox.schematic_component_id,
-    schematicSymbolId: schematicBox.schematic_symbol_id,
-    subcircuitId: schematicBox.subcircuit_id
-  };
-  if (schematicSheetId) {
-    placement.schematicSheetId = schematicSheetId;
-  }
-  if (schematicSheetName) {
-    placement.schematicSheetName = schematicSheetName;
-  }
-  return placement;
+var fmtDelta = (value) => {
+  const formatted = fmtNumber5(value);
+  return value > 0 ? `+${formatted}` : formatted;
 };
-var buildSolverContext = (circuitJson) => {
-  const schematicBoxes = circuitJson.filter(isSchematicBox);
-  const schematicSheetNameById = getSchematicSheetNamesById(circuitJson);
-  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent).map((sc2) => sc2.schematic_component_id));
-  const componentPlacements = [
-    ...circuitJson.filter(isSchematicComponent).map((sc2) => schematicComponentToPlacement(sc2, circuitJson, schematicSheetNameById, schematicBoxes.find((sb3) => sb3.schematic_component_id === sc2.schematic_component_id))),
-    ...schematicBoxes.filter((sb3) => !sb3.schematic_component_id || !schematicComponentIds.has(sb3.schematic_component_id)).map((sb3) => schematicBoxToPlacement(sb3, circuitJson, schematicSheetNameById))
-  ];
-  return { circuitJson, componentPlacements };
+var escapeAttr3 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var addAttr = (attrs, key, value, options) => {
+  if (value === undefined)
+    return;
+  const stringValue = typeof value === "number" ? options?.formatDelta ? fmtDelta(value) : fmtNumber5(value) : options?.escape === false ? value : escapeAttr3(value);
+  attrs.push(`${key}="${stringValue}"`);
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
-import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
-
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/graphics.ts
 import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 function mergeGraphicsObjects2(objects) {
@@ -301942,24 +301851,6 @@ function visualizeCircuitJson(circuitJson) {
   return { rects };
 }
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/format.ts
-var fmtNumber5 = (value) => {
-  if (Number.isInteger(value))
-    return String(value);
-  return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
-};
-var fmtDelta = (value) => {
-  const formatted = fmtNumber5(value);
-  return value > 0 ? `+${formatted}` : formatted;
-};
-var escapeAttr3 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-var addAttr = (attrs, key, value, options) => {
-  if (value === undefined)
-    return;
-  const stringValue = typeof value === "number" ? options?.formatDelta ? fmtDelta(value) : fmtNumber5(value) : options?.escape === false ? value : escapeAttr3(value);
-  attrs.push(`${key}="${stringValue}"`);
-};
-
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
 class CapacitorOrientationSolver extends BaseSolver5 {
   static ORIENTATION_MESSAGE = 'Use schOrientation="vertical" on this capacitor to fix the symbol orientation';
@@ -301993,7 +301884,9 @@ class CapacitorOrientationSolver extends BaseSolver5 {
       height: p3.height,
       sourceComponentId: p3.sourceComponentId,
       sourceComponentName: p3.sourceComponentName,
-      schematicComponentId: p3.schematicComponentId
+      schematicComponentId: p3.schematicComponentId,
+      schematicSheetId: p3.schematicSheetId,
+      schematicSheetName: p3.schematicSheetName
     }));
   }
   _step() {
@@ -302046,7 +301939,9 @@ class CapacitorOrientationSolver extends BaseSolver5 {
       height: placement.height,
       sourceComponentId: placement.sourceComponentId,
       sourceComponentName: placement.sourceComponentName,
-      schematicComponentId: placement.schematicComponentId
+      schematicComponentId: placement.schematicComponentId,
+      schematicSheetId: placement.schematicSheetId,
+      schematicSheetName: placement.schematicSheetName
     };
   }
   getIssueForPlacement(placement) {
@@ -302075,129 +301970,672 @@ class CapacitorOrientationSolver extends BaseSolver5 {
   }
 }
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
 import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver7 {
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
+function centeredRect(cx3, cy3, w4, h4) {
+  return {
+    left: cx3 - w4 / 2,
+    right: cx3 + w4 / 2,
+    top: cy3 + h4 / 2,
+    bottom: cy3 - h4 / 2
+  };
+}
+function rectOverlap(a2, b3) {
+  const ow2 = Math.min(a2.right, b3.right) - Math.max(a2.left, b3.left);
+  const oh2 = Math.min(a2.top, b3.top) - Math.max(a2.bottom, b3.bottom);
+  return ow2 > 0 && oh2 > 0 ? { ow: ow2, oh: oh2 } : null;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
+class ComponentNetLabelCollisionSolver extends BaseSolver7 {
   params;
+  LABEL_HALF_HEIGHT = 0.1;
+  LABEL_BOUNDS_SLACK = 0.1;
+  SCH_CHAR_WIDTH = 0.13;
   placements;
+  netLabelsByComponentId;
+  rawCollisions = [];
   firstIndex = 0;
   secondIndex = 1;
   constructor(params2) {
     super();
     this.params = params2;
     this.placements = params2.ctx.componentPlacements;
+    this.netLabelsByComponentId = this.buildNetLabelsByComponentId(params2.ctx.circuitJson);
     this.solved = this.placements.length < 2;
   }
   _step() {
     if (this.firstIndex >= this.placements.length - 1) {
+      this.buildAndPushIssues();
       this.solved = true;
       return;
     }
-    const overlap = this.getComponentOverlap(this.placements[this.firstIndex], this.placements[this.secondIndex]);
-    if (overlap)
-      this.params.issues.push(overlap);
+    const compA = this.placements[this.firstIndex];
+    const compB = this.placements[this.secondIndex];
+    this.detectPair(compA, compB);
     this.secondIndex++;
     if (this.secondIndex >= this.placements.length) {
       this.firstIndex++;
       this.secondIndex = this.firstIndex + 1;
     }
-    this.solved = this.firstIndex >= this.placements.length - 1;
   }
-  getCenteredRectBounds(box2) {
-    return {
-      left: box2.schX - box2.width / 2,
-      right: box2.schX + box2.width / 2,
-      top: box2.schY - box2.height / 2,
-      bottom: box2.schY + box2.height / 2
+  detectPair(compA, compB) {
+    if (compA.schematicSheetId !== compB.schematicSheetId)
+      return;
+    this.rawCollisions.push(...this.detectLabelLabel(compA, compB));
+    this.rawCollisions.push(...this.detectBoxLabel(compA, compB));
+    this.rawCollisions.push(...this.detectBoxLabel(compB, compA));
+  }
+  detectLabelLabel(firstComponent, secondComponent) {
+    let leftComp = firstComponent;
+    let rightComp = secondComponent;
+    if (firstComponent.schX > secondComponent.schX) {
+      leftComp = secondComponent;
+      rightComp = firstComponent;
+    }
+    const leftId = leftComp.schematicComponentId;
+    const rightId = rightComp.schematicComponentId;
+    if (!leftId || !rightId)
+      return [];
+    const leftLabels = this.netLabelsByComponentId.get(leftId) ?? [];
+    const rightLabels = this.netLabelsByComponentId.get(rightId) ?? [];
+    if (leftLabels.length === 0 || rightLabels.length === 0)
+      return [];
+    const hits = [];
+    for (const leftLabel of leftLabels) {
+      for (const rightLabel of rightLabels) {
+        const leftBounds = this.getNetLabelBounds(leftLabel);
+        const rightBounds = this.getNetLabelBounds(rightLabel);
+        if (rectOverlap(leftBounds, rightBounds)) {
+          hits.push({
+            type: "label-label",
+            leftComp,
+            rightComp,
+            leftId,
+            rightId,
+            xSeparation: leftBounds.right - rightBounds.left + 0.1
+          });
+        }
+      }
+    }
+    return hits;
+  }
+  detectBoxLabel(boxComp, labelComp) {
+    const boxId = boxComp.schematicComponentId;
+    const labelId = labelComp.schematicComponentId;
+    if (!boxId || !labelId)
+      return [];
+    const labels = this.netLabelsByComponentId.get(labelId) ?? [];
+    if (labels.length === 0)
+      return [];
+    const boxBounds = centeredRect(boxComp.schX, boxComp.schY, boxComp.width, boxComp.height);
+    const boxIsLeft = boxComp.schX <= labelComp.schX;
+    const hits = [];
+    for (const label of labels) {
+      const labelBounds = this.getNetLabelBounds(label);
+      if (!rectOverlap(boxBounds, labelBounds))
+        continue;
+      let xSeparation;
+      if (boxIsLeft) {
+        xSeparation = boxBounds.right - labelBounds.left + 0.1;
+      } else {
+        xSeparation = labelBounds.right - boxBounds.left + 0.1;
+      }
+      hits.push({
+        type: "box-label",
+        boxComp,
+        labelComp,
+        boxId,
+        labelId,
+        xSeparation
+      });
+    }
+    return hits;
+  }
+  buildAndPushIssues() {
+    if (this.rawCollisions.length === 0)
+      return;
+    const collisionsBySheet = new Map;
+    for (const collision of this.rawCollisions) {
+      const placement = collision.type === "label-label" ? collision.leftComp : collision.boxComp;
+      const sheetKey = placement.schematicSheetId ?? "";
+      const sheetCollisions = collisionsBySheet.get(sheetKey);
+      if (sheetCollisions)
+        sheetCollisions.push(collision);
+      else
+        collisionsBySheet.set(sheetKey, [collision]);
+    }
+    for (const collisions of collisionsBySheet.values()) {
+      this.buildAndPushIssueForSheet(collisions);
+    }
+  }
+  buildAndPushIssueForSheet(collisions) {
+    const globalFixes = this.computeGlobalFixes(collisions);
+    if (globalFixes.size === 0)
+      return;
+    const seenPairs = new Set;
+    const pairs3 = [];
+    for (const collision of collisions) {
+      let comp1Name;
+      let comp2Name;
+      if (collision.type === "label-label") {
+        comp1Name = collision.leftComp.sourceComponentName ?? "";
+        comp2Name = collision.rightComp.sourceComponentName ?? "";
+      } else {
+        comp1Name = collision.boxComp.sourceComponentName ?? "";
+        comp2Name = collision.labelComp.sourceComponentName ?? "";
+      }
+      const key = `${comp1Name}/${comp2Name}`;
+      if (!seenPairs.has(key)) {
+        seenPairs.add(key);
+        pairs3.push({ comp1Name, comp2Name });
+      }
+    }
+    const firstCollision = collisions[0];
+    const firstPlacement = firstCollision.type === "label-label" ? firstCollision.leftComp : firstCollision.boxComp;
+    this.params.issues.push({
+      lineItemType: "NetLabelCollision",
+      schematicSheetId: firstPlacement.schematicSheetId,
+      schematicSheetName: firstPlacement.schematicSheetName,
+      pairs: pairs3,
+      moves: Array.from(globalFixes.values())
+    });
+  }
+  computeGlobalFixes(collisions) {
+    const compById = new Map;
+    for (const placement of this.placements) {
+      if (placement.schematicComponentId)
+        compById.set(placement.schematicComponentId, placement);
+    }
+    const constraintMap = new Map;
+    const addConstraint = (leftId, rightId, xSeparation) => {
+      const leftComp = compById.get(leftId);
+      const rightComp = compById.get(rightId);
+      if (!leftComp || !rightComp)
+        return;
+      const minSep = rightComp.schX - leftComp.schX + xSeparation;
+      const key = `${leftId}|${rightId}`;
+      constraintMap.set(key, Math.max(constraintMap.get(key) ?? 0, minSep));
     };
+    for (const collision of collisions) {
+      if (collision.type === "label-label") {
+        addConstraint(collision.leftId, collision.rightId, collision.xSeparation);
+      } else if (collision.boxComp.schX <= collision.labelComp.schX) {
+        addConstraint(collision.boxId, collision.labelId, collision.xSeparation);
+      } else {
+        addConstraint(collision.labelId, collision.boxId, collision.xSeparation);
+      }
+    }
+    const constraints = [...constraintMap.entries()].map(([key, minSep]) => {
+      const pipeIndex = key.indexOf("|");
+      return {
+        leftId: key.slice(0, pipeIndex),
+        rightId: key.slice(pipeIndex + 1),
+        minSep
+      };
+    });
+    const allIds = new Set;
+    const adjacency = new Map;
+    for (const { leftId, rightId } of constraints) {
+      allIds.add(leftId);
+      allIds.add(rightId);
+      if (!adjacency.has(leftId))
+        adjacency.set(leftId, new Set);
+      if (!adjacency.has(rightId))
+        adjacency.set(rightId, new Set);
+      adjacency.get(leftId).add(rightId);
+      adjacency.get(rightId).add(leftId);
+    }
+    const visited = new Set;
+    const result = new Map;
+    for (const startId of allIds) {
+      if (visited.has(startId))
+        continue;
+      const group = [];
+      const queue = [startId];
+      visited.add(startId);
+      while (queue.length) {
+        const compId = queue.shift();
+        group.push(compId);
+        for (const neighbor of adjacency.get(compId) ?? []) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      group.sort((idA, idB) => (compById.get(idA)?.schX ?? 0) - (compById.get(idB)?.schX ?? 0));
+      const groupIds = new Set(group);
+      const groupConstraints = constraints.filter((c3) => groupIds.has(c3.leftId) && groupIds.has(c3.rightId));
+      const assigned = new Map;
+      for (const compId of group) {
+        let newX = compById.get(compId)?.schX ?? 0;
+        for (const { leftId, rightId, minSep } of groupConstraints) {
+          if (rightId === compId && assigned.has(leftId)) {
+            newX = Math.max(newX, assigned.get(leftId) + minSep);
+          }
+        }
+        assigned.set(compId, newX);
+      }
+      const totalPush = [...assigned.entries()].reduce((sum, [compId, newX]) => sum + (newX - (compById.get(compId)?.schX ?? 0)), 0);
+      if (totalPush > 0.000000001) {
+        const pullBack = totalPush / group.length;
+        const shifted = new Map;
+        for (const compId of group) {
+          let newX = (compById.get(compId)?.schX ?? 0) - pullBack;
+          for (const { leftId, rightId, minSep } of groupConstraints) {
+            if (rightId === compId && shifted.has(leftId)) {
+              newX = Math.max(newX, shifted.get(leftId) + minSep);
+            }
+          }
+          shifted.set(compId, newX);
+        }
+        const maxDisplacement = (positions) => [...positions.entries()].reduce((currentMax, [compId, newX]) => Math.max(currentMax, Math.abs(newX - (compById.get(compId)?.schX ?? 0))), 0);
+        if (maxDisplacement(shifted) < maxDisplacement(assigned)) {
+          for (const [compId, newX] of shifted)
+            assigned.set(compId, newX);
+        }
+      }
+      for (const [compId, newX] of assigned) {
+        const comp = compById.get(compId);
+        if (!comp || Math.abs(newX - comp.schX) < 0.000000001)
+          continue;
+        result.set(compId, {
+          componentName: comp.sourceComponentName ?? compId,
+          newSchX: Math.round(newX * 100) / 100,
+          newSchY: Math.round(comp.schY * 100) / 100
+        });
+      }
+    }
+    return result;
   }
-  getOverlapCorrectionSuggestions({
-    firstComponent,
-    secondComponent,
-    overlapWidth,
-    overlapHeight
-  }) {
-    const firstArea = firstComponent.width * firstComponent.height;
-    const secondArea = secondComponent.width * secondComponent.height;
-    const target = firstArea <= secondArea ? firstComponent : secondComponent;
-    const other = target === firstComponent ? secondComponent : firstComponent;
-    const deltaSchX = target.schX <= other.schX ? -overlapWidth : overlapWidth;
-    const deltaSchY = target.schY <= other.schY ? -overlapHeight : overlapHeight;
-    return [
-      {
-        targetComponentName: target.sourceComponentName,
-        deltaSchX,
-        deltaSchY: 0,
-        newSchX: target.schX + deltaSchX,
-        newSchY: target.schY
-      },
-      {
-        targetComponentName: target.sourceComponentName,
-        deltaSchX: 0,
-        deltaSchY,
-        newSchX: target.schX,
-        newSchY: target.schY + deltaSchY
+  buildNetLabelsByComponentId(circuitJson) {
+    const MATCH_EPSILON = 0.0001;
+    const portPositions = [];
+    for (const element of circuitJson) {
+      if (element.type !== "schematic_port")
+        continue;
+      const port = element;
+      if (!port.schematic_component_id)
+        continue;
+      portPositions.push({
+        componentId: port.schematic_component_id,
+        cx: port.center.x,
+        cy: port.center.y,
+        schematicSheetId: port.schematic_sheet_id
+      });
+    }
+    const result = new Map;
+    for (const element of circuitJson) {
+      if (element.type !== "schematic_net_label")
+        continue;
+      const label = element;
+      if (!label.anchor_position)
+        continue;
+      const { x: anchorX, y: anchorY } = label.anchor_position;
+      const matches = portPositions.filter((port) => port.schematicSheetId === label.schematic_sheet_id && Math.hypot(port.cx - anchorX, port.cy - anchorY) < MATCH_EPSILON);
+      if (matches.length === 0)
+        continue;
+      const componentIds = new Set(matches.map((match) => match.componentId));
+      if (componentIds.size !== 1)
+        continue;
+      const componentId = matches[0].componentId;
+      const labels = result.get(componentId) ?? [];
+      labels.push(label);
+      result.set(componentId, labels);
+    }
+    return result;
+  }
+  getNetLabelBounds(label) {
+    const anchorSide = label.anchor_side;
+    const isVertical3 = anchorSide === "top" || anchorSide === "bottom";
+    if (isVertical3) {
+      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 issueToString(issue) {
-    const attrs = [];
-    addAttr(attrs, "component1Name", issue.firstComponent.sourceComponentName);
-    addAttr(attrs, "component2Name", issue.secondComponent.sourceComponentName);
-    addAttr(attrs, "component1SchX", issue.firstComponent.schX);
-    addAttr(attrs, "component1SchY", issue.firstComponent.schY);
-    addAttr(attrs, "component2SchX", issue.secondComponent.schX);
-    addAttr(attrs, "component2SchY", issue.secondComponent.schY);
-    addAttr(attrs, "overlapWidth", issue.overlapWidth);
-    addAttr(attrs, "overlapHeight", issue.overlapHeight);
+  static netLabelCollisionToString(issue) {
+    const pairAttrs = issue.pairs.map((pair, i2) => `pair${i2 + 1}="${pair.comp1Name}/${pair.comp2Name}"`).join(" ");
+    const moves = issue.moves.map((move) => `    <Move componentName="${move.componentName}" newSchX="${move.newSchX}" newSchY="${move.newSchY}" />`);
     return [
-      `<ComponentOverlap ${attrs.join(" ")}>`,
-      ...issue.correctionSuggestions.map(SchematicBoxOverlapSolver.correctionSuggestionToString),
-      "</ComponentOverlap>"
+      `<ComponentNetLabelCollision ${pairAttrs}>`,
+      `  <SuggestedFix note="Apply all moves simultaneously. Set schAutoLayoutEnabled on your circuit.">`,
+      ...moves,
+      `  </SuggestedFix>`,
+      `</ComponentNetLabelCollision>`
     ].join(`
 `);
   }
-  static correctionSuggestionToString(suggestion) {
-    const attrs = [];
-    addAttr(attrs, "target", suggestion.targetComponentName);
-    if (suggestion.deltaSchX !== 0) {
-      addAttr(attrs, "newSchX", suggestion.newSchX);
-      addAttr(attrs, "deltaSchX", suggestion.deltaSchX, { formatDelta: true });
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver8 {
+  static ALIGNMENT_EPSILON = 0.01;
+  ctx;
+  out;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.ctx = ctx;
+    this.out = issues;
+  }
+  _step() {
+    const portsById = new Map(this.ctx.circuitJson.filter((el3) => el3.type === "schematic_port").map((port) => [port.schematic_port_id, port]));
+    const placementBySchematicComponentId = new Map(this.ctx.componentPlacements.flatMap((placement) => placement.schematicComponentId ? [[placement.schematicComponentId, placement]] : []));
+    const pinPairsByComponentPair = new Map;
+    for (const trace of this.ctx.circuitJson.filter((el3) => el3.type === "schematic_trace")) {
+      const pinPair = this.getTracePinPair(trace, portsById);
+      if (!pinPair)
+        continue;
+      const firstComponentId = pinPair.firstPort.schematic_component_id;
+      const secondComponentId = pinPair.secondPort.schematic_component_id;
+      if (!firstComponentId || !secondComponentId || firstComponentId === secondComponentId) {
+        continue;
+      }
+      const orderedPair = firstComponentId < secondComponentId ? pinPair : {
+        firstPort: pinPair.secondPort,
+        secondPort: pinPair.firstPort
+      };
+      const key = [firstComponentId, secondComponentId].sort().join("\x00");
+      const pairs3 = pinPairsByComponentPair.get(key) ?? [];
+      const isDuplicate = pairs3.some((pair) => pair.firstPort.schematic_port_id === orderedPair.firstPort.schematic_port_id && pair.secondPort.schematic_port_id === orderedPair.secondPort.schematic_port_id);
+      if (!isDuplicate)
+        pairs3.push(orderedPair);
+      pinPairsByComponentPair.set(key, pairs3);
     }
-    if (suggestion.deltaSchY !== 0) {
-      addAttr(attrs, "newSchY", suggestion.newSchY);
-      addAttr(attrs, "deltaSchY", suggestion.deltaSchY, { formatDelta: true });
+    for (const pinPairs of pinPairsByComponentPair.values()) {
+      const issue = this.findVerticalShiftIssue(pinPairs, placementBySchematicComponentId);
+      if (issue)
+        this.out.push(issue);
     }
-    return `<OverlapCorrectionSuggestion ${attrs.join(" ")} />`;
+    this.solved = true;
   }
-  getComponentOverlap(firstComponent, secondComponent) {
-    if (firstComponent.schematicSheetId !== secondComponent.schematicSheetId)
-      return null;
-    const a2 = this.getCenteredRectBounds(firstComponent);
-    const b3 = this.getCenteredRectBounds(secondComponent);
-    const overlapWidth = Math.min(a2.right, b3.right) - Math.max(a2.left, b3.left);
-    const overlapHeight = Math.min(a2.bottom, b3.bottom) - Math.max(a2.top, b3.top);
-    if (overlapWidth <= 0 || overlapHeight <= 0)
-      return null;
+  getTracePinPair(trace, portsById) {
+    const firstEdge = trace.edges?.[0];
+    const lastEdge = trace.edges?.at(-1);
+    if (!firstEdge || !lastEdge)
+      return;
+    const firstPortId = firstEdge.from_schematic_port_id ?? firstEdge.to_schematic_port_id;
+    const secondPortId = lastEdge.to_schematic_port_id ?? lastEdge.from_schematic_port_id;
+    const ports = [...portsById.values()];
+    const firstPort = firstPortId ? portsById.get(firstPortId) : this.findPortAtPoint(ports, firstEdge.from, trace.schematic_sheet_id);
+    const secondPort = secondPortId ? portsById.get(secondPortId) : this.findPortAtPoint(ports, lastEdge.to, trace.schematic_sheet_id);
+    if (!firstPort || !secondPort)
+      return;
+    if (firstPort.schematic_port_id === secondPort.schematic_port_id)
+      return;
+    if (firstPort.schematic_sheet_id !== secondPort.schematic_sheet_id)
+      return;
+    return { firstPort, secondPort };
+  }
+  findPortAtPoint(ports, point9, schematicSheetId) {
+    const { ALIGNMENT_EPSILON } = ComponentPinAlignmentSolver;
+    return ports.find((port) => port.schematic_sheet_id === schematicSheetId && Math.abs(port.center.x - point9.x) <= ALIGNMENT_EPSILON && Math.abs(port.center.y - point9.y) <= ALIGNMENT_EPSILON);
+  }
+  findVerticalShiftIssue(pinPairs, placementBySchematicComponentId) {
+    const firstPair = pinPairs[0];
+    if (!firstPair)
+      return;
+    const firstPlacement = placementBySchematicComponentId.get(firstPair.firstPort.schematic_component_id);
+    const secondPlacement = placementBySchematicComponentId.get(firstPair.secondPort.schematic_component_id);
+    if (!firstPlacement || !secondPlacement)
+      return;
+    const [leftPlacement, rightPlacement] = firstPlacement.schX <= secondPlacement.schX ? [firstPlacement, secondPlacement] : [secondPlacement, firstPlacement];
+    const horizontalPairs = pinPairs.flatMap((pair) => {
+      const [leftPort, rightPort] = pair.firstPort.center.x <= pair.secondPort.center.x ? [pair.firstPort, pair.secondPort] : [pair.secondPort, pair.firstPort];
+      return leftPort.facing_direction === "right" && rightPort.facing_direction === "left" ? [{ leftPort, rightPort }] : [];
+    });
+    if (horizontalPairs.length < 2)
+      return;
+    const { ALIGNMENT_EPSILON } = ComponentPinAlignmentSolver;
+    const currentlyAlignedPinCount = horizontalPairs.filter(({ leftPort, rightPort }) => Math.abs(leftPort.center.y - rightPort.center.y) <= ALIGNMENT_EPSILON).length;
+    const candidateGroups = [];
+    for (const pair of horizontalPairs) {
+      const deltaSchY2 = pair.leftPort.center.y - pair.rightPort.center.y;
+      if (Math.abs(deltaSchY2) <= ALIGNMENT_EPSILON)
+        continue;
+      const group = candidateGroups.find((candidate) => Math.abs(candidate.deltaSchY - deltaSchY2) <= ALIGNMENT_EPSILON);
+      if (group)
+        group.pairs.push(pair);
+      else
+        candidateGroups.push({ deltaSchY: deltaSchY2, pairs: [pair] });
+    }
+    const bestCandidate = candidateGroups.sort((a2, b3) => b3.pairs.length - a2.pairs.length || Math.abs(a2.deltaSchY) - Math.abs(b3.deltaSchY))[0];
+    if (!bestCandidate || bestCandidate.pairs.length < 2 || bestCandidate.pairs.length <= currentlyAlignedPinCount) {
+      return;
+    }
+    const targetName = rightPlacement.sourceComponentName ?? rightPlacement.schematicComponentId ?? "component";
+    const deltaSchY = bestCandidate.deltaSchY;
+    const newSchY = rightPlacement.schY + deltaSchY;
     return {
-      lineItemType: "ComponentOverlap",
-      firstComponent,
-      secondComponent,
-      overlapWidth,
-      overlapHeight,
-      correctionSuggestions: this.getOverlapCorrectionSuggestions({
-        firstComponent,
-        secondComponent,
-        overlapWidth,
-        overlapHeight
-      })
+      lineItemType: "ComponentPinsWouldAlignWithVerticalShift",
+      firstComponent: leftPlacement,
+      secondComponent: rightPlacement,
+      targetComponent: rightPlacement,
+      deltaSchY,
+      newSchY,
+      currentlyAlignedPinCount,
+      alignedPinCount: bestCandidate.pairs.length,
+      alignedPinPairs: bestCandidate.pairs.map(({ leftPort, rightPort }) => ({
+        firstPin: this.getPinLabel(leftPort),
+        secondPin: this.getPinLabel(rightPort)
+      })),
+      message: `shift ${targetName} vertically by ${fmtDelta(deltaSchY)} to align ${bestCandidate.pairs.length} connected pin pairs`
     };
   }
+  getPinLabel(port) {
+    return port.display_pin_label ?? port.pin_number?.toString();
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "firstComponentName", issue.firstComponent.sourceComponentName);
+    addAttr(attrs, "secondComponentName", issue.secondComponent.sourceComponentName);
+    addAttr(attrs, "targetComponentName", issue.targetComponent.sourceComponentName);
+    addAttr(attrs, "deltaSchY", issue.deltaSchY);
+    addAttr(attrs, "newSchY", issue.newSchY);
+    addAttr(attrs, "currentlyAlignedPinCount", issue.currentlyAlignedPinCount);
+    addAttr(attrs, "alignedPinCount", issue.alignedPinCount);
+    addAttr(attrs, "message", issue.message);
+    return `<ComponentPinsWouldAlignWithVerticalShift ${attrs.join(" ")} />`;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
+import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
+class DiodeResistorAlignmentSolver extends BaseSolver9 {
+  static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
+  ctx;
+  out;
+  schematicTraces;
+  currentIndex = 0;
+  sourceComponentFtypeById;
+  sourceComponentIdBySourcePortId;
+  schematicPorts;
+  schematicBoxBySourceComponentId;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.ctx = ctx;
+    this.out = issues;
+    const { circuitJson } = ctx;
+    this.sourceComponentFtypeById = this.buildSourceComponentFtypeById(circuitJson);
+    this.sourceComponentIdBySourcePortId = this.buildSourceComponentIdBySourcePortId(circuitJson);
+    this.schematicPorts = circuitJson.filter((el3) => el3.type === "schematic_port");
+    this.schematicBoxBySourceComponentId = this.buildSchematicBoxBySourceComponentId();
+    this.schematicTraces = circuitJson.filter((el3) => el3.type === "schematic_trace");
+    this.solved = this.schematicTraces.length === 0;
+  }
+  _step() {
+    const trace = this.schematicTraces[this.currentIndex];
+    if (!trace) {
+      this.solved = true;
+      return;
+    }
+    this.currentIndex++;
+    this.solved = this.currentIndex >= this.schematicTraces.length;
+    if (!trace.edges || trace.edges.length === 0)
+      return;
+    const firstEdge = trace.edges[0];
+    const lastEdge = trace.edges[trace.edges.length - 1];
+    if (!firstEdge || !lastEdge)
+      return;
+    const start = firstEdge.from;
+    const end = lastEdge.to;
+    const schematicSheetId = trace.schematic_sheet_id;
+    const startSourceCompId = this.findSourceComponentIdNearPoint(start, schematicSheetId);
+    const endSourceCompId = this.findSourceComponentIdNearPoint(end, schematicSheetId);
+    if (!startSourceCompId || !endSourceCompId)
+      return;
+    const startFtype = this.sourceComponentFtypeById.get(startSourceCompId);
+    const endFtype = this.sourceComponentFtypeById.get(endSourceCompId);
+    const { DIODE_FTYPES } = DiodeResistorAlignmentSolver;
+    const isDiodeResistorPair = DIODE_FTYPES.has(startFtype) && endFtype === "simple_resistor" || startFtype === "simple_resistor" && DIODE_FTYPES.has(endFtype);
+    if (!isDiodeResistorPair)
+      return;
+    const diodeCompId = DIODE_FTYPES.has(startFtype) ? startSourceCompId : endSourceCompId;
+    const resistorCompId = startFtype === "simple_resistor" ? startSourceCompId : endSourceCompId;
+    const diodeBox = this.schematicBoxBySourceComponentId.get(diodeCompId);
+    const resistorBox = this.schematicBoxBySourceComponentId.get(resistorCompId);
+    if (!diodeBox || !resistorBox)
+      return;
+    const diodePort = this.findNearestPort(DIODE_FTYPES.has(startFtype) ? start : end, schematicSheetId);
+    const resistorPort = this.findNearestPort(startFtype === "simple_resistor" ? start : end, schematicSheetId);
+    if (!diodePort?.center || !resistorPort?.center)
+      return;
+    const diodeName = diodeBox.sourceComponentName ?? diodeCompId;
+    const resistorName = resistorBox.sourceComponentName ?? resistorCompId;
+    const diodePin = diodePort?.display_pin_label ?? diodePort?.pin_number?.toString();
+    const resistorPin = resistorPort?.display_pin_label ?? resistorPort?.pin_number?.toString();
+    const diodeFacing = diodePort?.facing_direction;
+    const resistorFacing = resistorPort?.facing_direction;
+    const diodePinDesc = diodePin ? `${diodeName}.${diodePin}` : diodeName;
+    const resistorPinDesc = resistorPin ? `${resistorName}.${resistorPin}` : resistorName;
+    const makeIssue2 = (message) => ({
+      lineItemType: "DiodeResistorNotAligned",
+      diodeSchematicBox: diodeBox,
+      resistorSchematicBox: resistorBox,
+      diodePin,
+      resistorPin,
+      diodePinFacingDirection: diodeFacing,
+      resistorPinFacingDirection: resistorFacing,
+      message
+    });
+    if (!DiodeResistorAlignmentSolver.isCoLinear(diodePort.center, resistorPort.center)) {
+      this.out.push(makeIssue2(`trace has corners — align ${diodeName} and ${resistorName} on same axis and rotate so ${diodePinDesc} faces ${resistorPinDesc}`));
+      return;
+    }
+    if (diodeFacing && resistorFacing && !DiodeResistorAlignmentSolver.pinsFacingEachOther(diodePort.center, diodeFacing, resistorPort.center, resistorFacing)) {
+      this.out.push(makeIssue2(`${diodePinDesc} and ${resistorPinDesc} face away from each other — rotate ${diodeName} so ${diodePinDesc} faces ${resistorPinDesc}`));
+    }
+  }
+  static isCoLinear(a2, b3, epsilon = 0.01) {
+    return Math.abs(a2.x - b3.x) < epsilon || Math.abs(a2.y - b3.y) < epsilon;
+  }
+  static pinsFacingEachOther(aCenter, aFacing, bCenter, bFacing) {
+    const dx3 = bCenter.x - aCenter.x;
+    const dy3 = bCenter.y - aCenter.y;
+    const aToward = aFacing === "right" && dx3 > 0 || aFacing === "left" && dx3 < 0 || aFacing === "up" && dy3 > 0 || aFacing === "down" && dy3 < 0;
+    const bToward = bFacing === "right" && dx3 < 0 || bFacing === "left" && dx3 > 0 || bFacing === "up" && dy3 < 0 || bFacing === "down" && dy3 > 0;
+    return aToward && bToward;
+  }
+  static dist(a2, b3) {
+    return Math.sqrt((a2.x - b3.x) ** 2 + (a2.y - b3.y) ** 2);
+  }
+  findNearestPort(point9, schematicSheetId) {
+    let nearest;
+    let minDist = Infinity;
+    for (const port of this.schematicPorts) {
+      if (port.schematic_sheet_id !== schematicSheetId)
+        continue;
+      if (!port.center)
+        continue;
+      const d3 = DiodeResistorAlignmentSolver.dist(point9, port.center);
+      if (d3 < minDist) {
+        minDist = d3;
+        nearest = port;
+      }
+    }
+    return nearest;
+  }
+  findSourceComponentIdNearPoint(point9, schematicSheetId) {
+    const nearest = this.findNearestPort(point9, schematicSheetId);
+    if (!nearest || !nearest.source_port_id)
+      return;
+    return this.sourceComponentIdBySourcePortId.get(nearest.source_port_id);
+  }
+  buildSourceComponentFtypeById(circuitJson) {
+    const map = new Map;
+    for (const el3 of circuitJson) {
+      if (el3.type === "source_component" && "source_component_id" in el3 && "ftype" in el3 && typeof el3.ftype === "string") {
+        map.set(el3.source_component_id, el3.ftype);
+      }
+    }
+    return map;
+  }
+  buildSourceComponentIdBySourcePortId(circuitJson) {
+    const map = new Map;
+    for (const el3 of circuitJson) {
+      if (el3.type === "source_port" && "source_port_id" in el3 && "source_component_id" in el3 && typeof el3.source_port_id === "string" && typeof el3.source_component_id === "string") {
+        map.set(el3.source_port_id, el3.source_component_id);
+      }
+    }
+    return map;
+  }
+  buildSchematicBoxBySourceComponentId() {
+    const map = new Map;
+    for (const placement of this.ctx.componentPlacements) {
+      if (placement.sourceComponentId) {
+        map.set(placement.sourceComponentId, placement);
+      }
+    }
+    return map;
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "diodeComponentName", issue.diodeSchematicBox.sourceComponentName);
+    addAttr(attrs, "diodePin", issue.diodePin);
+    addAttr(attrs, "resistorComponentName", issue.resistorSchematicBox.sourceComponentName);
+    addAttr(attrs, "resistorPin", issue.resistorPin);
+    addAttr(attrs, "message", issue.message);
+    return `<DiodeResistorNotAligned ${attrs.join(" ")} />`;
+  }
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver8 {
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver10 {
   params;
   MESSAGE = "Inner labels are colliding. Increase the schWidth or schHeight.";
   PIN_LABEL_EDGE_PADDING = 0.1;
@@ -302394,9 +302832,129 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver8 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver11 {
+  params;
+  placements;
+  firstIndex = 0;
+  secondIndex = 1;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.placements = params2.ctx.componentPlacements;
+    this.solved = this.placements.length < 2;
+  }
+  _step() {
+    if (this.firstIndex >= this.placements.length - 1) {
+      this.solved = true;
+      return;
+    }
+    const overlap = this.getComponentOverlap(this.placements[this.firstIndex], this.placements[this.secondIndex]);
+    if (overlap)
+      this.params.issues.push(overlap);
+    this.secondIndex++;
+    if (this.secondIndex >= this.placements.length) {
+      this.firstIndex++;
+      this.secondIndex = this.firstIndex + 1;
+    }
+    this.solved = this.firstIndex >= this.placements.length - 1;
+  }
+  getCenteredRectBounds(box2) {
+    return {
+      left: box2.schX - box2.width / 2,
+      right: box2.schX + box2.width / 2,
+      top: box2.schY - box2.height / 2,
+      bottom: box2.schY + box2.height / 2
+    };
+  }
+  getOverlapCorrectionSuggestions({
+    firstComponent,
+    secondComponent,
+    overlapWidth,
+    overlapHeight
+  }) {
+    const firstArea = firstComponent.width * firstComponent.height;
+    const secondArea = secondComponent.width * secondComponent.height;
+    const target = firstArea <= secondArea ? firstComponent : secondComponent;
+    const other = target === firstComponent ? secondComponent : firstComponent;
+    const deltaSchX = target.schX <= other.schX ? -overlapWidth : overlapWidth;
+    const deltaSchY = target.schY <= other.schY ? -overlapHeight : overlapHeight;
+    return [
+      {
+        targetComponentName: target.sourceComponentName,
+        deltaSchX,
+        deltaSchY: 0,
+        newSchX: target.schX + deltaSchX,
+        newSchY: target.schY
+      },
+      {
+        targetComponentName: target.sourceComponentName,
+        deltaSchX: 0,
+        deltaSchY,
+        newSchX: target.schX,
+        newSchY: target.schY + deltaSchY
+      }
+    ];
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "component1Name", issue.firstComponent.sourceComponentName);
+    addAttr(attrs, "component2Name", issue.secondComponent.sourceComponentName);
+    addAttr(attrs, "component1SchX", issue.firstComponent.schX);
+    addAttr(attrs, "component1SchY", issue.firstComponent.schY);
+    addAttr(attrs, "component2SchX", issue.secondComponent.schX);
+    addAttr(attrs, "component2SchY", issue.secondComponent.schY);
+    addAttr(attrs, "overlapWidth", issue.overlapWidth);
+    addAttr(attrs, "overlapHeight", issue.overlapHeight);
+    return [
+      `<ComponentOverlap ${attrs.join(" ")}>`,
+      ...issue.correctionSuggestions.map(SchematicBoxOverlapSolver.correctionSuggestionToString),
+      "</ComponentOverlap>"
+    ].join(`
+`);
+  }
+  static correctionSuggestionToString(suggestion) {
+    const attrs = [];
+    addAttr(attrs, "target", suggestion.targetComponentName);
+    if (suggestion.deltaSchX !== 0) {
+      addAttr(attrs, "newSchX", suggestion.newSchX);
+      addAttr(attrs, "deltaSchX", suggestion.deltaSchX, { formatDelta: true });
+    }
+    if (suggestion.deltaSchY !== 0) {
+      addAttr(attrs, "newSchY", suggestion.newSchY);
+      addAttr(attrs, "deltaSchY", suggestion.deltaSchY, { formatDelta: true });
+    }
+    return `<OverlapCorrectionSuggestion ${attrs.join(" ")} />`;
+  }
+  getComponentOverlap(firstComponent, secondComponent) {
+    if (firstComponent.schematicSheetId !== secondComponent.schematicSheetId)
+      return null;
+    const a2 = this.getCenteredRectBounds(firstComponent);
+    const b3 = this.getCenteredRectBounds(secondComponent);
+    const overlapWidth = Math.min(a2.right, b3.right) - Math.max(a2.left, b3.left);
+    const overlapHeight = Math.min(a2.bottom, b3.bottom) - Math.max(a2.top, b3.top);
+    if (overlapWidth <= 0 || overlapHeight <= 0)
+      return null;
+    return {
+      lineItemType: "ComponentOverlap",
+      firstComponent,
+      secondComponent,
+      overlapWidth,
+      overlapHeight,
+      correctionSuggestions: this.getOverlapCorrectionSuggestions({
+        firstComponent,
+        secondComponent,
+        overlapWidth,
+        overlapHeight
+      })
+    };
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver9 {
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver12 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
@@ -302571,8 +303129,8 @@ class SchematicBoxTooWideSolver extends BaseSolver9 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver10 {
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver13 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
   PIN_NAME_CHARACTER_WIDTH = 0.095;
@@ -302800,9 +303358,349 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver10 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
+import {
+  BasePipelineSolver as BasePipelineSolver2,
+  definePipelineStep as definePipelineStep3
+} from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/placements.ts
+import { cju as cju7 } from "@tscircuit/circuit-json-util";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/schematic-sheets.ts
+var getSchematicSheetNamesById = (circuitJson) => {
+  const map = new Map;
+  for (const element of circuitJson) {
+    if (element.type === "schematic_sheet" && element.name) {
+      map.set(element.schematic_sheet_id, element.name);
+    }
+  }
+  return map;
+};
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/placements.ts
+var isSchematicBox = (el3) => el3.type === "schematic_box";
+var isSchematicComponent = (el3) => el3.type === "schematic_component";
+var getSchematicSheetId = (el3) => el3.schematic_sheet_id;
+var getSourceComponentName = (circuitJson, sourceComponentId) => {
+  if (!sourceComponentId)
+    return;
+  return cju7(circuitJson).source_component.get(sourceComponentId)?.name;
+};
+var getSourceComponentMetadata = (schematicBox, circuitJson) => {
+  if (!schematicBox.schematic_component_id)
+    return {};
+  const util2 = cju7(circuitJson);
+  const sc2 = util2.schematic_component.get(schematicBox.schematic_component_id);
+  if (!sc2?.source_component_id)
+    return {};
+  const sourceComponent = util2.source_component.get(sc2.source_component_id);
+  return {
+    sourceComponentId: sc2.source_component_id,
+    sourceComponentName: sourceComponent?.name
+  };
+};
+var schematicComponentToPlacement = (schematicComponent, circuitJson, schematicSheetNameById, schematicBox) => {
+  let schematicSheetId = getSchematicSheetId(schematicComponent);
+  if (schematicSheetId === undefined && schematicBox) {
+    schematicSheetId = getSchematicSheetId(schematicBox);
+  }
+  let schematicSheetName;
+  if (schematicSheetId) {
+    schematicSheetName = schematicSheetNameById.get(schematicSheetId);
+  }
+  const placement = {
+    lineItemType: "SchematicBoxPlacement",
+    positionAnchor: "center",
+    schX: schematicComponent.center.x,
+    schY: schematicComponent.center.y,
+    width: schematicBox?.width ?? schematicComponent.size.width,
+    height: schematicBox?.height ?? schematicComponent.size.height,
+    sourceComponentId: schematicComponent.source_component_id,
+    sourceComponentName: getSourceComponentName(circuitJson, schematicComponent.source_component_id),
+    schematicComponentId: schematicComponent.schematic_component_id,
+    schematicSymbolId: schematicBox?.schematic_symbol_id ?? schematicComponent.schematic_symbol_id,
+    subcircuitId: schematicComponent.subcircuit_id ?? schematicBox?.subcircuit_id
+  };
+  if (schematicSheetId) {
+    placement.schematicSheetId = schematicSheetId;
+  }
+  if (schematicSheetName) {
+    placement.schematicSheetName = schematicSheetName;
+  }
+  return placement;
+};
+var schematicBoxToPlacement = (schematicBox, circuitJson, schematicSheetNameById) => {
+  const schematicSheetId = getSchematicSheetId(schematicBox);
+  let schematicSheetName;
+  if (schematicSheetId) {
+    schematicSheetName = schematicSheetNameById.get(schematicSheetId);
+  }
+  const placement = {
+    lineItemType: "SchematicBoxPlacement",
+    positionAnchor: "center",
+    schX: schematicBox.x,
+    schY: schematicBox.y,
+    width: schematicBox.width,
+    height: schematicBox.height,
+    ...getSourceComponentMetadata(schematicBox, circuitJson),
+    schematicComponentId: schematicBox.schematic_component_id,
+    schematicSymbolId: schematicBox.schematic_symbol_id,
+    subcircuitId: schematicBox.subcircuit_id
+  };
+  if (schematicSheetId) {
+    placement.schematicSheetId = schematicSheetId;
+  }
+  if (schematicSheetName) {
+    placement.schematicSheetName = schematicSheetName;
+  }
+  return placement;
+};
+var buildSolverContext = (circuitJson) => {
+  const schematicBoxes = circuitJson.filter(isSchematicBox);
+  const schematicSheetNameById = getSchematicSheetNamesById(circuitJson);
+  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent).map((sc2) => sc2.schematic_component_id));
+  const componentPlacements = [
+    ...circuitJson.filter(isSchematicComponent).map((sc2) => schematicComponentToPlacement(sc2, circuitJson, schematicSheetNameById, schematicBoxes.find((sb3) => sb3.schematic_component_id === sc2.schematic_component_id))),
+    ...schematicBoxes.filter((sb3) => !sb3.schematic_component_id || !schematicComponentIds.has(sb3.schematic_component_id)).map((sb3) => schematicBoxToPlacement(sb3, circuitJson, schematicSheetNameById))
+  ];
+  return { circuitJson, componentPlacements };
+};
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver14 {
+  static EPSILON = 0.01;
+  ctx;
+  out;
+  constructor({
+    ctx,
+    issues
+  }) {
+    super();
+    this.ctx = ctx;
+    this.out = issues;
+  }
+  _step() {
+    const ports = this.ctx.circuitJson.filter((element) => element.type === "schematic_port");
+    const portsById = new Map(ports.map((port) => [port.schematic_port_id, port]));
+    const placementsByComponentId = new Map(this.ctx.componentPlacements.flatMap((placement) => placement.schematicComponentId ? [[placement.schematicComponentId, placement]] : []));
+    const emittedMoves = new Set;
+    for (const trace of this.ctx.circuitJson.filter((element) => element.type === "schematic_trace")) {
+      const points = this.getTracePoints(trace);
+      const currentTurnCount = this.countTurns(points);
+      if (currentTurnCount !== 3)
+        continue;
+      const candidates = [
+        this.getCandidate({
+          trace,
+          points,
+          atStart: true,
+          currentTurnCount,
+          ports,
+          portsById,
+          placementsByComponentId
+        }),
+        this.getCandidate({
+          trace,
+          points,
+          atStart: false,
+          currentTurnCount,
+          ports,
+          portsById,
+          placementsByComponentId
+        })
+      ].filter((candidate) => Boolean(candidate));
+      for (const candidate of candidates) {
+        if (this.wouldOverlapAnotherComponent(candidate))
+          continue;
+        const moveKey = [
+          candidate.target.schematicComponentId,
+          candidate.deltaSchX.toFixed(3),
+          candidate.deltaSchY.toFixed(3)
+        ].join("\x00");
+        if (emittedMoves.has(moveKey))
+          continue;
+        emittedMoves.add(moveKey);
+        this.out.push(this.makeIssue(trace, candidate));
+      }
+    }
+    this.solved = true;
+  }
+  getCandidate({
+    trace,
+    points,
+    atStart,
+    currentTurnCount,
+    ports,
+    portsById,
+    placementsByComponentId
+  }) {
+    if (points.length < 4)
+      return;
+    const terminalIndex = atStart ? 0 : points.length - 1;
+    const leadIndex = atStart ? 1 : points.length - 2;
+    const acrossIndex = atStart ? 2 : points.length - 3;
+    const retainedIndex = atStart ? 3 : points.length - 4;
+    const terminalPoint = points[terminalIndex];
+    const leadPoint = points[leadIndex];
+    const acrossPoint = points[acrossIndex];
+    const retainedPoint = points[retainedIndex];
+    const terminalEdge = atStart ? trace.edges[0] : trace.edges.at(-1);
+    if (!terminalEdge)
+      return;
+    const portId = atStart ? terminalEdge.from_schematic_port_id : terminalEdge.to_schematic_port_id;
+    const port = portId ? portsById.get(portId) : this.findPortAtPoint(ports, terminalPoint, trace.schematic_sheet_id);
+    if (!port?.schematic_component_id || !port.facing_direction)
+      return;
+    const leadAxis = this.getAxis(terminalPoint, leadPoint);
+    const shiftAxis = this.getAxis(leadPoint, acrossPoint);
+    const retainedAxis = this.getAxis(acrossPoint, retainedPoint);
+    const portAxis = port.facing_direction === "left" || port.facing_direction === "right" ? "horizontal" : "vertical";
+    if (!leadAxis || !shiftAxis || !retainedAxis)
+      return;
+    if (leadAxis !== portAxis || shiftAxis === portAxis || retainedAxis !== portAxis) {
+      return;
+    }
+    if (!this.isPointInFacingDirection(terminalPoint, leadPoint, port.facing_direction) || !this.isPointInFacingDirection(acrossPoint, retainedPoint, port.facing_direction)) {
+      return;
+    }
+    const target = placementsByComponentId.get(port.schematic_component_id);
+    if (!target)
+      return;
+    const deltaSchX = acrossPoint.x - leadPoint.x;
+    const deltaSchY = acrossPoint.y - leadPoint.y;
+    if (Math.abs(deltaSchX) <= TraceSimplificationSolver.EPSILON && Math.abs(deltaSchY) <= TraceSimplificationSolver.EPSILON) {
+      return;
+    }
+    const movedTerminalPoint = {
+      x: terminalPoint.x + deltaSchX,
+      y: terminalPoint.y + deltaSchY
+    };
+    const suggestedPoints = atStart ? [movedTerminalPoint, ...points.slice(2)] : [...points.slice(0, -2), movedTerminalPoint];
+    const suggestedTurnCount = this.countTurns(suggestedPoints);
+    if (suggestedTurnCount === undefined || suggestedTurnCount !== 1 || suggestedTurnCount >= currentTurnCount) {
+      return;
+    }
+    return {
+      target,
+      deltaSchX,
+      deltaSchY,
+      currentTurnCount,
+      suggestedTurnCount
+    };
+  }
+  getTracePoints(trace) {
+    const firstEdge = trace.edges[0];
+    if (!firstEdge)
+      return [];
+    const points = [firstEdge.from];
+    for (const edge of trace.edges) {
+      const previousPoint = points.at(-1);
+      if (!this.pointsEqual(previousPoint, edge.from))
+        return [];
+      points.push(edge.to);
+    }
+    return points;
+  }
+  countTurns(points) {
+    const axes = [];
+    for (const [index, point9] of points.slice(1).entries()) {
+      const previousPoint = points[index];
+      if (this.pointsEqual(previousPoint, point9))
+        continue;
+      const axis = this.getAxis(previousPoint, point9);
+      if (!axis)
+        return;
+      axes.push(axis);
+    }
+    return axes.slice(1).filter((axis, index) => axis !== axes[index]).length;
+  }
+  pointsEqual(a2, b3) {
+    const { EPSILON: EPSILON3 } = TraceSimplificationSolver;
+    return Math.abs(a2.x - b3.x) <= EPSILON3 && Math.abs(a2.y - b3.y) <= EPSILON3;
+  }
+  getAxis(a2, b3) {
+    const dx3 = Math.abs(b3.x - a2.x);
+    const dy3 = Math.abs(b3.y - a2.y);
+    const { EPSILON: EPSILON3 } = TraceSimplificationSolver;
+    if (dx3 <= EPSILON3 && dy3 > EPSILON3)
+      return "vertical";
+    if (dy3 <= EPSILON3 && dx3 > EPSILON3)
+      return "horizontal";
+    return;
+  }
+  isPointInFacingDirection(origin, point9, facingDirection) {
+    const { EPSILON: EPSILON3 } = TraceSimplificationSolver;
+    switch (facingDirection) {
+      case "left":
+        return point9.x < origin.x - EPSILON3;
+      case "right":
+        return point9.x > origin.x + EPSILON3;
+      case "up":
+        return point9.y > origin.y + EPSILON3;
+      case "down":
+        return point9.y < origin.y - EPSILON3;
+    }
+  }
+  findPortAtPoint(ports, point9, schematicSheetId) {
+    const { EPSILON: EPSILON3 } = TraceSimplificationSolver;
+    return ports.find((port) => port.schematic_sheet_id === schematicSheetId && Math.abs(port.center.x - point9.x) <= EPSILON3 && Math.abs(port.center.y - point9.y) <= EPSILON3);
+  }
+  wouldOverlapAnotherComponent(candidate) {
+    const movedBounds = centeredRect(candidate.target.schX + candidate.deltaSchX, candidate.target.schY + candidate.deltaSchY, candidate.target.width, candidate.target.height);
+    return this.ctx.componentPlacements.some((placement) => {
+      if (placement === candidate.target)
+        return false;
+      if (placement.schematicSheetId !== candidate.target.schematicSheetId) {
+        return false;
+      }
+      return Boolean(rectOverlap(movedBounds, centeredRect(placement.schX, placement.schY, placement.width, placement.height)));
+    });
+  }
+  makeIssue(trace, candidate) {
+    const targetName = candidate.target.sourceComponentName ?? candidate.target.schematicComponentId ?? "component";
+    const direction2 = this.getMoveDirection(candidate.deltaSchX, candidate.deltaSchY);
+    const distance49 = Math.abs(candidate.deltaSchX || candidate.deltaSchY);
+    const newSchX = candidate.target.schX + candidate.deltaSchX;
+    const newSchY = candidate.target.schY + candidate.deltaSchY;
+    return {
+      lineItemType: "TraceCanBeSimplifiedByMovingComponent",
+      schematicTraceId: trace.schematic_trace_id,
+      targetComponent: candidate.target,
+      deltaSchX: candidate.deltaSchX,
+      deltaSchY: candidate.deltaSchY,
+      newSchX,
+      newSchY,
+      currentTurnCount: candidate.currentTurnCount,
+      suggestedTurnCount: candidate.suggestedTurnCount,
+      message: `move ${targetName} ${direction2} by ${fmtNumber5(distance49)} (to schX=${fmtNumber5(newSchX)}, schY=${fmtNumber5(newSchY)}) to reduce this trace from ${candidate.currentTurnCount} turns to ${candidate.suggestedTurnCount}`
+    };
+  }
+  getMoveDirection(deltaSchX, deltaSchY) {
+    if (Math.abs(deltaSchX) > TraceSimplificationSolver.EPSILON) {
+      return deltaSchX > 0 ? "right" : "left";
+    }
+    return deltaSchY > 0 ? "up" : "down";
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "schematicTraceId", issue.schematicTraceId);
+    addAttr(attrs, "targetComponentName", issue.targetComponent.sourceComponentName);
+    addAttr(attrs, "deltaSchX", issue.deltaSchX, { formatDelta: true });
+    addAttr(attrs, "deltaSchY", issue.deltaSchY, { formatDelta: true });
+    addAttr(attrs, "newSchX", issue.newSchX);
+    addAttr(attrs, "newSchY", issue.newSchY);
+    addAttr(attrs, "currentTurnCount", issue.currentTurnCount);
+    addAttr(attrs, "suggestedTurnCount", issue.suggestedTurnCount);
+    addAttr(attrs, "message", issue.message);
+    return `<TraceCanBeSimplifiedByMovingComponent ${attrs.join(" ")} />`;
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver11 {
+import { BaseSolver as BaseSolver15 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver15 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -302910,650 +303808,6 @@ class VerboseNetLabelSolver extends BaseSolver11 {
   }
 }
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
-import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
-class DiodeResistorAlignmentSolver extends BaseSolver12 {
-  static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
-  ctx;
-  out;
-  schematicTraces;
-  currentIndex = 0;
-  sourceComponentFtypeById;
-  sourceComponentIdBySourcePortId;
-  schematicPorts;
-  schematicBoxBySourceComponentId;
-  constructor({
-    ctx,
-    issues
-  }) {
-    super();
-    this.ctx = ctx;
-    this.out = issues;
-    const { circuitJson } = ctx;
-    this.sourceComponentFtypeById = this.buildSourceComponentFtypeById(circuitJson);
-    this.sourceComponentIdBySourcePortId = this.buildSourceComponentIdBySourcePortId(circuitJson);
-    this.schematicPorts = circuitJson.filter((el3) => el3.type === "schematic_port");
-    this.schematicBoxBySourceComponentId = this.buildSchematicBoxBySourceComponentId();
-    this.schematicTraces = circuitJson.filter((el3) => el3.type === "schematic_trace");
-    this.solved = this.schematicTraces.length === 0;
-  }
-  _step() {
-    const trace = this.schematicTraces[this.currentIndex];
-    if (!trace) {
-      this.solved = true;
-      return;
-    }
-    this.currentIndex++;
-    this.solved = this.currentIndex >= this.schematicTraces.length;
-    if (!trace.edges || trace.edges.length === 0)
-      return;
-    const firstEdge = trace.edges[0];
-    const lastEdge = trace.edges[trace.edges.length - 1];
-    if (!firstEdge || !lastEdge)
-      return;
-    const start = firstEdge.from;
-    const end = lastEdge.to;
-    const schematicSheetId = trace.schematic_sheet_id;
-    const startSourceCompId = this.findSourceComponentIdNearPoint(start, schematicSheetId);
-    const endSourceCompId = this.findSourceComponentIdNearPoint(end, schematicSheetId);
-    if (!startSourceCompId || !endSourceCompId)
-      return;
-    const startFtype = this.sourceComponentFtypeById.get(startSourceCompId);
-    const endFtype = this.sourceComponentFtypeById.get(endSourceCompId);
-    const { DIODE_FTYPES } = DiodeResistorAlignmentSolver;
-    const isDiodeResistorPair = DIODE_FTYPES.has(startFtype) && endFtype === "simple_resistor" || startFtype === "simple_resistor" && DIODE_FTYPES.has(endFtype);
-    if (!isDiodeResistorPair)
-      return;
-    const diodeCompId = DIODE_FTYPES.has(startFtype) ? startSourceCompId : endSourceCompId;
-    const resistorCompId = startFtype === "simple_resistor" ? startSourceCompId : endSourceCompId;
-    const diodeBox = this.schematicBoxBySourceComponentId.get(diodeCompId);
-    const resistorBox = this.schematicBoxBySourceComponentId.get(resistorCompId);
-    if (!diodeBox || !resistorBox)
-      return;
-    const diodePort = this.findNearestPort(DIODE_FTYPES.has(startFtype) ? start : end, schematicSheetId);
-    const resistorPort = this.findNearestPort(startFtype === "simple_resistor" ? start : end, schematicSheetId);
-    if (!diodePort?.center || !resistorPort?.center)
-      return;
-    const diodeName = diodeBox.sourceComponentName ?? diodeCompId;
-    const resistorName = resistorBox.sourceComponentName ?? resistorCompId;
-    const diodePin = diodePort?.display_pin_label ?? diodePort?.pin_number?.toString();
-    const resistorPin = resistorPort?.display_pin_label ?? resistorPort?.pin_number?.toString();
-    const diodeFacing = diodePort?.facing_direction;
-    const resistorFacing = resistorPort?.facing_direction;
-    const diodePinDesc = diodePin ? `${diodeName}.${diodePin}` : diodeName;
-    const resistorPinDesc = resistorPin ? `${resistorName}.${resistorPin}` : resistorName;
-    const makeIssue2 = (message) => ({
-      lineItemType: "DiodeResistorNotAligned",
-      diodeSchematicBox: diodeBox,
-      resistorSchematicBox: resistorBox,
-      diodePin,
-      resistorPin,
-      diodePinFacingDirection: diodeFacing,
-      resistorPinFacingDirection: resistorFacing,
-      message
-    });
-    if (!DiodeResistorAlignmentSolver.isCoLinear(diodePort.center, resistorPort.center)) {
-      this.out.push(makeIssue2(`trace has corners — align ${diodeName} and ${resistorName} on same axis and rotate so ${diodePinDesc} faces ${resistorPinDesc}`));
-      return;
-    }
-    if (diodeFacing && resistorFacing && !DiodeResistorAlignmentSolver.pinsFacingEachOther(diodePort.center, diodeFacing, resistorPort.center, resistorFacing)) {
-      this.out.push(makeIssue2(`${diodePinDesc} and ${resistorPinDesc} face away from each other — rotate ${diodeName} so ${diodePinDesc} faces ${resistorPinDesc}`));
-    }
-  }
-  static isCoLinear(a2, b3, epsilon = 0.01) {
-    return Math.abs(a2.x - b3.x) < epsilon || Math.abs(a2.y - b3.y) < epsilon;
-  }
-  static pinsFacingEachOther(aCenter, aFacing, bCenter, bFacing) {
-    const dx3 = bCenter.x - aCenter.x;
-    const dy3 = bCenter.y - aCenter.y;
-    const aToward = aFacing === "right" && dx3 > 0 || aFacing === "left" && dx3 < 0 || aFacing === "up" && dy3 > 0 || aFacing === "down" && dy3 < 0;
-    const bToward = bFacing === "right" && dx3 < 0 || bFacing === "left" && dx3 > 0 || bFacing === "up" && dy3 < 0 || bFacing === "down" && dy3 > 0;
-    return aToward && bToward;
-  }
-  static dist(a2, b3) {
-    return Math.sqrt((a2.x - b3.x) ** 2 + (a2.y - b3.y) ** 2);
-  }
-  findNearestPort(point9, schematicSheetId) {
-    let nearest;
-    let minDist = Infinity;
-    for (const port of this.schematicPorts) {
-      if (port.schematic_sheet_id !== schematicSheetId)
-        continue;
-      if (!port.center)
-        continue;
-      const d3 = DiodeResistorAlignmentSolver.dist(point9, port.center);
-      if (d3 < minDist) {
-        minDist = d3;
-        nearest = port;
-      }
-    }
-    return nearest;
-  }
-  findSourceComponentIdNearPoint(point9, schematicSheetId) {
-    const nearest = this.findNearestPort(point9, schematicSheetId);
-    if (!nearest || !nearest.source_port_id)
-      return;
-    return this.sourceComponentIdBySourcePortId.get(nearest.source_port_id);
-  }
-  buildSourceComponentFtypeById(circuitJson) {
-    const map = new Map;
-    for (const el3 of circuitJson) {
-      if (el3.type === "source_component" && "source_component_id" in el3 && "ftype" in el3 && typeof el3.ftype === "string") {
-        map.set(el3.source_component_id, el3.ftype);
-      }
-    }
-    return map;
-  }
-  buildSourceComponentIdBySourcePortId(circuitJson) {
-    const map = new Map;
-    for (const el3 of circuitJson) {
-      if (el3.type === "source_port" && "source_port_id" in el3 && "source_component_id" in el3 && typeof el3.source_port_id === "string" && typeof el3.source_component_id === "string") {
-        map.set(el3.source_port_id, el3.source_component_id);
-      }
-    }
-    return map;
-  }
-  buildSchematicBoxBySourceComponentId() {
-    const map = new Map;
-    for (const placement of this.ctx.componentPlacements) {
-      if (placement.sourceComponentId) {
-        map.set(placement.sourceComponentId, placement);
-      }
-    }
-    return map;
-  }
-  static issueToString(issue) {
-    const attrs = [];
-    addAttr(attrs, "diodeComponentName", issue.diodeSchematicBox.sourceComponentName);
-    addAttr(attrs, "diodePin", issue.diodePin);
-    addAttr(attrs, "resistorComponentName", issue.resistorSchematicBox.sourceComponentName);
-    addAttr(attrs, "resistorPin", issue.resistorPin);
-    addAttr(attrs, "message", issue.message);
-    return `<DiodeResistorNotAligned ${attrs.join(" ")} />`;
-  }
-}
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
-function centeredRect(cx3, cy3, w4, h4) {
-  return {
-    left: cx3 - w4 / 2,
-    right: cx3 + w4 / 2,
-    top: cy3 + h4 / 2,
-    bottom: cy3 - h4 / 2
-  };
-}
-function rectOverlap(a2, b3) {
-  const ow2 = Math.min(a2.right, b3.right) - Math.max(a2.left, b3.left);
-  const oh2 = Math.min(a2.top, b3.top) - Math.max(a2.bottom, b3.bottom);
-  return ow2 > 0 && oh2 > 0 ? { ow: ow2, oh: oh2 } : null;
-}
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-class ComponentNetLabelCollisionSolver extends BaseSolver13 {
-  params;
-  LABEL_HALF_HEIGHT = 0.1;
-  LABEL_BOUNDS_SLACK = 0.1;
-  SCH_CHAR_WIDTH = 0.13;
-  placements;
-  netLabelsByComponentId;
-  rawCollisions = [];
-  firstIndex = 0;
-  secondIndex = 1;
-  constructor(params2) {
-    super();
-    this.params = params2;
-    this.placements = params2.ctx.componentPlacements;
-    this.netLabelsByComponentId = this.buildNetLabelsByComponentId(params2.ctx.circuitJson);
-    this.solved = this.placements.length < 2;
-  }
-  _step() {
-    if (this.firstIndex >= this.placements.length - 1) {
-      this.buildAndPushIssues();
-      this.solved = true;
-      return;
-    }
-    const compA = this.placements[this.firstIndex];
-    const compB = this.placements[this.secondIndex];
-    this.detectPair(compA, compB);
-    this.secondIndex++;
-    if (this.secondIndex >= this.placements.length) {
-      this.firstIndex++;
-      this.secondIndex = this.firstIndex + 1;
-    }
-  }
-  detectPair(compA, compB) {
-    if (compA.schematicSheetId !== compB.schematicSheetId)
-      return;
-    this.rawCollisions.push(...this.detectLabelLabel(compA, compB));
-    this.rawCollisions.push(...this.detectBoxLabel(compA, compB));
-    this.rawCollisions.push(...this.detectBoxLabel(compB, compA));
-  }
-  detectLabelLabel(firstComponent, secondComponent) {
-    let leftComp = firstComponent;
-    let rightComp = secondComponent;
-    if (firstComponent.schX > secondComponent.schX) {
-      leftComp = secondComponent;
-      rightComp = firstComponent;
-    }
-    const leftId = leftComp.schematicComponentId;
-    const rightId = rightComp.schematicComponentId;
-    if (!leftId || !rightId)
-      return [];
-    const leftLabels = this.netLabelsByComponentId.get(leftId) ?? [];
-    const rightLabels = this.netLabelsByComponentId.get(rightId) ?? [];
-    if (leftLabels.length === 0 || rightLabels.length === 0)
-      return [];
-    const hits = [];
-    for (const leftLabel of leftLabels) {
-      for (const rightLabel of rightLabels) {
-        const leftBounds = this.getNetLabelBounds(leftLabel);
-        const rightBounds = this.getNetLabelBounds(rightLabel);
-        if (rectOverlap(leftBounds, rightBounds)) {
-          hits.push({
-            type: "label-label",
-            leftComp,
-            rightComp,
-            leftId,
-            rightId,
-            xSeparation: leftBounds.right - rightBounds.left + 0.1
-          });
-        }
-      }
-    }
-    return hits;
-  }
-  detectBoxLabel(boxComp, labelComp) {
-    const boxId = boxComp.schematicComponentId;
-    const labelId = labelComp.schematicComponentId;
-    if (!boxId || !labelId)
-      return [];
-    const labels = this.netLabelsByComponentId.get(labelId) ?? [];
-    if (labels.length === 0)
-      return [];
-    const boxBounds = centeredRect(boxComp.schX, boxComp.schY, boxComp.width, boxComp.height);
-    const boxIsLeft = boxComp.schX <= labelComp.schX;
-    const hits = [];
-    for (const label of labels) {
-      const labelBounds = this.getNetLabelBounds(label);
-      if (!rectOverlap(boxBounds, labelBounds))
-        continue;
-      let xSeparation;
-      if (boxIsLeft) {
-        xSeparation = boxBounds.right - labelBounds.left + 0.1;
-      } else {
-        xSeparation = labelBounds.right - boxBounds.left + 0.1;
-      }
-      hits.push({
-        type: "box-label",
-        boxComp,
-        labelComp,
-        boxId,
-        labelId,
-        xSeparation
-      });
-    }
-    return hits;
-  }
-  buildAndPushIssues() {
-    if (this.rawCollisions.length === 0)
-      return;
-    const globalFixes = this.computeGlobalFixes();
-    if (globalFixes.size === 0)
-      return;
-    const seenPairs = new Set;
-    const pairs3 = [];
-    for (const collision of this.rawCollisions) {
-      let comp1Name;
-      let comp2Name;
-      if (collision.type === "label-label") {
-        comp1Name = collision.leftComp.sourceComponentName ?? "";
-        comp2Name = collision.rightComp.sourceComponentName ?? "";
-      } else {
-        comp1Name = collision.boxComp.sourceComponentName ?? "";
-        comp2Name = collision.labelComp.sourceComponentName ?? "";
-      }
-      const key = `${comp1Name}/${comp2Name}`;
-      if (!seenPairs.has(key)) {
-        seenPairs.add(key);
-        pairs3.push({ comp1Name, comp2Name });
-      }
-    }
-    this.params.issues.push({
-      lineItemType: "NetLabelCollision",
-      pairs: pairs3,
-      moves: Array.from(globalFixes.values())
-    });
-  }
-  computeGlobalFixes() {
-    const compById = new Map;
-    for (const placement of this.placements) {
-      if (placement.schematicComponentId)
-        compById.set(placement.schematicComponentId, placement);
-    }
-    const constraintMap = new Map;
-    const addConstraint = (leftId, rightId, xSeparation) => {
-      const leftComp = compById.get(leftId);
-      const rightComp = compById.get(rightId);
-      if (!leftComp || !rightComp)
-        return;
-      const minSep = rightComp.schX - leftComp.schX + xSeparation;
-      const key = `${leftId}|${rightId}`;
-      constraintMap.set(key, Math.max(constraintMap.get(key) ?? 0, minSep));
-    };
-    for (const collision of this.rawCollisions) {
-      if (collision.type === "label-label") {
-        addConstraint(collision.leftId, collision.rightId, collision.xSeparation);
-      } else if (collision.boxComp.schX <= collision.labelComp.schX) {
-        addConstraint(collision.boxId, collision.labelId, collision.xSeparation);
-      } else {
-        addConstraint(collision.labelId, collision.boxId, collision.xSeparation);
-      }
-    }
-    const constraints = [...constraintMap.entries()].map(([key, minSep]) => {
-      const pipeIndex = key.indexOf("|");
-      return {
-        leftId: key.slice(0, pipeIndex),
-        rightId: key.slice(pipeIndex + 1),
-        minSep
-      };
-    });
-    const allIds = new Set;
-    const adjacency = new Map;
-    for (const { leftId, rightId } of constraints) {
-      allIds.add(leftId);
-      allIds.add(rightId);
-      if (!adjacency.has(leftId))
-        adjacency.set(leftId, new Set);
-      if (!adjacency.has(rightId))
-        adjacency.set(rightId, new Set);
-      adjacency.get(leftId).add(rightId);
-      adjacency.get(rightId).add(leftId);
-    }
-    const visited = new Set;
-    const result = new Map;
-    for (const startId of allIds) {
-      if (visited.has(startId))
-        continue;
-      const group = [];
-      const queue = [startId];
-      visited.add(startId);
-      while (queue.length) {
-        const compId = queue.shift();
-        group.push(compId);
-        for (const neighbor of adjacency.get(compId) ?? []) {
-          if (!visited.has(neighbor)) {
-            visited.add(neighbor);
-            queue.push(neighbor);
-          }
-        }
-      }
-      group.sort((idA, idB) => (compById.get(idA)?.schX ?? 0) - (compById.get(idB)?.schX ?? 0));
-      const groupIds = new Set(group);
-      const groupConstraints = constraints.filter((c3) => groupIds.has(c3.leftId) && groupIds.has(c3.rightId));
-      const assigned = new Map;
-      for (const compId of group) {
-        let newX = compById.get(compId)?.schX ?? 0;
-        for (const { leftId, rightId, minSep } of groupConstraints) {
-          if (rightId === compId && assigned.has(leftId)) {
-            newX = Math.max(newX, assigned.get(leftId) + minSep);
-          }
-        }
-        assigned.set(compId, newX);
-      }
-      const totalPush = [...assigned.entries()].reduce((sum, [compId, newX]) => sum + (newX - (compById.get(compId)?.schX ?? 0)), 0);
-      if (totalPush > 0.000000001) {
-        const pullBack = totalPush / group.length;
-        const shifted = new Map;
-        for (const compId of group) {
-          let newX = (compById.get(compId)?.schX ?? 0) - pullBack;
-          for (const { leftId, rightId, minSep } of groupConstraints) {
-            if (rightId === compId && shifted.has(leftId)) {
-              newX = Math.max(newX, shifted.get(leftId) + minSep);
-            }
-          }
-          shifted.set(compId, newX);
-        }
-        const maxDisplacement = (positions) => [...positions.entries()].reduce((currentMax, [compId, newX]) => Math.max(currentMax, Math.abs(newX - (compById.get(compId)?.schX ?? 0))), 0);
-        if (maxDisplacement(shifted) < maxDisplacement(assigned)) {
-          for (const [compId, newX] of shifted)
-            assigned.set(compId, newX);
-        }
-      }
-      for (const [compId, newX] of assigned) {
-        const comp = compById.get(compId);
-        if (!comp || Math.abs(newX - comp.schX) < 0.000000001)
-          continue;
-        result.set(compId, {
-          componentName: comp.sourceComponentName ?? compId,
-          newSchX: Math.round(newX * 100) / 100,
-          newSchY: Math.round(comp.schY * 100) / 100
-        });
-      }
-    }
-    return result;
-  }
-  buildNetLabelsByComponentId(circuitJson) {
-    const MATCH_EPSILON = 0.0001;
-    const portPositions = [];
-    for (const element of circuitJson) {
-      if (element.type !== "schematic_port")
-        continue;
-      const port = element;
-      if (!port.schematic_component_id)
-        continue;
-      portPositions.push({
-        componentId: port.schematic_component_id,
-        cx: port.center.x,
-        cy: port.center.y,
-        schematicSheetId: port.schematic_sheet_id
-      });
-    }
-    const result = new Map;
-    for (const element of circuitJson) {
-      if (element.type !== "schematic_net_label")
-        continue;
-      const label = element;
-      if (!label.anchor_position)
-        continue;
-      const { x: anchorX, y: anchorY } = label.anchor_position;
-      const matches = portPositions.filter((port) => port.schematicSheetId === label.schematic_sheet_id && Math.hypot(port.cx - anchorX, port.cy - anchorY) < MATCH_EPSILON);
-      if (matches.length === 0)
-        continue;
-      const componentIds = new Set(matches.map((match) => match.componentId));
-      if (componentIds.size !== 1)
-        continue;
-      const componentId = matches[0].componentId;
-      const labels = result.get(componentId) ?? [];
-      labels.push(label);
-      result.set(componentId, labels);
-    }
-    return result;
-  }
-  getNetLabelBounds(label) {
-    const anchorSide = label.anchor_side;
-    const isVertical3 = anchorSide === "top" || anchorSide === "bottom";
-    if (isVertical3) {
-      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, i2) => `pair${i2 + 1}="${pair.comp1Name}/${pair.comp2Name}"`).join(" ");
-    const moves = issue.moves.map((move) => `    <Move componentName="${move.componentName}" newSchX="${move.newSchX}" newSchY="${move.newSchY}" />`);
-    return [
-      `<ComponentNetLabelCollision ${pairAttrs}>`,
-      `  <SuggestedFix note="Apply all moves simultaneously. Set schAutoLayoutEnabled on your circuit.">`,
-      ...moves,
-      `  </SuggestedFix>`,
-      `</ComponentNetLabelCollision>`
-    ].join(`
-`);
-  }
-}
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver14 {
-  static ALIGNMENT_EPSILON = 0.01;
-  ctx;
-  out;
-  constructor({
-    ctx,
-    issues
-  }) {
-    super();
-    this.ctx = ctx;
-    this.out = issues;
-  }
-  _step() {
-    const portsById = new Map(this.ctx.circuitJson.filter((el3) => el3.type === "schematic_port").map((port) => [port.schematic_port_id, port]));
-    const placementBySchematicComponentId = new Map(this.ctx.componentPlacements.flatMap((placement) => placement.schematicComponentId ? [[placement.schematicComponentId, placement]] : []));
-    const pinPairsByComponentPair = new Map;
-    for (const trace of this.ctx.circuitJson.filter((el3) => el3.type === "schematic_trace")) {
-      const pinPair = this.getTracePinPair(trace, portsById);
-      if (!pinPair)
-        continue;
-      const firstComponentId = pinPair.firstPort.schematic_component_id;
-      const secondComponentId = pinPair.secondPort.schematic_component_id;
-      if (!firstComponentId || !secondComponentId || firstComponentId === secondComponentId) {
-        continue;
-      }
-      const orderedPair = firstComponentId < secondComponentId ? pinPair : {
-        firstPort: pinPair.secondPort,
-        secondPort: pinPair.firstPort
-      };
-      const key = [firstComponentId, secondComponentId].sort().join("\x00");
-      const pairs3 = pinPairsByComponentPair.get(key) ?? [];
-      const isDuplicate = pairs3.some((pair) => pair.firstPort.schematic_port_id === orderedPair.firstPort.schematic_port_id && pair.secondPort.schematic_port_id === orderedPair.secondPort.schematic_port_id);
-      if (!isDuplicate)
-        pairs3.push(orderedPair);
-      pinPairsByComponentPair.set(key, pairs3);
-    }
-    for (const pinPairs of pinPairsByComponentPair.values()) {
-      const issue = this.findVerticalShiftIssue(pinPairs, placementBySchematicComponentId);
-      if (issue)
-        this.out.push(issue);
-    }
-    this.solved = true;
-  }
-  getTracePinPair(trace, portsById) {
-    const firstEdge = trace.edges?.[0];
-    const lastEdge = trace.edges?.at(-1);
-    if (!firstEdge || !lastEdge)
-      return;
-    const firstPortId = firstEdge.from_schematic_port_id ?? firstEdge.to_schematic_port_id;
-    const secondPortId = lastEdge.to_schematic_port_id ?? lastEdge.from_schematic_port_id;
-    const ports = [...portsById.values()];
-    const firstPort = firstPortId ? portsById.get(firstPortId) : this.findPortAtPoint(ports, firstEdge.from, trace.schematic_sheet_id);
-    const secondPort = secondPortId ? portsById.get(secondPortId) : this.findPortAtPoint(ports, lastEdge.to, trace.schematic_sheet_id);
-    if (!firstPort || !secondPort)
-      return;
-    if (firstPort.schematic_port_id === secondPort.schematic_port_id)
-      return;
-    if (firstPort.schematic_sheet_id !== secondPort.schematic_sheet_id)
-      return;
-    return { firstPort, secondPort };
-  }
-  findPortAtPoint(ports, point9, schematicSheetId) {
-    const { ALIGNMENT_EPSILON } = ComponentPinAlignmentSolver;
-    return ports.find((port) => port.schematic_sheet_id === schematicSheetId && Math.abs(port.center.x - point9.x) <= ALIGNMENT_EPSILON && Math.abs(port.center.y - point9.y) <= ALIGNMENT_EPSILON);
-  }
-  findVerticalShiftIssue(pinPairs, placementBySchematicComponentId) {
-    const firstPair = pinPairs[0];
-    if (!firstPair)
-      return;
-    const firstPlacement = placementBySchematicComponentId.get(firstPair.firstPort.schematic_component_id);
-    const secondPlacement = placementBySchematicComponentId.get(firstPair.secondPort.schematic_component_id);
-    if (!firstPlacement || !secondPlacement)
-      return;
-    const [leftPlacement, rightPlacement] = firstPlacement.schX <= secondPlacement.schX ? [firstPlacement, secondPlacement] : [secondPlacement, firstPlacement];
-    const horizontalPairs = pinPairs.flatMap((pair) => {
-      const [leftPort, rightPort] = pair.firstPort.center.x <= pair.secondPort.center.x ? [pair.firstPort, pair.secondPort] : [pair.secondPort, pair.firstPort];
-      return leftPort.facing_direction === "right" && rightPort.facing_direction === "left" ? [{ leftPort, rightPort }] : [];
-    });
-    if (horizontalPairs.length < 2)
-      return;
-    const { ALIGNMENT_EPSILON } = ComponentPinAlignmentSolver;
-    const currentlyAlignedPinCount = horizontalPairs.filter(({ leftPort, rightPort }) => Math.abs(leftPort.center.y - rightPort.center.y) <= ALIGNMENT_EPSILON).length;
-    const candidateGroups = [];
-    for (const pair of horizontalPairs) {
-      const deltaSchY2 = pair.leftPort.center.y - pair.rightPort.center.y;
-      if (Math.abs(deltaSchY2) <= ALIGNMENT_EPSILON)
-        continue;
-      const group = candidateGroups.find((candidate) => Math.abs(candidate.deltaSchY - deltaSchY2) <= ALIGNMENT_EPSILON);
-      if (group)
-        group.pairs.push(pair);
-      else
-        candidateGroups.push({ deltaSchY: deltaSchY2, pairs: [pair] });
-    }
-    const bestCandidate = candidateGroups.sort((a2, b3) => b3.pairs.length - a2.pairs.length || Math.abs(a2.deltaSchY) - Math.abs(b3.deltaSchY))[0];
-    if (!bestCandidate || bestCandidate.pairs.length < 2 || bestCandidate.pairs.length <= currentlyAlignedPinCount) {
-      return;
-    }
-    const targetName = rightPlacement.sourceComponentName ?? rightPlacement.schematicComponentId ?? "component";
-    const deltaSchY = bestCandidate.deltaSchY;
-    const newSchY = rightPlacement.schY + deltaSchY;
-    return {
-      lineItemType: "ComponentPinsWouldAlignWithVerticalShift",
-      firstComponent: leftPlacement,
-      secondComponent: rightPlacement,
-      targetComponent: rightPlacement,
-      deltaSchY,
-      newSchY,
-      currentlyAlignedPinCount,
-      alignedPinCount: bestCandidate.pairs.length,
-      alignedPinPairs: bestCandidate.pairs.map(({ leftPort, rightPort }) => ({
-        firstPin: this.getPinLabel(leftPort),
-        secondPin: this.getPinLabel(rightPort)
-      })),
-      message: `shift ${targetName} vertically by ${fmtDelta(deltaSchY)} to align ${bestCandidate.pairs.length} connected pin pairs`
-    };
-  }
-  getPinLabel(port) {
-    return port.display_pin_label ?? port.pin_number?.toString();
-  }
-  static issueToString(issue) {
-    const attrs = [];
-    addAttr(attrs, "firstComponentName", issue.firstComponent.sourceComponentName);
-    addAttr(attrs, "secondComponentName", issue.secondComponent.sourceComponentName);
-    addAttr(attrs, "targetComponentName", issue.targetComponent.sourceComponentName);
-    addAttr(attrs, "deltaSchY", issue.deltaSchY);
-    addAttr(attrs, "newSchY", issue.newSchY);
-    addAttr(attrs, "currentlyAlignedPinCount", issue.currentlyAlignedPinCount);
-    addAttr(attrs, "alignedPinCount", issue.alignedPinCount);
-    addAttr(attrs, "message", issue.message);
-    return `<ComponentPinsWouldAlignWithVerticalShift ${attrs.join(" ")} />`;
-  }
-}
-
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
 class SchematicPlacementPipeline extends BasePipelineSolver2 {
   ctx;
@@ -303583,6 +303837,9 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     definePipelineStep3("ComponentPinAlignmentSolver", ComponentPinAlignmentSolver, (p3) => [
       { ctx: p3.ctx, issues: p3.issues }
     ]),
+    definePipelineStep3("TraceSimplificationSolver", TraceSimplificationSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
     definePipelineStep3("ComponentNetLabelCollisionSolver", ComponentNetLabelCollisionSolver, (p3) => [
       { ctx: p3.ctx, issues: p3.issues }
     ])
@@ -303598,11 +303855,153 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/issue-context.ts
+var POSITION_EPSILON = 0.01;
+var getRelevantPlacementsForIssues = ({
+  issues,
+  componentPlacements,
+  circuitJson
+}) => {
+  const relevantPlacements = new Set;
+  const placementByComponentId = new Map(componentPlacements.flatMap((placement) => placement.schematicComponentId ? [[placement.schematicComponentId, placement]] : []));
+  const placementsByName = new Map;
+  for (const placement of componentPlacements) {
+    if (!placement.sourceComponentName)
+      continue;
+    const namedPlacements = placementsByName.get(placement.sourceComponentName);
+    if (namedPlacements)
+      namedPlacements.push(placement);
+    else
+      placementsByName.set(placement.sourceComponentName, [placement]);
+  }
+  const addPlacement = (placement) => {
+    if (!placement)
+      return;
+    const canonicalPlacement = placement.schematicComponentId ? placementByComponentId.get(placement.schematicComponentId) : componentPlacements.find((candidate) => candidate.sourceComponentId === placement.sourceComponentId && candidate.schX === placement.schX && candidate.schY === placement.schY);
+    if (canonicalPlacement)
+      relevantPlacements.add(canonicalPlacement);
+  };
+  const addComponentName = (componentName, schematicSheetId) => {
+    if (!componentName)
+      return;
+    for (const placement of placementsByName.get(componentName) ?? []) {
+      if (schematicSheetId === undefined || placement.schematicSheetId === schematicSheetId) {
+        relevantPlacements.add(placement);
+      }
+    }
+  };
+  for (const issue of issues) {
+    switch (issue.lineItemType) {
+      case "ComponentOverlap":
+        addPlacement(issue.firstComponent);
+        addPlacement(issue.secondComponent);
+        break;
+      case "SchematicBoxHasALotOfSurroundingWhitespace":
+      case "CapacitorSymbolHorizontal":
+      case "PinHeaderSchematicBoxTooWide":
+      case "GenericSchematicBoxTooWide":
+      case "SchematicBoxInnerLabelCollision":
+      case "SchematicPinPaddingToEdgeTooLarge":
+        addPlacement(issue.schematicBox);
+        break;
+      case "VerboseSchematicNetLabel":
+        for (const pin of issue.involvedPins) {
+          addComponentName(getComponentNameFromPin(pin), issue.schematicSheetId);
+        }
+        break;
+      case "DiodeResistorNotAligned":
+        addPlacement(issue.diodeSchematicBox);
+        addPlacement(issue.resistorSchematicBox);
+        break;
+      case "ComponentPinsWouldAlignWithVerticalShift":
+        addPlacement(issue.firstComponent);
+        addPlacement(issue.secondComponent);
+        addPlacement(issue.targetComponent);
+        break;
+      case "TraceCanBeSimplifiedByMovingComponent":
+        addPlacement(issue.targetComponent);
+        for (const placement of getTraceEndpointPlacements({
+          schematicTraceId: issue.schematicTraceId,
+          circuitJson,
+          placementByComponentId
+        })) {
+          relevantPlacements.add(placement);
+        }
+        break;
+      case "ComponentNetLabelCollision":
+        addPlacement(issue.firstComponent);
+        addPlacement(issue.secondComponent);
+        break;
+      case "ComponentBoxNetLabelCollision":
+        addPlacement(issue.boxComponent);
+        addPlacement(issue.labelComponent);
+        break;
+      case "NetLabelCollision":
+        for (const pair of issue.pairs) {
+          addComponentName(pair.comp1Name, issue.schematicSheetId);
+          addComponentName(pair.comp2Name, issue.schematicSheetId);
+        }
+        for (const move of issue.moves) {
+          addComponentName(move.componentName, issue.schematicSheetId);
+        }
+        break;
+    }
+  }
+  return componentPlacements.filter((placement) => relevantPlacements.has(placement));
+};
+var getIssueSchematicSheetContext = (issue) => {
+  if ("schematicSheetId" in issue || "schematicSheetName" in issue) {
+    const schematicSheetId = "schematicSheetId" in issue && typeof issue.schematicSheetId === "string" ? issue.schematicSheetId : undefined;
+    const schematicSheetName = "schematicSheetName" in issue && typeof issue.schematicSheetName === "string" ? issue.schematicSheetName : undefined;
+    if (schematicSheetId || schematicSheetName) {
+      return { schematicSheetId, schematicSheetName };
+    }
+  }
+  for (const value of Object.values(issue)) {
+    if (isSchematicBoxPlacement(value)) {
+      return {
+        schematicSheetId: value.schematicSheetId,
+        schematicSheetName: value.schematicSheetName
+      };
+    }
+  }
+  return {};
+};
+var getComponentNameFromPin = (pin) => {
+  const separatorIndex = pin.lastIndexOf(".");
+  return separatorIndex === -1 ? pin : pin.slice(0, separatorIndex);
+};
+var isSchematicBoxPlacement = (value) => Boolean(value && typeof value === "object" && "positionAnchor" in value && value.positionAnchor === "center" && "schX" in value && "schY" in value && "width" in value && "height" in value);
+var getTraceEndpointPlacements = ({
+  schematicTraceId,
+  circuitJson,
+  placementByComponentId
+}) => {
+  const trace = circuitJson.find((element) => element.type === "schematic_trace" && element.schematic_trace_id === schematicTraceId);
+  const firstEdge = trace?.edges[0];
+  const lastEdge = trace?.edges.at(-1);
+  if (!trace || !firstEdge || !lastEdge)
+    return [];
+  const ports = circuitJson.filter((element) => element.type === "schematic_port");
+  const portsById = new Map(ports.map((port) => [port.schematic_port_id, port]));
+  const endpointPorts = [
+    firstEdge.from_schematic_port_id ? portsById.get(firstEdge.from_schematic_port_id) : findPortAtPoint(ports, firstEdge.from, trace.schematic_sheet_id),
+    lastEdge.to_schematic_port_id ? portsById.get(lastEdge.to_schematic_port_id) : findPortAtPoint(ports, lastEdge.to, trace.schematic_sheet_id)
+  ];
+  return endpointPorts.flatMap((port) => {
+    const placement = port?.schematic_component_id ? placementByComponentId.get(port.schematic_component_id) : undefined;
+    return placement ? [placement] : [];
+  });
+};
+var findPortAtPoint = (ports, point9, schematicSheetId) => ports.find((port) => port.schematic_sheet_id === schematicSheetId && Math.abs(port.center.x - point9.x) <= POSITION_EPSILON && Math.abs(port.center.y - point9.y) <= POSITION_EPSILON);
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyze-schematic-placement.ts
 class SchematicPlacementAnalysis {
   lineItems;
-  constructor(lineItems) {
+  groupBySchematicSheet;
+  constructor(lineItems, groupBySchematicSheet = false) {
     this.lineItems = lineItems;
+    this.groupBySchematicSheet = groupBySchematicSheet;
   }
   getLineItems() {
     return this.lineItems;
@@ -303618,7 +304017,6 @@ class SchematicPlacementAnalysis {
     addAttr(attrs, "schY", lineItem.schY);
     addAttr(attrs, "width", lineItem.width);
     addAttr(attrs, "height", lineItem.height);
-    addAttr(attrs, "schSheetName", lineItem.schematicSheetName);
     return `<SchematicBoxPlacement ${attrs.join(" ")} />`;
   }
   schematicIssuesToString(issue) {
@@ -303640,6 +304038,8 @@ class SchematicPlacementAnalysis {
         return DiodeResistorAlignmentSolver.issueToString(issue);
       case "ComponentPinsWouldAlignWithVerticalShift":
         return ComponentPinAlignmentSolver.issueToString(issue);
+      case "TraceCanBeSimplifiedByMovingComponent":
+        return TraceSimplificationSolver.issueToString(issue);
       case "NetLabelCollision":
         return ComponentNetLabelCollisionSolver.netLabelCollisionToString(issue);
       default:
@@ -303649,28 +304049,71 @@ class SchematicPlacementAnalysis {
   toString() {
     const schematicBoxPlacements = this.lineItems.filter((lineItem) => lineItem.lineItemType === "SchematicBoxPlacement");
     const issues = this.lineItems.flatMap((lineItem) => lineItem.lineItemType === "SchematicPlacementIssues" ? lineItem.issues : []);
-    return [
-      "<SchematicBoxPositions>",
-      ...schematicBoxPlacements.map(this.schematicBoxPlacementsToString),
-      "</SchematicBoxPositions>",
-      ...issues.length > 0 ? [
-        "<SchematicPlacementIssues>",
-        ...issues.map(this.schematicIssuesToString),
-        "</SchematicPlacementIssues>"
-      ] : []
-    ].join(`
+    if (issues.length === 0)
+      return "";
+    if (!this.groupBySchematicSheet) {
+      return this.issueContextToLines(schematicBoxPlacements, issues).join(`
+`);
+    }
+    const groups = new Map;
+    const getOrCreateGroup = (context) => {
+      const key = context.schematicSheetId ?? context.schematicSheetName ?? "__default__";
+      const existingGroup = groups.get(key);
+      if (existingGroup)
+        return existingGroup;
+      const group = { ...context, placements: [], issues: [] };
+      groups.set(key, group);
+      return group;
+    };
+    for (const issue of issues) {
+      getOrCreateGroup(getIssueSchematicSheetContext(issue)).issues.push(issue);
+    }
+    for (const placement of schematicBoxPlacements) {
+      getOrCreateGroup({
+        schematicSheetId: placement.schematicSheetId,
+        schematicSheetName: placement.schematicSheetName
+      }).placements.push(placement);
+    }
+    return [...groups.values()].flatMap((group) => {
+      const sheetAttrs = [];
+      addAttr(sheetAttrs, "name", group.schematicSheetName);
+      addAttr(sheetAttrs, "id", group.schematicSheetId);
+      return [
+        `<SchematicSheet${sheetAttrs.length > 0 ? ` ${sheetAttrs.join(" ")}` : ""}>`,
+        ...this.issueContextToLines(group.placements, group.issues),
+        "</SchematicSheet>"
+      ];
+    }).join(`
 `);
   }
+  issueContextToLines(placements, issues) {
+    return [
+      ...placements.length > 0 ? [
+        "<SchematicBoxPositions>",
+        ...placements.map(this.schematicBoxPlacementsToString),
+        "</SchematicBoxPositions>"
+      ] : [],
+      "<SchematicPlacementIssues>",
+      ...issues.map(this.schematicIssuesToString),
+      "</SchematicPlacementIssues>"
+    ];
+  }
 }
 var analyzeSchematicPlacement = (circuitJson) => {
   const pipeline = new SchematicPlacementPipeline(circuitJson);
   pipeline.solve();
   const { issues, componentPlacements } = pipeline.getOutput();
+  const relevantPlacements = getRelevantPlacementsForIssues({
+    issues,
+    componentPlacements,
+    circuitJson
+  });
   const lineItems = [
-    ...componentPlacements,
+    ...relevantPlacements,
     ...issues.length > 0 ? [{ lineItemType: "SchematicPlacementIssues", issues }] : []
   ];
-  return new SchematicPlacementAnalysis(lineItems);
+  const schematicSheetIds = new Set(circuitJson.flatMap((element) => ("schematic_sheet_id" in element) && typeof element.schematic_sheet_id === "string" ? [element.schematic_sheet_id] : []));
+  return new SchematicPlacementAnalysis(lineItems, schematicSheetIds.size > 1);
 };
 // cli/check/schematic-placement/register.ts
 var checkSchematicPlacement = async (file) => {