@tscircuit/cli 0.1.1392 → 0.1.1393

package/dist/cli/main.js

@@ -100616,7 +100616,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1391";
+var version = "0.1.1392";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100630,7 +100630,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#8e3b4dc434d342f6b9833777107fc66515d1480b",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#700017d79a608295cc275dcb9c2e1d160809ef9e",
     "@tscircuit/eval": "^0.0.835",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
@@ -244242,647 +244242,1254 @@ var registerCheckRoutingDifficulty = (program2) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/analyze-schematic-placement.ts
-import { cju as cju7 } from "@tscircuit/circuit-json-util";
+// 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/analyzers/capacitor-orientation.ts
-var HORIZONTAL_CAPACITOR_SYMBOL_NAMES = new Set([
-  "capacitor_left",
-  "capacitor_right"
-]);
-var isSchematicComponent = (element) => element.type === "schematic_component";
-var isSourceCapacitor = (circuitJson, sourceComponentId) => {
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/placements.ts
+import { cju as cju7 } from "@tscircuit/circuit-json-util";
+var isSchematicBox = (el3) => el3.type === "schematic_box";
+var isSchematicComponent = (el3) => el3.type === "schematic_component";
+var getSourceComponentName = (circuitJson, sourceComponentId) => {
   if (!sourceComponentId)
-    return false;
-  return circuitJson.some((element) => element.type === "source_component" && element.source_component_id === sourceComponentId && element.ftype === "simple_capacitor");
-};
-var generateCapacitorOrientationIssues = (componentPlacements, circuitJson) => {
-  const placementBySchematicComponentId = new Map(componentPlacements.filter((placement) => placement.schematicComponentId).map((placement) => [placement.schematicComponentId, placement]));
-  return circuitJson.filter(isSchematicComponent).filter((schematicComponent) => isSourceCapacitor(circuitJson, schematicComponent.source_component_id) && HORIZONTAL_CAPACITOR_SYMBOL_NAMES.has(schematicComponent.symbol_name ?? "")).flatMap((schematicComponent) => {
-    const schematicBox = placementBySchematicComponentId.get(schematicComponent.schematic_component_id);
-    if (!schematicBox)
-      return [];
-    return [
-      {
-        lineItemType: "CapacitorSymbolHorizontal",
-        schematicBox
-      }
-    ];
-  });
+    return;
+  return cju7(circuitJson).source_component.get(sourceComponentId)?.name;
 };
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/shared.ts
-var SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
-var SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
-var PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP = 0.1;
-var GENERIC_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP = 1;
-var PIN_LABEL_EDGE_PADDING = 0.1;
-var PIN_NAME_CHARACTER_WIDTH = 0.095;
-var FALLBACK_CHARACTER_WIDTH = 0.13;
-var GAP_COMPARISON_EPSILON = 0.000000001;
-var isSchematicPort = (element) => element.type === "schematic_port";
-var isSourcePort = (element) => element.type === "source_port";
-var isSchematicComponent2 = (element) => element.type === "schematic_component";
-var getSourceComponentWithFtype = (element) => {
-  if (element.type !== "source_component" || !("source_component_id" in element) || typeof element.source_component_id !== "string") {
-    return null;
-  }
+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 {
-    type: "source_component",
-    source_component_id: element.source_component_id,
-    ftype: "ftype" in element && typeof element.ftype === "string" ? element.ftype : undefined
+    sourceComponentId: sc2.source_component_id,
+    sourceComponentName: sourceComponent?.name
   };
 };
-var isHorizontalSide = (side) => side === "left" || side === "right";
-var isVerticalSide = (side) => side === "top" || side === "bottom";
-var getCenteredRectBounds = (box2) => {
-  const halfWidth = box2.width / 2;
-  const halfHeight = box2.height / 2;
+var schematicComponentToPlacement = (schematicComponent, circuitJson, schematicBox) => ({
+  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
+});
+var schematicBoxToPlacement = (schematicBox, circuitJson) => ({
+  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
+});
+var buildSolverContext = (circuitJson) => {
+  const schematicBoxes = circuitJson.filter(isSchematicBox);
+  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent).map((sc2) => sc2.schematic_component_id));
+  const componentPlacements = [
+    ...circuitJson.filter(isSchematicComponent).map((sc2) => schematicComponentToPlacement(sc2, circuitJson, schematicBoxes.find((sb2) => sb2.schematic_component_id === sc2.schematic_component_id))),
+    ...schematicBoxes.filter((sb2) => !sb2.schematic_component_id || !schematicComponentIds.has(sb2.schematic_component_id)).map((sb2) => schematicBoxToPlacement(sb2, circuitJson))
+  ];
+  return { circuitJson, componentPlacements };
+};
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
+import { BaseSolver as BaseSolver6 } 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) {
+  return objects.filter((o3) => o3 !== undefined).reduce((acc, o3) => mergeGraphics2(acc, o3), {});
+}
+function highlightPlacement(placement, color, label) {
   return {
-    left: box2.schX - halfWidth,
-    right: box2.schX + halfWidth,
-    top: box2.schY + halfHeight,
-    bottom: box2.schY - halfHeight
+    rects: [
+      {
+        center: { x: placement.schX, y: placement.schY },
+        width: placement.width,
+        height: placement.height,
+        stroke: color,
+        fill: color.replace("0.95", "0.15"),
+        label
+      }
+    ]
   };
+}
+function visualizeCircuitJson(circuitJson) {
+  const rects = circuitJson.filter((el3) => el3.type === "schematic_box").map((el3) => {
+    const box2 = el3;
+    return {
+      center: { x: box2.x, y: box2.y },
+      width: box2.width,
+      height: box2.height,
+      stroke: "hsl(0,0%,60%)"
+    };
+  });
+  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 isPinNameLabel = (label, sourcePort) => {
-  if (!sourcePort)
-    return false;
-  return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
-};
-var estimateLabelWidth = (label, sourcePort) => {
-  const characterWidth = isPinNameLabel(label, sourcePort) ? PIN_NAME_CHARACTER_WIDTH : FALLBACK_CHARACTER_WIDTH;
-  return Array.from(label).length * characterWidth;
-};
-var exceedsMaxAllowedGap = (measuredInnerLabelEmptySpace, maxAllowedInnerLabelEmptySpace) => measuredInnerLabelEmptySpace - maxAllowedInnerLabelEmptySpace > GAP_COMPARISON_EPSILON;
-var getSourcePortById = (circuitJson) => new Map(circuitJson.filter(isSourcePort).map((sourcePort) => [sourcePort.source_port_id, sourcePort]));
-var getSourceComponentById = (circuitJson) => new Map(circuitJson.flatMap((element) => {
-  const sourceComponent = getSourceComponentWithFtype(element);
-  return sourceComponent ? [sourceComponent] : [];
-}).map((sourceComponent) => [
-  sourceComponent.source_component_id,
-  sourceComponent
-]));
-var getSchematicComponentById = (circuitJson) => new Map(circuitJson.filter(isSchematicComponent2).map((schematicComponent) => [
-  schematicComponent.schematic_component_id,
-  schematicComponent
-]));
-var getPlacementBySchematicComponentId = (componentPlacements) => new Map(componentPlacements.filter((placement) => placement.schematicComponentId).map((placement) => [placement.schematicComponentId, placement]));
-var getPortsBySchematicComponentId = (circuitJson, isRelevantSide) => {
-  const portsBySchematicComponentId = new Map;
-  for (const port of circuitJson.filter(isSchematicPort)) {
-    if (!port.schematic_component_id)
-      continue;
-    if (!isRelevantSide(port.side_of_component))
-      continue;
-    const ports = portsBySchematicComponentId.get(port.schematic_component_id);
-    if (ports) {
-      ports.push(port);
-    } else {
-      portsBySchematicComponentId.set(port.schematic_component_id, [port]);
+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 BaseSolver6 {
+  ctx;
+  out;
+  schematicComponentById;
+  sourceComponentById;
+  capacitorPlacements;
+  currentPlacementIndex = 0;
+  horizontalSymbolNames = new Set([
+    "capacitor_left",
+    "capacitor_right"
+  ]);
+  constructor({
+    ctx,
+    issues: out
+  }) {
+    super();
+    this.ctx = ctx;
+    this.out = out;
+    this.schematicComponentById = this.buildSchematicComponentById(ctx.circuitJson);
+    this.sourceComponentById = this.buildSourceComponentById(ctx.circuitJson);
+    this.capacitorPlacements = this.getCapacitorPlacements();
+    this.solved = this.capacitorPlacements.length === 0;
+  }
+  getCapacitorPlacements() {
+    return this.ctx.componentPlacements.filter((p3) => p3.sourceComponentId !== undefined && this.sourceComponentById.get(p3.sourceComponentId)?.ftype === "simple_capacitor").map((p3) => ({
+      schX: p3.schX,
+      schY: p3.schY,
+      width: p3.width,
+      height: p3.height,
+      sourceComponentId: p3.sourceComponentId,
+      sourceComponentName: p3.sourceComponentName,
+      schematicComponentId: p3.schematicComponentId
+    }));
+  }
+  _step() {
+    const currentPlacement = this.capacitorPlacements[this.currentPlacementIndex];
+    if (!currentPlacement) {
+      this.solved = true;
+      return;
     }
+    this.currentPlacementIndex += 1;
+    this.solved = this.currentPlacementIndex >= this.capacitorPlacements.length;
+    const issue = this.getIssueForPlacement(currentPlacement);
+    if (issue)
+      this.out.push(issue);
   }
-  return portsBySchematicComponentId;
-};
-var getSourceComponentFtype = (schematicBox, sourceComponentById) => schematicBox.sourceComponentId ? sourceComponentById.get(schematicBox.sourceComponentId)?.ftype : undefined;
+  visualize() {
+    const focusedPlacement = this.getFocusedPlacement();
+    return mergeGraphicsObjects2([
+      visualizeCircuitJson(this.ctx.circuitJson),
+      focusedPlacement ? highlightPlacement(focusedPlacement, "hsl(210, 100%, 50%, 0.95)", "capacitorOrientation") : undefined
+    ]);
+  }
+  getFocusedPlacement() {
+    if (this.capacitorPlacements.length === 0)
+      return;
+    const index = this.iterations === 0 ? this.currentPlacementIndex : Math.max(0, this.currentPlacementIndex - 1);
+    return this.capacitorPlacements[index];
+  }
+  buildSchematicComponentById(circuitJson) {
+    return new Map(circuitJson.filter((el3) => el3.type === "schematic_component").map((sc2) => [sc2.schematic_component_id, sc2]));
+  }
+  buildSourceComponentById(circuitJson) {
+    return new Map(circuitJson.flatMap((el3) => {
+      if (el3.type !== "source_component" || !("source_component_id" in el3) || typeof el3.source_component_id !== "string")
+        return [];
+      return [
+        {
+          type: "source_component",
+          source_component_id: el3.source_component_id,
+          ftype: "ftype" in el3 && typeof el3.ftype === "string" ? el3.ftype : undefined
+        }
+      ];
+    }).map((sc2) => [sc2.source_component_id, sc2]));
+  }
+  createIssuePlacement(placement) {
+    return {
+      positionAnchor: "center",
+      schX: placement.schX,
+      schY: placement.schY,
+      width: placement.width,
+      height: placement.height,
+      sourceComponentId: placement.sourceComponentId,
+      sourceComponentName: placement.sourceComponentName,
+      schematicComponentId: placement.schematicComponentId
+    };
+  }
+  getIssueForPlacement(placement) {
+    if (!placement.schematicComponentId || !placement.sourceComponentId)
+      return;
+    const schematicComponent = this.schematicComponentById.get(placement.schematicComponentId);
+    if (!schematicComponent)
+      return;
+    if (!this.horizontalSymbolNames.has(schematicComponent.symbol_name ?? ""))
+      return;
+    return {
+      lineItemType: "CapacitorSymbolHorizontal",
+      schematicBox: this.createIssuePlacement(placement)
+    };
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+    addAttr(attrs, "schX", issue.schematicBox.schX);
+    addAttr(attrs, "schY", issue.schematicBox.schY);
+    addAttr(attrs, "width", issue.schematicBox.width);
+    addAttr(attrs, "height", issue.schematicBox.height);
+    return `<CapacitorSymbolHorizontal ${attrs.join(" ")} />`;
+  }
+}
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/pin-padding-to-edge.ts
-var isSchematicSide = (side) => isHorizontalSide(side) || isVerticalSide(side);
-var getPinSpacing = (schematicBox, schematicComponentById) => {
-  if (!schematicBox.schematicComponentId)
-    return null;
-  const schematicComponent = schematicComponentById.get(schematicBox.schematicComponentId);
-  return typeof schematicComponent?.pin_spacing === "number" ? schematicComponent.pin_spacing : null;
-};
-var getPinName = (port, sourcePortById) => {
-  const sourcePort = sourcePortById.get(port.source_port_id);
-  if (sourcePort?.name)
-    return sourcePort.name;
-  if (port.display_pin_label)
-    return port.display_pin_label;
-  if (sourcePort?.pin_number !== undefined)
-    return String(sourcePort.pin_number);
-  return;
-};
-var getMaxLabelLengthBySide = (ports, sourcePortById) => {
-  const maxLabelLengthBySide = {
-    left: 0,
-    right: 0,
-    top: 0,
-    bottom: 0
-  };
-  for (const port of ports) {
-    if (!isSchematicSide(port.side_of_component))
-      continue;
-    if (!port.display_pin_label)
-      continue;
-    maxLabelLengthBySide[port.side_of_component] = Math.max(maxLabelLengthBySide[port.side_of_component], estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id)));
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver8 {
+  params;
+  placements;
+  firstIndex = 0;
+  secondIndex = 1;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.placements = params2.ctx.componentPlacements;
+    this.solved = this.placements.length < 2;
   }
-  return maxLabelLengthBySide;
-};
-var getOuterPinBySide = (edgeSide, ports) => {
-  if (ports.length === 0)
-    return null;
-  switch (edgeSide) {
-    case "top":
-      return ports.reduce((topPort, port) => port.center.y > topPort.center.y ? port : topPort);
-    case "bottom":
-      return ports.reduce((bottomPort, port) => port.center.y < bottomPort.center.y ? port : bottomPort);
-    case "left":
-      return ports.reduce((leftPort, port) => port.center.x < leftPort.center.x ? port : leftPort);
-    case "right":
-      return ports.reduce((rightPort, port) => port.center.x > rightPort.center.x ? port : rightPort);
+  _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;
   }
-};
-var getPinPaddingToEdge = (input) => {
-  const bounds = getCenteredRectBounds(input.schematicBox);
-  switch (input.edgeSide) {
-    case "top":
-      return Math.max(0, bounds.top - input.port.center.y);
-    case "bottom":
-      return Math.max(0, input.port.center.y - bounds.bottom);
-    case "left":
-      return Math.max(0, input.port.center.x - bounds.left);
-    case "right":
-      return Math.max(0, bounds.right - input.port.center.x);
+  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
+    };
   }
-};
-var getBoxEdgeSidesForPinSide = (pinSide) => isHorizontalSide(pinSide) ? ["top", "bottom"] : ["left", "right"];
-var hasPinsOnAllSides = (portsBySide) => portsBySide.has("left") && portsBySide.has("right") && portsBySide.has("top") && portsBySide.has("bottom");
-var getMaxAllowedPinPadding = (input) => {
-  const edgeAxisSides = isHorizontalSide(input.edgeSide) ? ["left", "right"] : ["top", "bottom"];
-  return (input.maxLabelLengthBySide[edgeAxisSides[0]] + input.maxLabelLengthBySide[edgeAxisSides[1]] + input.spacing) / 2;
-};
-var createPinPaddingToEdgeIssue = (candidate) => {
-  const excessPadding = Math.max(0, candidate.measuredPadding - candidate.maxAllowedPadding);
-  const widthReduction = excessPadding * 2;
-  const heightReduction = excessPadding * 2;
-  return {
-    lineItemType: "SchematicPinPaddingToEdgeTooLarge",
-    pinSide: candidate.pinSide,
-    edgeSide: candidate.edgeSide,
-    pinName: candidate.pinName,
-    schematicBox: candidate.schematicBox,
-    measuredPadding: candidate.measuredPadding,
-    maxAllowedPadding: candidate.maxAllowedPadding,
-    excessPadding,
-    suggestedSchWidth: isHorizontalSide(candidate.pinSide) ? undefined : Math.max(0, candidate.schematicBox.width - widthReduction),
-    suggestedSchHeight: isHorizontalSide(candidate.pinSide) ? Math.max(0, candidate.schematicBox.height - heightReduction) : undefined,
-    message: isHorizontalSide(candidate.pinSide) ? `${SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE} height` : `${SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE} width`
-  };
-};
-var generateSchematicPinPaddingToEdgeCandidates = (componentPlacements, circuitJson) => {
-  const placementBySchematicComponentId = getPlacementBySchematicComponentId(componentPlacements);
-  const schematicComponentById = getSchematicComponentById(circuitJson);
-  const sourcePortById = getSourcePortById(circuitJson);
-  const portsBySchematicComponentId = getPortsBySchematicComponentId(circuitJson, isSchematicSide);
-  const candidates = [];
-  for (const [schematicComponentId, ports] of portsBySchematicComponentId) {
-    const schematicBox = placementBySchematicComponentId.get(schematicComponentId);
+  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) {
+    const a2 = this.getCenteredRectBounds(firstComponent);
+    const b = this.getCenteredRectBounds(secondComponent);
+    const overlapWidth = Math.min(a2.right, b.right) - Math.max(a2.left, b.left);
+    const overlapHeight = Math.min(a2.bottom, b.bottom) - Math.max(a2.top, b.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/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
+import { BaseSolver as BaseSolver9 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver9 {
+  params;
+  MESSAGE = "Inner labels are colliding. Increase the schWidth or schHeight.";
+  PIN_LABEL_EDGE_PADDING = 0.1;
+  PIN_LABEL_TEXT_HEIGHT = 0.15;
+  PIN_NAME_CHARACTER_WIDTH = 0.095;
+  FALLBACK_CHARACTER_WIDTH = 0.13;
+  INNER_LABEL_COLLISION_PADDING = 0.02;
+  COLLISION_COMPARISON_EPSILON = 0.000000001;
+  entries;
+  placementById;
+  sourcePortById;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const { circuitJson, componentPlacements } = params2.ctx;
+    this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
+    this.sourcePortById = this.getSourcePortById(circuitJson);
+    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
+    this.solved = this.entries.length === 0;
+  }
+  _step() {
+    const entry = this.entries[this.currentIndex++];
+    if (!entry) {
+      this.solved = true;
+      return;
+    }
+    this.solved = this.currentIndex >= this.entries.length;
+    const [schematicComponentId, ports] = entry;
+    const schematicBox = this.placementById.get(schematicComponentId);
     if (!schematicBox)
-      continue;
-    const pinSpacing = getPinSpacing(schematicBox, schematicComponentById);
+      return;
+    const bounds = this.getCenteredRectBounds(schematicBox);
+    const labelRects = this.getLabelRects(bounds, ports, this.sourcePortById);
+    if (labelRects.length === 0)
+      return;
+    const collisionSummary = this.getCollisionSummary(labelRects);
+    if (collisionSummary.overlappingSides.length === 0)
+      return;
+    this.params.issues.push({
+      lineItemType: "SchematicBoxInnerLabelCollision",
+      schematicBox,
+      overlappingSides: collisionSummary.overlappingSides,
+      message: this.MESSAGE
+    });
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+    addAttr(attrs, "currentSchWidth", issue.schematicBox.width);
+    addAttr(attrs, "currentSchHeight", issue.schematicBox.height);
+    addAttr(attrs, "overlappingSides", issue.overlappingSides.join(","));
+    return `<SchematicBoxInnerLabelCollision ${attrs.join(" ")} />`;
+  }
+  isSchematicPort(el3) {
+    return el3.type === "schematic_port";
+  }
+  isSourcePort(el3) {
+    return el3.type === "source_port";
+  }
+  isSchematicSide(side) {
+    return side === "left" || side === "right" || side === "top" || side === "bottom";
+  }
+  isPinNameLabel(label, sourcePort) {
+    if (!sourcePort)
+      return false;
+    return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
+  }
+  estimateLabelLength(label, sourcePort) {
+    return Array.from(label).length * (this.isPinNameLabel(label, sourcePort) ? this.PIN_NAME_CHARACTER_WIDTH : this.FALLBACK_CHARACTER_WIDTH);
+  }
+  hasCollision(requiredGrowth) {
+    return requiredGrowth > this.COLLISION_COMPARISON_EPSILON;
+  }
+  getCenteredRectBounds(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
+    };
+  }
+  getSourcePortById(circuitJson) {
+    return new Map(circuitJson.filter((el3) => this.isSourcePort(el3)).map((sp3) => [sp3.source_port_id, sp3]));
+  }
+  getPlacementBySchematicComponentId(componentPlacements) {
+    return new Map(componentPlacements.filter((p3) => p3.schematicComponentId).map((p3) => [p3.schematicComponentId, p3]));
+  }
+  getPortsBySchematicComponentId(circuitJson) {
+    const map = new Map;
+    for (const port of circuitJson.filter((el3) => this.isSchematicPort(el3))) {
+      if (!port.schematic_component_id)
+        continue;
+      if (!this.isSchematicSide(port.side_of_component))
+        continue;
+      const ports = map.get(port.schematic_component_id);
+      if (ports)
+        ports.push(port);
+      else
+        map.set(port.schematic_component_id, [port]);
+    }
+    return map;
+  }
+  getLabelRects(bounds, ports, sourcePortById) {
+    const rects = [];
+    for (const port of ports) {
+      if (!this.isSchematicSide(port.side_of_component))
+        continue;
+      if (!port.display_pin_label)
+        continue;
+      const labelLength = this.estimateLabelLength(port.display_pin_label, sourcePortById.get(port.source_port_id));
+      const halfTextHeight = this.PIN_LABEL_TEXT_HEIGHT / 2;
+      switch (port.side_of_component) {
+        case "left": {
+          const xMin = bounds.left + this.PIN_LABEL_EDGE_PADDING;
+          rects.push({
+            side: port.side_of_component,
+            xMin,
+            xMax: xMin + labelLength,
+            yMin: port.center.y - halfTextHeight,
+            yMax: port.center.y + halfTextHeight
+          });
+          break;
+        }
+        case "right": {
+          const xMax = bounds.right - this.PIN_LABEL_EDGE_PADDING;
+          rects.push({
+            side: port.side_of_component,
+            xMin: xMax - labelLength,
+            xMax,
+            yMin: port.center.y - halfTextHeight,
+            yMax: port.center.y + halfTextHeight
+          });
+          break;
+        }
+        case "top": {
+          const yMax = bounds.top - this.PIN_LABEL_EDGE_PADDING;
+          rects.push({
+            side: port.side_of_component,
+            xMin: port.center.x - halfTextHeight,
+            xMax: port.center.x + halfTextHeight,
+            yMin: yMax - labelLength,
+            yMax
+          });
+          break;
+        }
+        case "bottom": {
+          const yMin = bounds.bottom + this.PIN_LABEL_EDGE_PADDING;
+          rects.push({
+            side: port.side_of_component,
+            xMin: port.center.x - halfTextHeight,
+            xMax: port.center.x + halfTextHeight,
+            yMin,
+            yMax: yMin + labelLength
+          });
+          break;
+        }
+      }
+    }
+    return rects;
+  }
+  getCollisionSummary(rects) {
+    const overlappingSides = new Set;
+    for (let i2 = 0;i2 < rects.length; i2++) {
+      for (let j4 = i2 + 1;j4 < rects.length; j4++) {
+        const a2 = rects[i2];
+        const b = rects[j4];
+        if (a2.side === b.side)
+          continue;
+        if (!this.rectsOverlap(a2, b))
+          continue;
+        overlappingSides.add(a2.side);
+        overlappingSides.add(b.side);
+      }
+    }
+    return {
+      overlappingSides: this.sortSides(Array.from(overlappingSides))
+    };
+  }
+  rectsOverlap(a2, b) {
+    return this.hasCollision(Math.min(a2.xMax, b.xMax) - Math.max(a2.xMin, b.xMin) + this.INNER_LABEL_COLLISION_PADDING) && this.hasCollision(Math.min(a2.yMax, b.yMax) - Math.max(a2.yMin, b.yMin) + this.INNER_LABEL_COLLISION_PADDING);
+  }
+  sortSides(sides) {
+    const order = {
+      left: 0,
+      right: 1,
+      top: 2,
+      bottom: 3
+    };
+    return sides.sort((a2, b) => order[a2] - order[b]);
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver10 {
+  params;
+  SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
+  PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
+  GENERIC_MAX_ALLOWED_GAP = 1;
+  PIN_LABEL_EDGE_PADDING = 0.1;
+  PIN_NAME_CHARACTER_WIDTH = 0.095;
+  FALLBACK_CHARACTER_WIDTH = 0.13;
+  GAP_COMPARISON_EPSILON = 0.000000001;
+  entries;
+  placementById;
+  sourcePortById;
+  sourceComponentById;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const { circuitJson, componentPlacements } = params2.ctx;
+    this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
+    this.sourcePortById = this.getSourcePortById(circuitJson);
+    this.sourceComponentById = this.getSourceComponentById(circuitJson);
+    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
+    this.solved = this.entries.length === 0;
+  }
+  _step() {
+    const entry = this.entries[this.currentIndex++];
+    if (!entry) {
+      this.solved = true;
+      return;
+    }
+    this.solved = this.currentIndex >= this.entries.length;
+    const [schematicComponentId, ports] = entry;
+    const schematicBox = this.placementById.get(schematicComponentId);
+    if (!schematicBox)
+      return;
+    const bounds = this.getCenteredRectBounds(schematicBox);
+    const leftCol = this.getLabelColumn("left", ports, this.sourcePortById);
+    const rightCol = this.getLabelColumn("right", ports, this.sourcePortById);
+    const ftype = this.getSourceComponentFtype(schematicBox, this.sourceComponentById);
+    let measuredSpace;
+    if (leftCol && rightCol) {
+      measuredSpace = this.getInnerLabelEdge(bounds, rightCol) - this.getInnerLabelEdge(bounds, leftCol);
+    } else if (leftCol && leftCol.labelCount >= 4) {
+      measuredSpace = bounds.right - this.getInnerLabelEdge(bounds, leftCol);
+    } else if (rightCol && rightCol.labelCount >= 4) {
+      measuredSpace = this.getInnerLabelEdge(bounds, rightCol) - bounds.left;
+    }
+    if (measuredSpace === undefined)
+      return;
+    const maxAllowed = ftype === "simple_pin_header" ? this.PIN_HEADER_MAX_ALLOWED_GAP : this.GENERIC_MAX_ALLOWED_GAP;
+    if (!this.exceedsMaxAllowedGap(measuredSpace, maxAllowed))
+      return;
+    const suggestedSchWidth = this.getSuggestedWidth({
+      measuredInnerLabelHorizontalEmptySpace: measuredSpace,
+      maxAllowedInnerLabelHorizontalEmptySpace: maxAllowed,
+      currentWidth: schematicBox.width
+    });
+    if (ftype === "simple_pin_header") {
+      this.params.issues.push({
+        lineItemType: "PinHeaderSchematicBoxTooWide",
+        schematicBox,
+        measuredInnerLabelHorizontalEmptySpace: measuredSpace,
+        maxAllowedInnerLabelHorizontalEmptySpace: maxAllowed,
+        suggestedSchWidth,
+        message: this.SCHEMATIC_BOX_TOO_WIDE_MESSAGE
+      });
+    } else {
+      this.params.issues.push({
+        lineItemType: "GenericSchematicBoxTooWide",
+        schematicBox,
+        measuredInnerLabelHorizontalEmptySpace: measuredSpace,
+        maxAllowedInnerLabelHorizontalEmptySpace: maxAllowed,
+        suggestedSchWidth,
+        message: this.SCHEMATIC_BOX_TOO_WIDE_MESSAGE
+      });
+    }
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+    addAttr(attrs, "currentSchWidth", issue.schematicBox.width);
+    addAttr(attrs, "measuredInnerLabelHorizontalEmptySpace", issue.measuredInnerLabelHorizontalEmptySpace);
+    addAttr(attrs, "maxAllowedInnerLabelHorizontalEmptySpace", issue.maxAllowedInnerLabelHorizontalEmptySpace);
+    addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
+    return `<${issue.lineItemType} ${attrs.join(" ")} />`;
+  }
+  isSchematicPort(el3) {
+    return el3.type === "schematic_port";
+  }
+  isSourcePort(el3) {
+    return el3.type === "source_port";
+  }
+  isHorizontalSide(side) {
+    return side === "left" || side === "right";
+  }
+  getSourceComponentWithFtype(el3) {
+    if (el3.type !== "source_component" || !("source_component_id" in el3) || typeof el3.source_component_id !== "string")
+      return null;
+    return {
+      type: "source_component",
+      source_component_id: el3.source_component_id,
+      ftype: "ftype" in el3 && typeof el3.ftype === "string" ? el3.ftype : undefined
+    };
+  }
+  isPinNameLabel(label, sourcePort) {
+    if (!sourcePort)
+      return false;
+    return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
+  }
+  estimateLabelWidth(label, sourcePort) {
+    return Array.from(label).length * (this.isPinNameLabel(label, sourcePort) ? this.PIN_NAME_CHARACTER_WIDTH : this.FALLBACK_CHARACTER_WIDTH);
+  }
+  exceedsMaxAllowedGap(measured, maxAllowed) {
+    return measured - maxAllowed > this.GAP_COMPARISON_EPSILON;
+  }
+  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
+    };
+  }
+  getSourcePortById(circuitJson) {
+    return new Map(circuitJson.filter((el3) => this.isSourcePort(el3)).map((sp3) => [sp3.source_port_id, sp3]));
+  }
+  getSourceComponentById(circuitJson) {
+    return new Map(circuitJson.flatMap((el3) => {
+      const sc2 = this.getSourceComponentWithFtype(el3);
+      return sc2 ? [sc2] : [];
+    }).map((sc2) => [sc2.source_component_id, sc2]));
+  }
+  getPlacementBySchematicComponentId(componentPlacements) {
+    return new Map(componentPlacements.filter((p3) => p3.schematicComponentId).map((p3) => [p3.schematicComponentId, p3]));
+  }
+  getPortsBySchematicComponentId(circuitJson) {
+    const map = new Map;
+    for (const port of circuitJson.filter((el3) => this.isSchematicPort(el3))) {
+      if (!port.schematic_component_id)
+        continue;
+      if (!this.isHorizontalSide(port.side_of_component))
+        continue;
+      const ports = map.get(port.schematic_component_id);
+      if (ports)
+        ports.push(port);
+      else
+        map.set(port.schematic_component_id, [port]);
+    }
+    return map;
+  }
+  getSourceComponentFtype(schematicBox, sourceComponentById) {
+    return schematicBox.sourceComponentId ? sourceComponentById.get(schematicBox.sourceComponentId)?.ftype : undefined;
+  }
+  getLabelColumn(side, ports, sourcePortById) {
+    const widths = ports.filter((p3) => p3.side_of_component === side).flatMap((p3) => p3.display_pin_label ? [
+      this.estimateLabelWidth(p3.display_pin_label, sourcePortById.get(p3.source_port_id))
+    ] : []);
+    if (widths.length === 0)
+      return null;
+    return {
+      side,
+      labelCount: widths.length,
+      maxLabelWidth: Math.max(...widths)
+    };
+  }
+  getInnerLabelEdge(bounds, col) {
+    return col.side === "left" ? bounds.left + this.PIN_LABEL_EDGE_PADDING + col.maxLabelWidth : bounds.right - this.PIN_LABEL_EDGE_PADDING - col.maxLabelWidth;
+  }
+  getSuggestedWidth(input) {
+    return input.currentWidth - input.measuredInnerLabelHorizontalEmptySpace + input.maxAllowedInnerLabelHorizontalEmptySpace;
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver11 {
+  params;
+  MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
+  PIN_NAME_CHARACTER_WIDTH = 0.095;
+  FALLBACK_CHARACTER_WIDTH = 0.13;
+  GAP_COMPARISON_EPSILON = 0.000000001;
+  entries;
+  placementById;
+  schematicComponentById;
+  sourcePortById;
+  currentIndex = 0;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const { circuitJson, componentPlacements } = params2.ctx;
+    this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
+    this.schematicComponentById = this.getSchematicComponentById(circuitJson);
+    this.sourcePortById = this.getSourcePortById(circuitJson);
+    this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
+    this.solved = this.entries.length === 0;
+  }
+  _step() {
+    const entry = this.entries[this.currentIndex++];
+    if (!entry) {
+      this.solved = true;
+      return;
+    }
+    this.solved = this.currentIndex >= this.entries.length;
+    const [schematicComponentId, ports] = entry;
+    const schematicBox = this.placementById.get(schematicComponentId);
+    if (!schematicBox)
+      return;
+    const pinSpacing = this.getPinSpacing(schematicBox, this.schematicComponentById);
     if (pinSpacing === null)
-      continue;
-    const maxLabelLengthBySide = getMaxLabelLengthBySide(ports, sourcePortById);
+      return;
+    const maxLabelLengthBySide = this.getMaxLabelLengthBySide(ports, this.sourcePortById);
     const portsBySide = new Map;
     for (const port of ports) {
-      if (!isSchematicSide(port.side_of_component))
+      if (!this.isSchematicSide(port.side_of_component))
         continue;
       const sidePorts = portsBySide.get(port.side_of_component) ?? [];
       sidePorts.push(port);
       portsBySide.set(port.side_of_component, sidePorts);
     }
-    const useLabelAwareMaxPadding = hasPinsOnAllSides(portsBySide);
+    const useLabelAwareMaxPadding = this.hasPinsOnAllSides(portsBySide);
     for (const [pinSide, sidePorts] of portsBySide) {
-      for (const edgeSide of getBoxEdgeSidesForPinSide(pinSide)) {
-        const outerPin = getOuterPinBySide(edgeSide, sidePorts);
+      for (const edgeSide of this.getBoxEdgeSidesForPinSide(pinSide)) {
+        const outerPin = this.getOuterPinBySide(edgeSide, sidePorts);
         if (!outerPin)
           continue;
-        const measuredPinPadding = {
-          pinName: getPinName(outerPin, sourcePortById),
-          measuredPadding: getPinPaddingToEdge({
-            schematicBox,
-            port: outerPin,
-            edgeSide
-          })
-        };
-        candidates.push({
+        const measuredPadding = this.getPinPaddingToEdge(schematicBox, outerPin, edgeSide);
+        const maxAllowedPadding = useLabelAwareMaxPadding ? this.getMaxAllowedPinPadding(pinSpacing, edgeSide, maxLabelLengthBySide) : pinSpacing;
+        if (!this.exceedsMaxAllowedGap(measuredPadding, maxAllowedPadding))
+          continue;
+        this.params.issues.push(this.createIssue({
           schematicBox,
           pinSide,
           edgeSide,
-          pinName: measuredPinPadding.pinName,
-          measuredPadding: measuredPinPadding.measuredPadding,
-          maxAllowedPadding: useLabelAwareMaxPadding ? getMaxAllowedPinPadding({
-            spacing: pinSpacing,
-            edgeSide,
-            maxLabelLengthBySide
-          }) : pinSpacing
-        });
+          pinName: this.getPinName(outerPin, this.sourcePortById),
+          measuredPadding,
+          maxAllowedPadding
+        }));
       }
     }
   }
-  return candidates;
-};
-var getSchematicPinPaddingToEdgeTooLargeIssues = (candidates) => candidates.filter((candidate) => exceedsMaxAllowedGap(candidate.measuredPadding, candidate.maxAllowedPadding)).map(createPinPaddingToEdgeIssue);
-var generateSchematicPinPaddingToEdgeTooLargeIssues = (componentPlacements, circuitJson) => getSchematicPinPaddingToEdgeTooLargeIssues(generateSchematicPinPaddingToEdgeCandidates(componentPlacements, circuitJson));
-
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/too-wide.ts
-var getLabelColumn = (side, ports, sourcePortById) => {
-  const labelWidths = ports.filter((port) => port.side_of_component === side).flatMap((port) => port.display_pin_label ? [
-    estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id))
-  ] : []);
-  if (labelWidths.length === 0)
-    return null;
-  return {
-    side,
-    labelCount: labelWidths.length,
-    maxLabelWidth: Math.max(...labelWidths)
-  };
-};
-var getInnerLabelEdge = (bounds, labelColumn) => {
-  if (labelColumn.side === "left") {
-    return bounds.left + PIN_LABEL_EDGE_PADDING + labelColumn.maxLabelWidth;
-  }
-  return bounds.right - PIN_LABEL_EDGE_PADDING - labelColumn.maxLabelWidth;
-};
-var getSuggestedWidth = (input) => input.currentWidth - input.measuredInnerLabelHorizontalEmptySpace + input.maxAllowedInnerLabelHorizontalEmptySpace;
-var createPinHeaderIssue = (input) => ({
-  lineItemType: "PinHeaderSchematicBoxTooWide",
-  schematicBox: input.schematicBox,
-  measuredInnerLabelHorizontalEmptySpace: input.measuredInnerLabelHorizontalEmptySpace,
-  maxAllowedInnerLabelHorizontalEmptySpace: PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
-  suggestedSchWidth: input.suggestedSchWidth,
-  message: SCHEMATIC_BOX_TOO_WIDE_MESSAGE
-});
-var createGenericIssue = (input) => ({
-  lineItemType: "GenericSchematicBoxTooWide",
-  schematicBox: input.schematicBox,
-  measuredInnerLabelHorizontalEmptySpace: input.measuredInnerLabelHorizontalEmptySpace,
-  maxAllowedInnerLabelHorizontalEmptySpace: GENERIC_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
-  suggestedSchWidth: input.suggestedSchWidth,
-  message: SCHEMATIC_BOX_TOO_WIDE_MESSAGE
-});
-var generateSchematicBoxWidthSizingCandidates = (componentPlacements, circuitJson) => {
-  const placementBySchematicComponentId = getPlacementBySchematicComponentId(componentPlacements);
-  const sourcePortById = getSourcePortById(circuitJson);
-  const sourceComponentById = getSourceComponentById(circuitJson);
-  const portsBySchematicComponentId = getPortsBySchematicComponentId(circuitJson, isHorizontalSide);
-  const candidates = [];
-  for (const [schematicComponentId, ports] of portsBySchematicComponentId) {
-    const schematicBox = placementBySchematicComponentId.get(schematicComponentId);
-    if (!schematicBox)
-      continue;
-    const bounds = getCenteredRectBounds(schematicBox);
-    const leftLabelColumn = getLabelColumn("left", ports, sourcePortById);
-    const rightLabelColumn = getLabelColumn("right", ports, sourcePortById);
-    const sourceComponentFtype = getSourceComponentFtype(schematicBox, sourceComponentById);
-    if (leftLabelColumn && rightLabelColumn) {
-      const measuredInnerLabelHorizontalEmptySpace = getInnerLabelEdge(bounds, rightLabelColumn) - getInnerLabelEdge(bounds, leftLabelColumn);
-      candidates.push({
-        schematicBox,
-        sourceComponentFtype,
-        measuredInnerLabelHorizontalEmptySpace
-      });
-      continue;
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+    addAttr(attrs, "pinSide", issue.pinSide);
+    addAttr(attrs, "edgeSide", issue.edgeSide);
+    addAttr(attrs, "pinName", issue.pinName);
+    addAttr(attrs, "measuredPadding", issue.measuredPadding);
+    addAttr(attrs, "maxAllowedPadding", issue.maxAllowedPadding);
+    addAttr(attrs, "excessPadding", issue.excessPadding);
+    addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
+    addAttr(attrs, "suggestedSchHeight", issue.suggestedSchHeight);
+    return `<SchematicPinPaddingToEdgeTooLarge ${attrs.join(" ")} />`;
+  }
+  isSchematicPort(el3) {
+    return el3.type === "schematic_port";
+  }
+  isSourcePort(el3) {
+    return el3.type === "source_port";
+  }
+  isSchematicComponent(el3) {
+    return el3.type === "schematic_component";
+  }
+  isHorizontalSide(side) {
+    return side === "left" || side === "right";
+  }
+  isVerticalSide(side) {
+    return side === "top" || side === "bottom";
+  }
+  isSchematicSide(side) {
+    return this.isHorizontalSide(side) || this.isVerticalSide(side);
+  }
+  isPinNameLabel(label, sourcePort) {
+    if (!sourcePort)
+      return false;
+    return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
+  }
+  estimateLabelWidth(label, sourcePort) {
+    return Array.from(label).length * (this.isPinNameLabel(label, sourcePort) ? this.PIN_NAME_CHARACTER_WIDTH : this.FALLBACK_CHARACTER_WIDTH);
+  }
+  exceedsMaxAllowedGap(measured, maxAllowed) {
+    return measured - maxAllowed > this.GAP_COMPARISON_EPSILON;
+  }
+  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
+    };
+  }
+  getSourcePortById(circuitJson) {
+    return new Map(circuitJson.filter((el3) => this.isSourcePort(el3)).map((sp3) => [sp3.source_port_id, sp3]));
+  }
+  getSchematicComponentById(circuitJson) {
+    return new Map(circuitJson.filter((el3) => this.isSchematicComponent(el3)).map((sc2) => [sc2.schematic_component_id, sc2]));
+  }
+  getPlacementBySchematicComponentId(componentPlacements) {
+    return new Map(componentPlacements.filter((p3) => p3.schematicComponentId).map((p3) => [p3.schematicComponentId, p3]));
+  }
+  getPortsBySchematicComponentId(circuitJson) {
+    const map = new Map;
+    for (const port of circuitJson.filter((el3) => this.isSchematicPort(el3))) {
+      if (!port.schematic_component_id)
+        continue;
+      if (!this.isSchematicSide(port.side_of_component))
+        continue;
+      const ports = map.get(port.schematic_component_id);
+      if (ports)
+        ports.push(port);
+      else
+        map.set(port.schematic_component_id, [port]);
     }
-    if (leftLabelColumn && leftLabelColumn.labelCount >= 4) {
-      const measuredInnerLabelHorizontalEmptySpace = bounds.right - getInnerLabelEdge(bounds, leftLabelColumn);
-      candidates.push({
-        schematicBox,
-        sourceComponentFtype,
-        measuredInnerLabelHorizontalEmptySpace
-      });
+    return map;
+  }
+  getPinSpacing(schematicBox, schematicComponentById) {
+    if (!schematicBox.schematicComponentId)
+      return null;
+    const sc2 = schematicComponentById.get(schematicBox.schematicComponentId);
+    return typeof sc2?.pin_spacing === "number" ? sc2.pin_spacing : null;
+  }
+  getPinName(port, sourcePortById) {
+    const sp3 = sourcePortById.get(port.source_port_id);
+    if (sp3?.name)
+      return sp3.name;
+    if (port.display_pin_label)
+      return port.display_pin_label;
+    if (sp3?.pin_number !== undefined)
+      return String(sp3.pin_number);
+    return;
+  }
+  getMaxLabelLengthBySide(ports, sourcePortById) {
+    const result = {
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0
+    };
+    for (const port of ports) {
+      if (!this.isSchematicSide(port.side_of_component))
+        continue;
+      if (!port.display_pin_label)
+        continue;
+      result[port.side_of_component] = Math.max(result[port.side_of_component], this.estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id)));
     }
-    if (rightLabelColumn && rightLabelColumn.labelCount >= 4) {
-      const measuredInnerLabelHorizontalEmptySpace = getInnerLabelEdge(bounds, rightLabelColumn) - bounds.left;
-      candidates.push({
-        schematicBox,
-        sourceComponentFtype,
-        measuredInnerLabelHorizontalEmptySpace
-      });
+    return result;
+  }
+  getOuterPinBySide(edgeSide, ports) {
+    if (ports.length === 0)
+      return null;
+    switch (edgeSide) {
+      case "top":
+        return ports.reduce((a2, b) => b.center.y > a2.center.y ? b : a2);
+      case "bottom":
+        return ports.reduce((a2, b) => b.center.y < a2.center.y ? b : a2);
+      case "left":
+        return ports.reduce((a2, b) => b.center.x < a2.center.x ? b : a2);
+      case "right":
+        return ports.reduce((a2, b) => b.center.x > a2.center.x ? b : a2);
     }
   }
-  return candidates;
-};
-var getPinHeaderSchematicBoxTooWideIssues = (candidates) => candidates.filter((candidate) => candidate.sourceComponentFtype === "simple_pin_header").filter((candidate) => exceedsMaxAllowedGap(candidate.measuredInnerLabelHorizontalEmptySpace, PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP)).map((candidate) => createPinHeaderIssue({
-  schematicBox: candidate.schematicBox,
-  measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
-  suggestedSchWidth: getSuggestedWidth({
-    measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
-    maxAllowedInnerLabelHorizontalEmptySpace: PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
-    currentWidth: candidate.schematicBox.width
-  })
-}));
-var getGenericSchematicBoxTooWideIssues = (candidates) => candidates.filter((candidate) => candidate.sourceComponentFtype !== "simple_pin_header").filter((candidate) => exceedsMaxAllowedGap(candidate.measuredInnerLabelHorizontalEmptySpace, GENERIC_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP)).map((candidate) => createGenericIssue({
-  schematicBox: candidate.schematicBox,
-  measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
-  suggestedSchWidth: getSuggestedWidth({
-    measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
-    maxAllowedInnerLabelHorizontalEmptySpace: GENERIC_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
-    currentWidth: candidate.schematicBox.width
-  })
-}));
-var generatePinHeaderSchematicBoxTooWideIssues = (componentPlacements, circuitJson) => getPinHeaderSchematicBoxTooWideIssues(generateSchematicBoxWidthSizingCandidates(componentPlacements, circuitJson));
-var generateGenericSchematicBoxTooWideIssues = (componentPlacements, circuitJson) => getGenericSchematicBoxTooWideIssues(generateSchematicBoxWidthSizingCandidates(componentPlacements, circuitJson));
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-overlap.ts
-var getCenteredRectBounds2 = (box2) => {
-  const halfWidth = box2.width / 2;
-  const halfHeight = box2.height / 2;
-  return {
-    left: box2.schX - halfWidth,
-    right: box2.schX + halfWidth,
-    top: box2.schY - halfHeight,
-    bottom: box2.schY + halfHeight
-  };
-};
-var getComponentOverlap = (firstComponent, secondComponent) => {
-  const firstBounds = getCenteredRectBounds2(firstComponent);
-  const secondBounds = getCenteredRectBounds2(secondComponent);
-  const left = Math.max(firstBounds.left, secondBounds.left);
-  const right = Math.min(firstBounds.right, secondBounds.right);
-  const top = Math.max(firstBounds.top, secondBounds.top);
-  const bottom = Math.min(firstBounds.bottom, secondBounds.bottom);
-  const overlapWidth = right - left;
-  const overlapHeight = bottom - top;
-  if (overlapWidth <= 0 || overlapHeight <= 0) {
-    return null;
+  getPinPaddingToEdge(schematicBox, port, edgeSide) {
+    const bounds = this.getCenteredRectBounds(schematicBox);
+    switch (edgeSide) {
+      case "top":
+        return Math.max(0, bounds.top - port.center.y);
+      case "bottom":
+        return Math.max(0, port.center.y - bounds.bottom);
+      case "left":
+        return Math.max(0, port.center.x - bounds.left);
+      case "right":
+        return Math.max(0, bounds.right - port.center.x);
+    }
   }
-  return {
-    lineItemType: "ComponentOverlap",
-    firstComponent,
-    secondComponent,
-    overlapWidth,
-    overlapHeight,
-    correctionSuggestions: getOverlapCorrectionSuggestions({
-      firstComponent,
-      secondComponent,
-      overlapWidth,
-      overlapHeight
-    })
-  };
-};
-var getOverlapCorrectionSuggestions = ({
-  firstComponent,
-  secondComponent,
-  overlapWidth,
-  overlapHeight
-}) => {
-  const firstArea = firstComponent.width * firstComponent.height;
-  const secondArea = secondComponent.width * secondComponent.height;
-  const targetComponent = firstArea <= secondArea ? firstComponent : secondComponent;
-  const otherComponent = targetComponent === firstComponent ? secondComponent : firstComponent;
-  const deltaSchX = targetComponent.schX <= otherComponent.schX ? -overlapWidth : overlapWidth;
-  const deltaSchY = targetComponent.schY <= otherComponent.schY ? -overlapHeight : overlapHeight;
-  return [
-    {
-      targetComponentName: targetComponent.sourceComponentName,
-      deltaSchX,
-      deltaSchY: 0,
-      newSchX: targetComponent.schX + deltaSchX,
-      newSchY: targetComponent.schY
-    },
-    {
-      targetComponentName: targetComponent.sourceComponentName,
-      deltaSchX: 0,
-      deltaSchY,
-      newSchX: targetComponent.schX,
-      newSchY: targetComponent.schY + deltaSchY
+  getBoxEdgeSidesForPinSide(pinSide) {
+    return this.isHorizontalSide(pinSide) ? ["top", "bottom"] : ["left", "right"];
+  }
+  hasPinsOnAllSides(portsBySide) {
+    return portsBySide.has("left") && portsBySide.has("right") && portsBySide.has("top") && portsBySide.has("bottom");
+  }
+  getMaxAllowedPinPadding(spacing, edgeSide, maxLabelLengthBySide) {
+    const sides = this.isHorizontalSide(edgeSide) ? ["left", "right"] : ["top", "bottom"];
+    return (maxLabelLengthBySide[sides[0]] + maxLabelLengthBySide[sides[1]] + spacing) / 2;
+  }
+  createIssue(candidate) {
+    const excessPadding = Math.max(0, candidate.measuredPadding - candidate.maxAllowedPadding);
+    const reduction = excessPadding * 2;
+    return {
+      lineItemType: "SchematicPinPaddingToEdgeTooLarge",
+      pinSide: candidate.pinSide,
+      edgeSide: candidate.edgeSide,
+      pinName: candidate.pinName,
+      schematicBox: candidate.schematicBox,
+      measuredPadding: candidate.measuredPadding,
+      maxAllowedPadding: candidate.maxAllowedPadding,
+      excessPadding,
+      suggestedSchWidth: this.isHorizontalSide(candidate.pinSide) ? undefined : Math.max(0, candidate.schematicBox.width - reduction),
+      suggestedSchHeight: this.isHorizontalSide(candidate.pinSide) ? Math.max(0, candidate.schematicBox.height - reduction) : undefined,
+      message: this.isHorizontalSide(candidate.pinSide) ? `${this.MESSAGE} height` : `${this.MESSAGE} width`
+    };
+  }
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver12 {
+  params;
+  VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
+  netLabels;
+  tokenToInvolvedPin;
+  currentIndex = 0;
+  seen = new Set;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    const { circuitJson } = params2.ctx;
+    this.netLabels = circuitJson.filter((el3) => this.isSchematicNetLabel(el3));
+    this.tokenToInvolvedPin = this.buildTokenToInvolvedPinMap(circuitJson);
+    this.solved = this.netLabels.length === 0;
+  }
+  _step() {
+    const label = this.netLabels[this.currentIndex++];
+    if (!label) {
+      this.solved = true;
+      return;
     }
-  ];
-};
-var generateSchematicPlacementIssues = (componentPlacements) => {
-  const issues = [];
-  for (let firstIndex = 0;firstIndex < componentPlacements.length; firstIndex++) {
-    for (let secondIndex = firstIndex + 1;secondIndex < componentPlacements.length; secondIndex++) {
-      const overlap = getComponentOverlap(componentPlacements[firstIndex], componentPlacements[secondIndex]);
-      if (overlap) {
-        issues.push(overlap);
+    this.solved = this.currentIndex >= this.netLabels.length;
+    if (!label.text.includes("/") || this.seen.has(label.text))
+      return;
+    this.seen.add(label.text);
+    const issue = {
+      lineItemType: "VerboseSchematicNetLabel",
+      schematicNetLabelId: label.schematic_net_label_id,
+      sourceNetId: label.source_net_id,
+      text: label.text,
+      involvedPins: this.getInvolvedPins(label.text, this.tokenToInvolvedPin),
+      schX: label.center.x,
+      schY: label.center.y,
+      message: this.VERBOSE_NET_LABEL_MESSAGE
+    };
+    this.params.issues.push(issue);
+  }
+  static issueToString(issue) {
+    const attrs = [];
+    addAttr(attrs, "message", issue.message, { escape: false });
+    addAttr(attrs, "text", issue.text);
+    addAttr(attrs, "involvedPins", issue.involvedPins.join(","));
+    addAttr(attrs, "schX", issue.schX);
+    addAttr(attrs, "schY", issue.schY);
+    return `<VerboseSchematicNetLabel ${attrs.join(" ")} />`;
+  }
+  isSchematicNetLabel(el3) {
+    return el3.type === "schematic_net_label";
+  }
+  isSourcePort(el3) {
+    return el3.type === "source_port";
+  }
+  getSourceComponentWithName(el3) {
+    if (el3.type !== "source_component" || !("source_component_id" in el3) || !("name" in el3) || typeof el3.source_component_id !== "string" || typeof el3.name !== "string")
+      return null;
+    return { source_component_id: el3.source_component_id, name: el3.name };
+  }
+  getSourcePortNameCandidates(port) {
+    return [
+      port.most_frequently_referenced_by_name,
+      port.name,
+      ...port.port_hints ?? [],
+      port.pin_number === undefined ? undefined : String(port.pin_number)
+    ].filter((n3) => Boolean(n3));
+  }
+  getBestSourcePortName(port) {
+    return port.most_frequently_referenced_by_name ?? port.name ?? (port.pin_number === undefined ? "" : `pin${port.pin_number}`);
+  }
+  buildTokenToInvolvedPinMap(circuitJson) {
+    const sourceComponentById = new Map(circuitJson.flatMap((el3) => {
+      const sc2 = this.getSourceComponentWithName(el3);
+      return sc2 ? [sc2] : [];
+    }).map((sc2) => [sc2.source_component_id, sc2]));
+    const map = new Map;
+    for (const port of circuitJson.filter((el3) => this.isSourcePort(el3))) {
+      if (!port.source_component_id)
+        continue;
+      const sc2 = sourceComponentById.get(port.source_component_id);
+      if (!sc2?.name)
+        continue;
+      const involvedPin = `${sc2.name}.${this.getBestSourcePortName(port)}`;
+      for (const name of this.getSourcePortNameCandidates(port)) {
+        map.set(`${sc2.name}_${name}`, involvedPin);
       }
     }
+    return map;
+  }
+  getInvolvedPins(text, tokenToInvolvedPin) {
+    const pins = new Set;
+    for (const token of text.split("/")) {
+      const pin = tokenToInvolvedPin.get(token);
+      if (pin)
+        pins.add(pin);
+    }
+    return Array.from(pins);
   }
-  return issues;
-};
+}
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/verbose-net-label.ts
-var VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
-var isSchematicNetLabel = (element) => element.type === "schematic_net_label";
-var isSourcePort2 = (element) => element.type === "source_port";
-var getSourceComponentWithName = (element) => {
-  if (element.type !== "source_component" || !("source_component_id" in element) || !("name" in element) || typeof element.source_component_id !== "string" || typeof element.name !== "string") {
-    return null;
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
+import { BaseSolver as BaseSolver13 } from "@tscircuit/solver-utils";
+class DiodeResistorAlignmentSolver extends BaseSolver13 {
+  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;
   }
-  return {
-    type: "source_component",
-    source_component_id: element.source_component_id,
-    name: element.name
-  };
-};
-var getSourcePortNameCandidates = (sourcePort) => [
-  sourcePort.most_frequently_referenced_by_name,
-  sourcePort.name,
-  ...sourcePort.port_hints ?? [],
-  sourcePort.pin_number === undefined ? undefined : String(sourcePort.pin_number)
-].filter((name) => Boolean(name));
-var getBestSourcePortName = (sourcePort) => sourcePort.most_frequently_referenced_by_name ?? sourcePort.name ?? (sourcePort.pin_number === undefined ? "" : `pin${sourcePort.pin_number}`);
-var getLabelTokenToInvolvedPinMap = (circuitJson) => {
-  const sourceComponentById = new Map(circuitJson.flatMap((element) => {
-    const sourceComponent = getSourceComponentWithName(element);
-    return sourceComponent ? [sourceComponent] : [];
-  }).map((sourceComponent) => [
-    sourceComponent.source_component_id,
-    sourceComponent
-  ]));
-  const tokenToInvolvedPin = new Map;
-  for (const sourcePort of circuitJson.filter(isSourcePort2)) {
-    if (!sourcePort.source_component_id)
-      continue;
-    const sourceComponent = sourceComponentById.get(sourcePort.source_component_id);
-    if (!sourceComponent?.name)
-      continue;
-    const involvedPin = `${sourceComponent.name}.${getBestSourcePortName(sourcePort)}`;
-    for (const portName of getSourcePortNameCandidates(sourcePort)) {
-      tokenToInvolvedPin.set(`${sourceComponent.name}_${portName}`, involvedPin);
+  _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 startSourceCompId = this.findSourceComponentIdNearPoint(start);
+    const endSourceCompId = this.findSourceComponentIdNearPoint(end);
+    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);
+    const resistorPort = this.findNearestPort(startFtype === "simple_resistor" ? start : end);
+    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}`));
     }
   }
-  return tokenToInvolvedPin;
-};
-var getInvolvedPins = (netLabelText, tokenToInvolvedPin) => {
-  const involvedPins = new Set;
-  for (const token of netLabelText.split("/")) {
-    const involvedPin = tokenToInvolvedPin.get(token);
-    if (involvedPin)
-      involvedPins.add(involvedPin);
+  static isCoLinear(a2, b, epsilon = 0.01) {
+    return Math.abs(a2.x - b.x) < epsilon || Math.abs(a2.y - b.y) < epsilon;
   }
-  return Array.from(involvedPins);
-};
-var generateVerboseNetLabelIssues = (circuitJson) => {
-  const tokenToInvolvedPin = getLabelTokenToInvolvedPinMap(circuitJson);
-  const issuesByText = new Map;
-  for (const netLabel of circuitJson.filter(isSchematicNetLabel)) {
-    if (!netLabel.text.includes("/"))
-      continue;
-    if (issuesByText.has(netLabel.text))
-      continue;
-    issuesByText.set(netLabel.text, {
-      lineItemType: "VerboseSchematicNetLabel",
-      schematicNetLabelId: netLabel.schematic_net_label_id,
-      sourceNetId: netLabel.source_net_id,
-      text: netLabel.text,
-      involvedPins: getInvolvedPins(netLabel.text, tokenToInvolvedPin),
-      schX: netLabel.center.x,
-      schY: netLabel.center.y,
-      message: VERBOSE_NET_LABEL_MESSAGE
-    });
+  static pinsFacingEachOther(aCenter, aFacing, bCenter, bFacing) {
+    const dx2 = bCenter.x - aCenter.x;
+    const dy2 = bCenter.y - aCenter.y;
+    const aToward = aFacing === "right" && dx2 > 0 || aFacing === "left" && dx2 < 0 || aFacing === "up" && dy2 > 0 || aFacing === "down" && dy2 < 0;
+    const bToward = bFacing === "right" && dx2 < 0 || bFacing === "left" && dx2 > 0 || bFacing === "up" && dy2 < 0 || bFacing === "down" && dy2 > 0;
+    return aToward && bToward;
   }
-  return Array.from(issuesByText.values());
-};
+  static dist(a2, b) {
+    return Math.sqrt((a2.x - b.x) ** 2 + (a2.y - b.y) ** 2);
+  }
+  findNearestPort(point5) {
+    let nearest;
+    let minDist = Infinity;
+    for (const port of this.schematicPorts) {
+      if (!port.center)
+        continue;
+      const d3 = DiodeResistorAlignmentSolver.dist(point5, port.center);
+      if (d3 < minDist) {
+        minDist = d3;
+        nearest = port;
+      }
+    }
+    return nearest;
+  }
+  findSourceComponentIdNearPoint(point5) {
+    const nearest = this.findNearestPort(point5);
+    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/analyzers/analyze-schematic-placement.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 formattedValue = fmtNumber5(value);
-  return value > 0 ? `+${formattedValue}` : formattedValue;
-};
-var isSchematicBox = (element) => element.type === "schematic_box";
-var isSchematicComponent3 = (element) => element.type === "schematic_component";
-var getSourceComponentName = (circuitJson, sourceComponentId) => {
-  if (!sourceComponentId)
-    return;
-  return cju7(circuitJson).source_component.get(sourceComponentId)?.name;
-};
-var schematicComponentToLineItem = (schematicComponent, circuitJson, schematicBox) => ({
-  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
-});
-var schematicBoxToLineItem = (schematicBox, circuitJson) => ({
-  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
-});
-var getSourceComponentMetadata = (schematicBox, circuitJson) => {
-  if (!schematicBox.schematic_component_id)
-    return {};
-  const circuitJsonUtil = cju7(circuitJson);
-  const schematicComponent = circuitJsonUtil.schematic_component.get(schematicBox.schematic_component_id);
-  if (!schematicComponent?.source_component_id)
-    return {};
-  const sourceComponent = circuitJsonUtil.source_component.get(schematicComponent.source_component_id);
-  return {
-    sourceComponentId: schematicComponent.source_component_id,
-    sourceComponentName: sourceComponent?.name
-  };
-};
-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}"`);
-};
-var lineItemToString3 = (lineItem) => {
-  const attrs = [];
-  addAttr(attrs, "componentName", lineItem.sourceComponentName);
-  addAttr(attrs, "positionAnchor", lineItem.positionAnchor);
-  addAttr(attrs, "schX", lineItem.schX);
-  addAttr(attrs, "schY", lineItem.schY);
-  addAttr(attrs, "width", lineItem.width);
-  addAttr(attrs, "height", lineItem.height);
-  return `<SchematicBoxPlacement ${attrs.join(" ")} />`;
-};
-var overlapIssueToString = (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(correctionSuggestionToString),
-    "</ComponentOverlap>"
-  ].join(`
-`);
-};
-var capacitorSymbolHorizontalIssueToString = (issue) => {
-  const attrs = [];
-  addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
-  addAttr(attrs, "schX", issue.schematicBox.schX);
-  addAttr(attrs, "schY", issue.schematicBox.schY);
-  addAttr(attrs, "width", issue.schematicBox.width);
-  addAttr(attrs, "height", issue.schematicBox.height);
-  return `<CapacitorSymbolHorizontal ${attrs.join(" ")} />`;
-};
-var verboseSchematicNetLabelIssueToString = (issue) => {
-  const attrs = [];
-  addAttr(attrs, "message", issue.message, { escape: false });
-  addAttr(attrs, "text", issue.text);
-  addAttr(attrs, "involvedPins", issue.involvedPins.join(","));
-  addAttr(attrs, "schX", issue.schX);
-  addAttr(attrs, "schY", issue.schY);
-  return `<VerboseSchematicNetLabel ${attrs.join(" ")} />`;
-};
-var schematicBoxTooWideIssueToString = (issue) => {
-  const attrs = [];
-  addAttr(attrs, "message", issue.message, { escape: false });
-  addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
-  addAttr(attrs, "currentSchWidth", issue.schematicBox.width);
-  addAttr(attrs, "measuredInnerLabelHorizontalEmptySpace", issue.measuredInnerLabelHorizontalEmptySpace);
-  addAttr(attrs, "maxAllowedInnerLabelHorizontalEmptySpace", issue.maxAllowedInnerLabelHorizontalEmptySpace);
-  addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
-  return `<${issue.lineItemType} ${attrs.join(" ")} />`;
-};
-var schematicPinPaddingToEdgeTooLargeIssueToString = (issue) => {
-  const attrs = [];
-  addAttr(attrs, "message", issue.message, { escape: false });
-  addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
-  addAttr(attrs, "pinSide", issue.pinSide);
-  addAttr(attrs, "edgeSide", issue.edgeSide);
-  addAttr(attrs, "pinName", issue.pinName);
-  addAttr(attrs, "measuredPadding", issue.measuredPadding);
-  addAttr(attrs, "maxAllowedPadding", issue.maxAllowedPadding);
-  addAttr(attrs, "excessPadding", issue.excessPadding);
-  addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
-  addAttr(attrs, "suggestedSchHeight", issue.suggestedSchHeight);
-  return `<SchematicPinPaddingToEdgeTooLarge ${attrs.join(" ")} />`;
-};
-var 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(" ")} />`;
-};
-var escapeAttr3 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
+class SchematicPlacementPipeline extends BasePipelineSolver2 {
+  ctx;
+  issues = [];
+  pipelineDef = [
+    definePipelineStep3("SchematicBoxOverlapSolver", SchematicBoxOverlapSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("CapacitorOrientationSolver", CapacitorOrientationSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("VerboseNetLabelSolver", VerboseNetLabelSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("SchematicBoxTooWideSolver", SchematicBoxTooWideSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("SchematicPinPaddingToEdgeSolver", SchematicPinPaddingToEdgeSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("SchematicBoxInnerLabelCollisionSolver", SchematicBoxInnerLabelCollisionSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("DiodeResistorAlignmentSolver", DiodeResistorAlignmentSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
+    ])
+  ];
+  _setup() {
+    this.ctx = buildSolverContext(this.inputProblem);
+  }
+  getOutput() {
+    return {
+      issues: this.issues,
+      componentPlacements: this.ctx.componentPlacements
+    };
+  }
+}
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyze-schematic-placement.ts
 class SchematicPlacementAnalysis {
   lineItems;
   constructor(lineItems) {
@@ -244894,32 +245501,47 @@ class SchematicPlacementAnalysis {
   getString() {
     return this.toString();
   }
+  schematicBoxPlacementsToString(lineItem) {
+    const attrs = [];
+    addAttr(attrs, "componentName", lineItem.sourceComponentName);
+    addAttr(attrs, "positionAnchor", lineItem.positionAnchor);
+    addAttr(attrs, "schX", lineItem.schX);
+    addAttr(attrs, "schY", lineItem.schY);
+    addAttr(attrs, "width", lineItem.width);
+    addAttr(attrs, "height", lineItem.height);
+    return `<SchematicBoxPlacement ${attrs.join(" ")} />`;
+  }
+  schematicIssuesToString(issue) {
+    switch (issue.lineItemType) {
+      case "ComponentOverlap":
+        return SchematicBoxOverlapSolver.issueToString(issue);
+      case "CapacitorSymbolHorizontal":
+        return CapacitorOrientationSolver.issueToString(issue);
+      case "VerboseSchematicNetLabel":
+        return VerboseNetLabelSolver.issueToString(issue);
+      case "PinHeaderSchematicBoxTooWide":
+      case "GenericSchematicBoxTooWide":
+        return SchematicBoxTooWideSolver.issueToString(issue);
+      case "SchematicBoxInnerLabelCollision":
+        return SchematicBoxInnerLabelCollisionSolver.issueToString(issue);
+      case "SchematicPinPaddingToEdgeTooLarge":
+        return SchematicPinPaddingToEdgeSolver.issueToString(issue);
+      case "DiodeResistorNotAligned":
+        return DiodeResistorAlignmentSolver.issueToString(issue);
+      default:
+        return "";
+    }
+  }
   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(lineItemToString3),
+      ...schematicBoxPlacements.map(this.schematicBoxPlacementsToString),
       "</SchematicBoxPositions>",
       ...issues.length > 0 ? [
         "<SchematicPlacementIssues>",
-        ...issues.map((issue) => {
-          switch (issue.lineItemType) {
-            case "ComponentOverlap":
-              return overlapIssueToString(issue);
-            case "CapacitorSymbolHorizontal":
-              return capacitorSymbolHorizontalIssueToString(issue);
-            case "VerboseSchematicNetLabel":
-              return verboseSchematicNetLabelIssueToString(issue);
-            case "PinHeaderSchematicBoxTooWide":
-            case "GenericSchematicBoxTooWide":
-              return schematicBoxTooWideIssueToString(issue);
-            case "SchematicPinPaddingToEdgeTooLarge":
-              return schematicPinPaddingToEdgeTooLargeIssueToString(issue);
-            default:
-              return "";
-          }
-        }),
+        ...issues.map(this.schematicIssuesToString),
         "</SchematicPlacementIssues>"
       ] : []
     ].join(`
@@ -244927,24 +245549,14 @@ class SchematicPlacementAnalysis {
   }
 }
 var analyzeSchematicPlacement = (circuitJson) => {
-  const schematicBoxes = circuitJson.filter(isSchematicBox);
-  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent3).map((schematicComponent) => schematicComponent.schematic_component_id));
+  const pipeline = new SchematicPlacementPipeline(circuitJson);
+  pipeline.solve();
+  const { issues, componentPlacements } = pipeline.getOutput();
   const lineItems = [
-    ...circuitJson.filter(isSchematicComponent3).map((schematicComponent) => schematicComponentToLineItem(schematicComponent, circuitJson, schematicBoxes.find((schematicBox) => schematicBox.schematic_component_id === schematicComponent.schematic_component_id))),
-    ...schematicBoxes.filter((schematicBox) => !schematicBox.schematic_component_id || !schematicComponentIds.has(schematicBox.schematic_component_id)).map((schematicBox) => schematicBoxToLineItem(schematicBox, circuitJson))
-  ];
-  const issues = [
-    ...generateSchematicPlacementIssues(lineItems),
-    ...generateCapacitorOrientationIssues(lineItems, circuitJson),
-    ...generateVerboseNetLabelIssues(circuitJson),
-    ...generatePinHeaderSchematicBoxTooWideIssues(lineItems, circuitJson),
-    ...generateGenericSchematicBoxTooWideIssues(lineItems, circuitJson),
-    ...generateSchematicPinPaddingToEdgeTooLargeIssues(lineItems, circuitJson)
-  ];
-  return new SchematicPlacementAnalysis([
-    ...lineItems,
+    ...componentPlacements,
     ...issues.length > 0 ? [{ lineItemType: "SchematicPlacementIssues", issues }] : []
-  ]);
+  ];
+  return new SchematicPlacementAnalysis(lineItems);
 };
 // cli/check/schematic-placement/register.ts
 var checkSchematicPlacement = async (file) => {