@tscircuit/schematic-trace-solver 0.0.62 → 0.0.64

package/dist/index.d.ts

@@ -83,6 +83,7 @@ interface InputNetConnection {
     netId: string;
     pinIds: Array<PinId>;
     netLabelWidth?: number;
+    netLabelHeight?: number;
 }
 interface InputProblem {
     chips: Array<InputChip>;
@@ -288,6 +289,7 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
     availableOrientations: Array<FacingDirection>;
     chipObstacleSpatialIndex: ChipObstacleSpatialIndex;
     netLabelWidth?: number;
+    netLabelHeight?: number;
     netLabelPlacement: NetLabelPlacement | null;
     testedCandidates: Array<{
         center: {
@@ -316,6 +318,7 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
         overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup;
         availableOrientations: FacingDirection[];
         netLabelWidth?: number;
+        netLabelHeight?: number;
     });
     getConstructorParams(): ConstructorParameters<typeof SingleNetLabelPlacementSolver>[0];
     _step(): void;
@@ -385,6 +388,7 @@ declare class NetLabelPlacementSolver extends BaseSolver {
     });
     computeOverlappingSameNetTraceGroups(): Array<OverlappingSameNetTraceGroup>;
     private getNetLabelWidthForGroup;
+    private getNetLabelHeightForGroup;
     _step(): void;
     visualize(): GraphicsObject;
 }
@@ -700,6 +704,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private findValidLateralShiftedCandidate;
     private findValidCandidateInShiftColumn;
     private evaluateCandidate;
+    private getCandidateConnectorTrace;
     private getSearchStartAnchor;
     private getWickOffsetAnchor;
     private getSideOffsetAnchor;
@@ -707,6 +712,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getLateralColumnMaxDistance;
     private createCandidate;
     private getNetLabelWidth;
+    private getNetLabelHeight;
     private getCandidateStatus;
     private getBoundsStatus;
     private intersectsAnyOtherNetLabel;
@@ -911,6 +917,7 @@ declare class NetLabelNetLabelCollisionSolver extends BaseSolver {
     private collisionKey;
     private findNextCollidingPair;
     private netLabelWidthOf;
+    private netLabelHeightOf;
     private buildCandidatesForLabel;
     private checkCandidate;
     private beginSearchForLabel;

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() {
@@ -5609,6 +5636,14 @@ var tracePathCrossesAnyBounds = (tracePath, bounds) => {
   }
   return false;
 };
+var tracePathIntersectsBounds = (tracePath, bounds) => {
+  for (let i = 0; i < tracePath.length - 1; i++) {
+    if (segmentIntersectsRect2(tracePath[i], tracePath[i + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
 var tracePathCrossesAnyTrace = (tracePath, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -5873,28 +5908,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     this.addConnectorTrace(label, candidate, labelIndex);
   }
   addConnectorTrace(label, candidate, labelIndex) {
-    let tracePath;
-    if (candidate.phase === "lateral-shift") {
-      const orientDir = dir(candidate.orientation);
-      const kickedSource = {
-        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
-        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP
-      };
-      tracePath = simplifyOrthogonalPath([
-        label.anchorPoint,
-        ...getConnectorTracePath(
-          kickedSource,
-          candidate.anchorPoint,
-          candidate.orientation
-        )
-      ]);
-    } else {
-      tracePath = getConnectorTracePath(
-        label.anchorPoint,
-        candidate.anchorPoint,
-        candidate.orientation
-      );
-    }
+    const tracePath = this.getCandidateConnectorTrace(label, candidate);
     if (tracePath.length < 2) return;
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
     const connectorTrace = {
@@ -6077,14 +6091,42 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       distance: distance3,
       outwardDistance,
       selected: false,
-      status: this.getCandidateStatus(candidate, label, labelIndex)
+      status: this.getCandidateStatus({
+        candidate,
+        label,
+        labelIndex,
+        phase
+      })
     };
   }
+  getCandidateConnectorTrace(label, candidate) {
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation);
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP
+      };
+      return simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation
+        )
+      ]);
+    }
+    return getConnectorTracePath(
+      label.anchorPoint,
+      candidate.anchorPoint,
+      candidate.orientation
+    );
+  }
   getSearchStartAnchor(label, orientation) {
     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 +6175,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 +6199,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,17 +6229,29 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
     )?.netLabelWidth;
   }
-  getCandidateStatus(candidate, label, labelIndex) {
+  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(params) {
+    const { candidate, label, labelIndex, phase } = params;
     const boundsStatus = this.getBoundsStatus(
       getRectBounds(candidate.center, candidate.width, candidate.height),
       labelIndex
     );
     if (boundsStatus !== "valid") return boundsStatus;
-    const connectorTrace = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation
-    );
+    const connectorTrace = this.getCandidateConnectorTrace(label, {
+      anchorPoint: candidate.anchorPoint,
+      orientation: candidate.orientation,
+      phase
+    });
     if (tracePathCrossesAnyTrace(connectorTrace, this.traceMap)) {
       return "trace-collision";
     }
@@ -6207,7 +6263,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue;
       const otherLabel = this.outputNetLabelPlacements[i];
-      if (tracePathCrossesAnyBounds(
+      if (tracePathIntersectsBounds(
         connectorTrace,
         getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height)
       )) {
@@ -6798,6 +6854,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 +6877,7 @@ var generateCandidatesAlongTrace = (params) => {
           point,
           orientation,
           netLabelWidth,
+          netLabelHeight,
           traceLocation,
           pathDistance,
           label
@@ -6857,13 +6915,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 +7086,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)
@@ -7437,16 +7506,14 @@ function buildMergedObstacleLabel(seedLabel, allLabels) {
     height: h
   };
 }
-function detectInnerTraceLabelOverlaps(traces, labels) {
+function detectTraceLabelOverlaps(traces, labels) {
   const overlaps = [];
   for (const trace of traces) {
     for (const label of labels) {
       if (trace.globalConnNetId === label.globalConnNetId) continue;
       const bounds = getRectBounds(label.center, label.width, label.height);
       const path = trace.tracePath;
-      const innerStart = 1;
-      const innerEnd = path.length - 2;
-      for (let i = innerStart; i < innerEnd; i++) {
+      for (let i = 0; i < path.length - 1; i++) {
         if (segmentIntersectsRect2(path[i], path[i + 1], bounds)) {
           overlaps.push({ trace, label });
           break;
@@ -7512,7 +7579,7 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
       }
       return;
     }
-    const overlaps = detectInnerTraceLabelOverlaps(
+    const overlaps = detectTraceLabelOverlaps(
       this.outputTraces,
       this.outputNetLabelPlacements
     );
@@ -7702,13 +7769,20 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
       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
+        netLabelWidth,
+        netLabelHeight
       });
       const baseCenter = getCenterFromAnchor(anchor, orientation, width, height);
       const outwardDir = OUTWARD_DIR[orientation];

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -22,6 +22,7 @@ import {
   rectsOverlap,
   simplifyOrthogonalPath,
   traceCrossesBoundsInterior,
+  tracePathIntersectsBounds,
   tracePathCrossesAnyBounds,
   tracePathCrossesAnyTrace,
 } from "./geometry"
@@ -143,30 +144,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
-    let tracePath: Point[]
-
-    if (candidate.phase === "lateral-shift") {
-      const orientDir = dir(candidate.orientation)
-      const kickedSource = {
-        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
-        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP,
-      }
-      tracePath = simplifyOrthogonalPath([
-        label.anchorPoint,
-        ...getConnectorTracePath(
-          kickedSource,
-          candidate.anchorPoint,
-          candidate.orientation,
-        ),
-      ])
-    } else {
-      tracePath = getConnectorTracePath(
-        label.anchorPoint,
-        candidate.anchorPoint,
-        candidate.orientation,
-      )
-    }
-
+    const tracePath = this.getCandidateConnectorTrace(label, candidate)
     if (tracePath.length < 2) return
 
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`
@@ -417,8 +395,43 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       distance,
       outwardDistance,
       selected: false,
-      status: this.getCandidateStatus(candidate, label, labelIndex),
+      status: this.getCandidateStatus({
+        candidate,
+        label,
+        labelIndex,
+        phase,
+      }),
+    }
+  }
+
+  private getCandidateConnectorTrace(
+    label: NetLabelPlacement,
+    candidate: Pick<
+      EvaluatedCandidate,
+      "anchorPoint" | "orientation" | "phase"
+    >,
+  ) {
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation)
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP,
+      }
+      return simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation,
+        ),
+      ])
     }
+
+    return getConnectorTracePath(
+      label.anchorPoint,
+      candidate.anchorPoint,
+      candidate.orientation,
+    )
   }
 
   private getSearchStartAnchor(
@@ -429,6 +442,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label),
     })
 
     return this.getSideOffsetAnchor({
@@ -494,6 +508,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 +549,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label),
     })
     return {
       orientation,
@@ -567,22 +583,37 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )?.netLabelWidth
   }
 
-  private getCandidateStatus(
-    candidate: CandidateLabel,
-    label: NetLabelPlacement,
-    labelIndex: number,
-  ) {
+  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(params: {
+    candidate: CandidateLabel
+    label: NetLabelPlacement
+    labelIndex: number
+    phase: CandidatePhase
+  }) {
+    const { candidate, label, labelIndex, phase } = params
     const boundsStatus = this.getBoundsStatus(
       getRectBounds(candidate.center, candidate.width, candidate.height),
       labelIndex,
     )
     if (boundsStatus !== "valid") return boundsStatus
 
-    const connectorTrace = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation,
-    )
+    const connectorTrace = this.getCandidateConnectorTrace(label, {
+      anchorPoint: candidate.anchorPoint,
+      orientation: candidate.orientation,
+      phase,
+    })
 
     if (tracePathCrossesAnyTrace(connectorTrace, this.traceMap)) {
       return "trace-collision"
@@ -598,7 +629,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       if (i === labelIndex) continue
       const otherLabel = this.outputNetLabelPlacements[i]!
       if (
-        tracePathCrossesAnyBounds(
+        tracePathIntersectsBounds(
           connectorTrace,
           getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height),
         )

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -2,6 +2,7 @@ import type { Point } from "@tscircuit/math-utils"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import type { FacingDirection } from "lib/utils/dir"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { EPS, TRACE_BOUNDARY_TOLERANCE } from "./constants"
 import type { Bounds, ChipSide } from "./types"
 
@@ -102,6 +103,18 @@ export const tracePathCrossesAnyBounds = (
   return false
 }
 
+export const tracePathIntersectsBounds = (
+  tracePath: Point[],
+  bounds: Bounds,
+) => {
+  for (let i = 0; i < tracePath.length - 1; i++) {
+    if (segmentIntersectsRect(tracePath[i]!, tracePath[i + 1]!, bounds)) {
+      return true
+    }
+  }
+  return false
+}
+
 export const tracePathCrossesAnyTrace = (
   tracePath: Point[],
   traceMap: Record<string, SolvedTracePath>,

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -170,8 +170,15 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
     return label.height
   }
 
+  private netLabelHeightOf(label: NetLabelPlacement): number | undefined {
+    if (label.orientation === "x+" || label.orientation === "x-")
+      return label.height
+    return label.width
+  }
+
   private buildCandidatesForLabel(label: NetLabelPlacement): Candidate[] {
     const netLabelWidth = this.netLabelWidthOf(label)
+    const netLabelHeight = this.netLabelHeightOf(label)
     const candidates: Candidate[] = []
 
     const buildCandidate = (
@@ -183,6 +190,7 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
       const { width, height } = getDimsForOrientation({
         orientation,
         netLabelWidth,
+        netLabelHeight,
       })
       const baseCenter = getCenterFromAnchor(anchor, orientation, width, height)
       const outwardDir = OUTWARD_DIR[orientation]