@tscircuit/schematic-trace-solver 0.0.61 → 0.0.63

package/dist/index.js

@@ -1511,18 +1511,19 @@ var ChipObstacleSpatialIndex = class {
 var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
 var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
 function getDimsForOrientation(params) {
-  const { orientation, netLabelWidth } = params;
+  const { orientation, netLabelWidth, netLabelHeight } = params;
   const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
+  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
   if (orientation === "y+" || orientation === "y-") {
     return {
-      // Rotated, so width/height swap
-      width: NET_LABEL_HORIZONTAL_HEIGHT,
+      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
+      width: horizHeight,
       height: horizWidth
     };
   }
   return {
     width: horizWidth,
-    height: NET_LABEL_HORIZONTAL_HEIGHT
+    height: horizHeight
   };
 }
 function getCenterFromAnchor(anchor, orientation, width, height) {
@@ -1651,7 +1652,8 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     chipObstacleSpatialIndex,
     overlappingSameNetTraceGroup,
     availableOrientations,
-    netLabelWidth
+    netLabelWidth,
+    netLabelHeight
   } = params;
   const pinId = overlappingSameNetTraceGroup.portOnlyPinId;
   if (!pinId) {
@@ -1685,7 +1687,8 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
   for (const orientation of orientations) {
     const { width: width2, height: height2 } = getDimsForOrientation({
       orientation,
-      netLabelWidth
+      netLabelWidth,
+      netLabelHeight
     });
     const baseCenter2 = getCenterFromAnchor(anchor, orientation, width2, height2);
     const outward2 = outwardOf(orientation);
@@ -1857,8 +1860,9 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
   overlappingSameNetTraceGroup;
   availableOrientations;
   chipObstacleSpatialIndex;
-  // Optional override for the width of the net label (per netId)
+  // Optional override for the width/height of the net label (per netId)
   netLabelWidth;
+  netLabelHeight;
   netLabelPlacement = null;
   testedCandidates = [];
   constructor(params) {
@@ -1868,6 +1872,7 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     this.overlappingSameNetTraceGroup = params.overlappingSameNetTraceGroup;
     this.availableOrientations = params.availableOrientations;
     this.netLabelWidth = params.netLabelWidth;
+    this.netLabelHeight = params.netLabelHeight;
     this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
   }
   getConstructorParams() {
@@ -1876,7 +1881,8 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       inputTraceMap: this.inputTraceMap,
       overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
       availableOrientations: this.availableOrientations,
-      netLabelWidth: this.netLabelWidth
+      netLabelWidth: this.netLabelWidth,
+      netLabelHeight: this.netLabelHeight
     };
   }
   _step() {
@@ -1891,7 +1897,8 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
         chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
         overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
         availableOrientations: this.availableOrientations,
-        netLabelWidth: this.netLabelWidth
+        netLabelWidth: this.netLabelWidth,
+        netLabelHeight: this.netLabelHeight
       });
       this.testedCandidates.push(...res.testedCandidates);
       if (res.placement) {
@@ -1961,7 +1968,8 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
           for (const orientation of candidateOrients) {
             const { width, height } = getDimsForOrientation({
               orientation,
-              netLabelWidth: this.netLabelWidth
+              netLabelWidth: this.netLabelWidth,
+              netLabelHeight: this.netLabelHeight
             });
             const center = getCenterFromAnchor(
               anchor,
@@ -2250,6 +2258,21 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
     )?.netLabelWidth;
   }
+  getNetLabelHeightForGroup(group) {
+    if (group.netId) {
+      const ncHeight = this.inputProblem.netConnections.find(
+        (nc) => nc.netId === group.netId
+      )?.netLabelHeight;
+      if (ncHeight !== void 0) return ncHeight;
+    }
+    const pinIds = group.overlappingTraces?.pins.map((p) => p.pinId) ?? [];
+    if (group.portOnlyPinId) {
+      pinIds.push(group.portOnlyPinId);
+    }
+    return this.inputProblem.netConnections.find(
+      (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
+    )?.netLabelHeight;
+  }
   _step() {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement);
@@ -2265,12 +2288,14 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       if (!this.triedAnyOrientationFallbackForCurrentGroup && !isAlreadyFull && this.currentGroup) {
         this.triedAnyOrientationFallbackForCurrentGroup = true;
         const netLabelWidth2 = this.getNetLabelWidthForGroup(this.currentGroup);
+        const netLabelHeight2 = this.getNetLabelHeightForGroup(this.currentGroup);
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
           overlappingSameNetTraceGroup: this.currentGroup,
           availableOrientations: fullOrients,
-          netLabelWidth: netLabelWidth2
+          netLabelWidth: netLabelWidth2,
+          netLabelHeight: netLabelHeight2
         });
         return;
       }
@@ -2291,12 +2316,14 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     this.currentGroup = nextOverlappingSameNetTraceGroup;
     this.triedAnyOrientationFallbackForCurrentGroup = false;
     const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup);
+    const netLabelHeight = this.getNetLabelHeightForGroup(this.currentGroup);
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
       overlappingSameNetTraceGroup: nextOverlappingSameNetTraceGroup,
       availableOrientations: this.inputProblem.availableNetLabelOrientations[netId] ?? ["x+", "x-", "y+", "y-"],
-      netLabelWidth
+      netLabelWidth,
+      netLabelHeight
     });
   }
   visualize() {
@@ -6084,7 +6111,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const anchorPoint = this.getWickOffsetAnchor(label.anchorPoint, orientation);
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label)
+      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label)
     });
     return this.getSideOffsetAnchor({
       anchorPoint,
@@ -6133,7 +6161,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getSearchDistanceLimit(label, orientation) {
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label)
+      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label)
     });
     const labelLength = orientation === "y+" || orientation === "y-" ? height : width;
     return Math.min(this.maxSearchDistance, labelLength * 2);
@@ -6156,7 +6185,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   createCandidate(label, anchorPoint, orientation) {
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label)
+      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label)
     });
     return {
       orientation,
@@ -6185,6 +6215,17 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
     )?.netLabelWidth;
   }
+  getNetLabelHeight(label) {
+    if (label.netId) {
+      const ncHeight = this.inputProblem.netConnections.find(
+        (connection) => connection.netId === label.netId
+      )?.netLabelHeight;
+      if (ncHeight !== void 0) return ncHeight;
+    }
+    return this.inputProblem.netConnections.find(
+      (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
+    )?.netLabelHeight;
+  }
   getCandidateStatus(candidate, label, labelIndex) {
     const boundsStatus = this.getBoundsStatus(
       getRectBounds(candidate.center, candidate.width, candidate.height),
@@ -6798,6 +6839,7 @@ var generateCandidatesAlongTrace = (params) => {
     getTraceVertexDistances(traceLocation.trace)
   );
   const netLabelWidth = getNetLabelWidth(inputProblem, label);
+  const netLabelHeight = getNetLabelHeight(inputProblem, label);
   const candidates = [];
   const seenCandidateKeys = /* @__PURE__ */ new Set();
   for (const pathDistance of candidateDistances) {
@@ -6820,6 +6862,7 @@ var generateCandidatesAlongTrace = (params) => {
           point,
           orientation,
           netLabelWidth,
+          netLabelHeight,
           traceLocation,
           pathDistance,
           label
@@ -6857,13 +6900,15 @@ var createCandidate = (params) => {
     point,
     orientation,
     netLabelWidth,
+    netLabelHeight,
     traceLocation,
     pathDistance,
     label
   } = params;
   const { width, height } = getDimsForOrientation({
     orientation,
-    netLabelWidth
+    netLabelWidth,
+    netLabelHeight
   });
   return {
     anchorPoint: point,
@@ -7026,6 +7071,15 @@ var getNetLabelWidth = (inputProblem, label) => {
   }
   return label.width;
 };
+var getNetLabelHeight = (inputProblem, label) => {
+  const ncHeightByNetId = inputProblem.netConnections.find(
+    (connection) => connection.netId === label.netId
+  )?.netLabelHeight;
+  if (ncHeightByNetId !== void 0) return ncHeightByNetId;
+  return inputProblem.netConnections.find(
+    (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
+  )?.netLabelHeight;
+};
 var roundDistance = (distance3) => Number(distance3.toFixed(6));
 var dedupeOrientations = (orientations) => [
   ...new Set(orientations)
@@ -7605,6 +7659,345 @@ globalConnNetId: ${label.globalConnNetId}`
   }
 };
 
+// lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts
+var ANCHOR_TRACE_CLEARANCE = 1e-4;
+var SEGMENT_PARALLEL_EPS = 1e-6;
+var CANDIDATE_STEP2 = 0.1;
+var OUTWARD_DIR = {
+  "x+": { x: 1, y: 0 },
+  "x-": { x: -1, y: 0 },
+  "y+": { x: 0, y: 1 },
+  "y-": { x: 0, y: -1 }
+};
+var CANDIDATE_STATUS_COLOR = {
+  ok: "green",
+  "label-collision": "orange",
+  "trace-collision": "darkorange",
+  "chip-collision": "red"
+};
+var CANDIDATE_STATUS_FILL = {
+  ok: "rgba(0, 200, 0, 0.25)",
+  "label-collision": "rgba(255, 160, 0, 0.2)",
+  "trace-collision": "rgba(200, 80, 0, 0.2)",
+  "chip-collision": "rgba(220, 0, 0, 0.15)"
+};
+function boundsOverlap(a, b) {
+  return a.minX < b.maxX - 1e-9 && a.maxX > b.minX + 1e-9 && a.minY < b.maxY - 1e-9 && a.maxY > b.minY + 1e-9;
+}
+function sampleAnchorsAlongSegment(a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len = Math.sqrt(dx * dx + dy * dy);
+  const steps = Math.max(1, Math.round(len / CANDIDATE_STEP2));
+  const anchors = [];
+  for (let k = 0; k <= steps; k++) {
+    const t = k / steps;
+    anchors.push({ x: a.x + t * dx, y: a.y + t * dy });
+  }
+  return anchors;
+}
+var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputNetLabelPlacements;
+  currentCollision = null;
+  currentLabelToMove = null;
+  candidateResults = [];
+  chipIndex;
+  traceMap;
+  skippedCollisionKeys = /* @__PURE__ */ new Set();
+  labelsToTry = [];
+  candidateQueue = [];
+  candidateIndex = 0;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+    this.chipIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
+    this.traceMap = Object.fromEntries(
+      params.traces.map((t) => [t.mspPairId, t])
+    );
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  getOutput() {
+    return { netLabelPlacements: this.outputNetLabelPlacements };
+  }
+  labelBounds(label) {
+    return getRectBounds(label.center, label.width, label.height);
+  }
+  collisionKey(a, b) {
+    return [a.globalConnNetId, b.globalConnNetId].sort().join("::");
+  }
+  findNextCollidingPair() {
+    const labels = this.outputNetLabelPlacements;
+    for (let i = 0; i < labels.length; i++) {
+      for (let j = i + 1; j < labels.length; j++) {
+        const a = labels[i];
+        const b = labels[j];
+        if (a.globalConnNetId === b.globalConnNetId) continue;
+        if (this.skippedCollisionKeys.has(this.collisionKey(a, b))) continue;
+        if (boundsOverlap(this.labelBounds(a), this.labelBounds(b)))
+          return [a, b];
+      }
+    }
+    return null;
+  }
+  netLabelWidthOf(label) {
+    if (label.orientation === "x+" || label.orientation === "x-")
+      return label.width;
+    return label.height;
+  }
+  netLabelHeightOf(label) {
+    if (label.orientation === "x+" || label.orientation === "x-")
+      return label.height;
+    return label.width;
+  }
+  buildCandidatesForLabel(label) {
+    const netLabelWidth = this.netLabelWidthOf(label);
+    const netLabelHeight = this.netLabelHeightOf(label);
+    const candidates = [];
+    const buildCandidate = (orientation, anchor, hostPairId, hostSegIndex) => {
+      const { width, height } = getDimsForOrientation({
+        orientation,
+        netLabelWidth,
+        netLabelHeight
+      });
+      const baseCenter = getCenterFromAnchor(anchor, orientation, width, height);
+      const outwardDir = OUTWARD_DIR[orientation];
+      const center = {
+        x: baseCenter.x + outwardDir.x * ANCHOR_TRACE_CLEARANCE,
+        y: baseCenter.y + outwardDir.y * ANCHOR_TRACE_CLEARANCE
+      };
+      return {
+        orientation,
+        anchor,
+        center,
+        width,
+        height,
+        bounds: getRectBounds(center, width, height),
+        hostPairId,
+        hostSegIndex,
+        status: null
+      };
+    };
+    const isPortOnly = label.mspConnectionPairIds.length === 0;
+    if (isPortOnly) {
+      const allOrientations = ["x+", "x-", "y+", "y-"];
+      const orderedOrientations = [
+        label.orientation,
+        ...allOrientations.filter((o) => o !== label.orientation)
+      ];
+      for (const orientation of orderedOrientations) {
+        candidates.push(buildCandidate(orientation, label.anchorPoint));
+      }
+    } else {
+      for (const mspPairId of label.mspConnectionPairIds) {
+        const trace = this.traceMap[mspPairId];
+        if (!trace) continue;
+        const pts = trace.tracePath;
+        for (let si = 0; si < pts.length - 1; si++) {
+          const segStart = pts[si];
+          const segEnd = pts[si + 1];
+          const isHorizontal3 = Math.abs(segStart.y - segEnd.y) < SEGMENT_PARALLEL_EPS;
+          const isVertical4 = Math.abs(segStart.x - segEnd.x) < SEGMENT_PARALLEL_EPS;
+          if (!isHorizontal3 && !isVertical4) continue;
+          let perpendicularOrientations;
+          if (isHorizontal3) {
+            perpendicularOrientations = ["y+", "y-"];
+          } else {
+            perpendicularOrientations = ["x+", "x-"];
+          }
+          for (const anchor of sampleAnchorsAlongSegment(segStart, segEnd)) {
+            for (const orientation of perpendicularOrientations) {
+              candidates.push(
+                buildCandidate(
+                  orientation,
+                  anchor,
+                  mspPairId,
+                  si
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+    return candidates;
+  }
+  checkCandidate(candidate, movingLabelNetId, obstacleLabels) {
+    const { bounds, hostPairId, hostSegIndex } = candidate;
+    if (this.chipIndex.getChipsInBounds(bounds).length > 0)
+      return "chip-collision";
+    if (rectIntersectsAnyTrace(bounds, this.traceMap, hostPairId, hostSegIndex).hasIntersection) {
+      return "trace-collision";
+    }
+    for (const obstacle of obstacleLabels) {
+      if (obstacle.globalConnNetId === movingLabelNetId) continue;
+      if (boundsOverlap(bounds, this.labelBounds(obstacle)))
+        return "label-collision";
+    }
+    return "ok";
+  }
+  beginSearchForLabel(label) {
+    this.currentLabelToMove = label;
+    this.candidateQueue = this.buildCandidatesForLabel(label);
+    this.candidateIndex = 0;
+    this.candidateResults = [];
+  }
+  clearActiveSearch() {
+    this.currentCollision = null;
+    this.currentLabelToMove = null;
+    this.labelsToTry = [];
+    this.candidateQueue = [];
+    this.candidateIndex = 0;
+    this.candidateResults = [];
+  }
+  _step() {
+    if (!this.currentCollision) {
+      const pair = this.findNextCollidingPair();
+      if (!pair) {
+        this.solved = true;
+        return;
+      }
+      this.currentCollision = pair;
+      this.labelsToTry = [pair[1], pair[0]];
+      this.beginSearchForLabel(this.labelsToTry.shift());
+      return;
+    }
+    if (this.candidateIndex >= this.candidateQueue.length) {
+      if (this.labelsToTry.length > 0) {
+        this.beginSearchForLabel(this.labelsToTry.shift());
+      } else {
+        this.skippedCollisionKeys.add(
+          this.collisionKey(this.currentCollision[0], this.currentCollision[1])
+        );
+        this.clearActiveSearch();
+      }
+      return;
+    }
+    const candidate = this.candidateQueue[this.candidateIndex++];
+    const [labelA, labelB] = this.currentCollision;
+    let fixedLabel;
+    if (this.currentLabelToMove === labelB) {
+      fixedLabel = labelA;
+    } else {
+      fixedLabel = labelB;
+    }
+    const obstacleLabels = [
+      ...this.outputNetLabelPlacements.filter(
+        (l) => l !== labelA && l !== labelB
+      ),
+      fixedLabel
+    ];
+    const status = this.checkCandidate(
+      candidate,
+      this.currentLabelToMove.globalConnNetId,
+      obstacleLabels
+    );
+    candidate.status = status;
+    this.candidateResults.push({ ...candidate });
+    if (status === "ok") {
+      const idx = this.outputNetLabelPlacements.indexOf(
+        this.currentLabelToMove
+      );
+      if (idx !== -1) {
+        this.outputNetLabelPlacements[idx] = {
+          ...this.currentLabelToMove,
+          orientation: candidate.orientation,
+          anchorPoint: candidate.anchor,
+          width: candidate.width,
+          height: candidate.height,
+          center: candidate.center
+        };
+      }
+      this.clearActiveSearch();
+    }
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem);
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.rects) graphics.rects = [];
+    if (!graphics.points) graphics.points = [];
+    for (const trace of this.traces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const label of this.outputNetLabelPlacements) {
+      const isInActiveCollision = this.currentCollision != null && (label === this.currentCollision[0] || label === this.currentCollision[1]);
+      let labelFill;
+      let labelStroke;
+      let labelText;
+      let pointColor;
+      if (isInActiveCollision) {
+        labelFill = "rgba(255, 0, 0, 0.2)";
+        labelStroke = "red";
+        labelText = `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}
+\u26A0 COLLIDING`;
+        pointColor = "red";
+      } else {
+        labelFill = getColorFromString(label.globalConnNetId, 0.35);
+        labelStroke = getColorFromString(label.globalConnNetId, 0.9);
+        labelText = `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`;
+        pointColor = getColorFromString(label.globalConnNetId, 0.9);
+      }
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: labelFill,
+        strokeColor: labelStroke,
+        label: labelText
+      });
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: pointColor,
+        label: `anchorPoint
+orientation: ${label.orientation}`
+      });
+    }
+    const movingNetId = this.currentLabelToMove ? this.currentLabelToMove.netId : "?";
+    for (const c of this.candidateResults) {
+      const statusColor = CANDIDATE_STATUS_COLOR[c.status];
+      const statusFill = CANDIDATE_STATUS_FILL[c.status];
+      let strokeDash;
+      if (c.status !== "ok") strokeDash = "4 2";
+      graphics.rects.push({
+        center: c.center,
+        width: c.width,
+        height: c.height,
+        fill: statusFill,
+        strokeColor: statusColor,
+        strokeDash,
+        label: `candidate: ${c.status}
+orientation: ${c.orientation}
+moving: ${movingNetId}`
+      });
+      graphics.points.push({
+        x: c.anchor.x,
+        y: c.anchor.y,
+        color: statusColor,
+        label: `candidate anchor
+${c.status}`
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -7630,6 +8023,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   vccNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
   netLabelTraceCollisionSolver;
+  netLabelNetLabelCollisionSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -7821,6 +8215,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           netLabelPlacements: instance.traceAnchoredNetLabelOverlapSolver.outputNetLabelPlacements
         }
       ]
+    ),
+    definePipelineStep(
+      "netLabelNetLabelCollisionSolver",
+      NetLabelNetLabelCollisionSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.netLabelTraceCollisionSolver.getOutput().traces,
+          netLabelPlacements: instance.netLabelTraceCollisionSolver.getOutput().netLabelPlacements
+        }
+      ]
     )
   ];
   constructor(inputProblem) {

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -429,6 +429,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label),
     })
 
     return this.getSideOffsetAnchor({
@@ -494,6 +495,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label),
     })
     const labelLength =
       orientation === "y+" || orientation === "y-" ? height : width
@@ -534,6 +536,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label),
     })
     return {
       orientation,
@@ -567,6 +570,19 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )?.netLabelWidth
   }
 
+  private getNetLabelHeight(label: NetLabelPlacement) {
+    if (label.netId) {
+      const ncHeight = this.inputProblem.netConnections.find(
+        (connection) => connection.netId === label.netId,
+      )?.netLabelHeight
+      if (ncHeight !== undefined) return ncHeight
+    }
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => label.pinIds.includes(pid)),
+    )?.netLabelHeight
+  }
+
   private getCandidateStatus(
     candidate: CandidateLabel,
     label: NetLabelPlacement,