@tscircuit/schematic-trace-solver 0.0.133 → 0.0.134

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS13 = 1e-9;
+  const EPS14 = 1e-9;
   const crossesSegment = (a, b) => {
     for (const [, rcl] of restrictedCenterLines) {
       if (rcl.axes.has("x") && typeof rcl.x === "number") {
-        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS13) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS14) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS13) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS14) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS13 || Math.abs(p1.y - p2.y) < EPS13) {
+  if (Math.abs(p1.x - p2.x) < EPS14 || Math.abs(p1.y - p2.y) < EPS14) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1424,8 +1424,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS13 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS13 && Math.abs(p.y - q.y) < EPS13;
+      const EPS14 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS14 && Math.abs(p.y - q.y) < EPS14;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1709,13 +1709,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS13 = 1e-6
+  EPS: EPS14 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical5 = Math.abs(start.x - end.x) < EPS13;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS13;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS14;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS14;
   if (!isVertical5 && !isHorizontal4) return;
   const segDir = isVertical5 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2144,7 +2144,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS13 = 2e-3;
+    const EPS14 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -2171,7 +2171,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS13) {
+          if (rangeOverlap > EPS14) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2190,7 +2190,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS13) return;
+          if (rangeOverlap < -EPS14) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2213,8 +2213,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS13;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS13;
+            const aVert = Math.abs(a1.x - a2.x) < EPS14;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS14;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2225,11 +2225,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS13;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS13;
+                const bVert = Math.abs(b1.x - b2.x) < EPS14;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS14;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS13) {
+                  if (Math.abs(a1.x - b1.x) < EPS14) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2239,7 +2239,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS13) {
+                  if (Math.abs(a1.y - b1.y) < EPS14) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2295,14 +2295,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS13 = 2e-3;
+    const EPS14 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS13;
-        const isVertical5 = Math.abs(p1.x - p2.x) < EPS13;
+        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS14;
+        const isVertical5 = Math.abs(p1.x - p2.x) < EPS14;
         if (!isHorizontal4 && !isVertical5) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2316,13 +2316,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS13 = 2e-3;
+    const EPS14 = 2e-3;
     const p0 = i > 0 ? tracePath[i - 1] : null;
     const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null;
-    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS13 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS13 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS13 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS13 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS14 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS14 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS14 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS14 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2450,24 +2450,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS13 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS13;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS13;
+function segmentIntersectsRect2(p1, p2, rect, EPS14 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS14;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS14;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS13 || x > rect.maxX + EPS13) return false;
+    if (x < rect.minX - EPS14 || x > rect.maxX + EPS14) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS13;
+    return overlap > EPS14;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS13 || y > rect.maxY + EPS13) return false;
+    if (y < rect.minY - EPS14 || y > rect.maxY + EPS14) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS13;
+    return overlap > EPS14;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -2864,14 +2864,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS13 = 1e-6;
+    const EPS14 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS13;
-        const isV = Math.abs(a.x - b.x) < EPS13;
+        const isH = Math.abs(a.y - b.y) < EPS14;
+        const isV = Math.abs(a.x - b.x) < EPS14;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4619,6 +4619,81 @@ var distance3 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 var manhattanDistance = (p1, p2) => Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+var EPS6 = 1e-9;
+var between = (value, first, second) => value >= Math.min(first, second) - EPS6 && value <= Math.max(first, second) + EPS6;
+var getAxisAlignedIntersection = (firstStart, firstEnd, secondStart, secondEnd) => {
+  const firstIsHorizontal = Math.abs(firstStart.y - firstEnd.y) <= EPS6;
+  const firstIsVertical = Math.abs(firstStart.x - firstEnd.x) <= EPS6;
+  const secondIsHorizontal = Math.abs(secondStart.y - secondEnd.y) <= EPS6;
+  const secondIsVertical = Math.abs(secondStart.x - secondEnd.x) <= EPS6;
+  if (firstIsHorizontal && secondIsVertical) {
+    const point = { x: secondStart.x, y: firstStart.y };
+    return between(point.x, firstStart.x, firstEnd.x) && between(point.y, secondStart.y, secondEnd.y) ? point : null;
+  }
+  if (firstIsVertical && secondIsHorizontal) {
+    const point = { x: firstStart.x, y: secondStart.y };
+    return between(point.y, firstStart.y, firstEnd.y) && between(point.x, secondStart.x, secondEnd.x) ? point : null;
+  }
+  if (firstIsHorizontal && secondIsHorizontal && Math.abs(firstStart.y - secondStart.y) <= EPS6) {
+    const overlapMin = Math.max(
+      Math.min(firstStart.x, firstEnd.x),
+      Math.min(secondStart.x, secondEnd.x)
+    );
+    const overlapMax = Math.min(
+      Math.max(firstStart.x, firstEnd.x),
+      Math.max(secondStart.x, secondEnd.x)
+    );
+    if (overlapMin > overlapMax + EPS6) return null;
+    return {
+      x: Math.max(overlapMin, Math.min(firstStart.x, overlapMax)),
+      y: firstStart.y
+    };
+  }
+  if (firstIsVertical && secondIsVertical && Math.abs(firstStart.x - secondStart.x) <= EPS6) {
+    const overlapMin = Math.max(
+      Math.min(firstStart.y, firstEnd.y),
+      Math.min(secondStart.y, secondEnd.y)
+    );
+    const overlapMax = Math.min(
+      Math.max(firstStart.y, firstEnd.y),
+      Math.max(secondStart.y, secondEnd.y)
+    );
+    if (overlapMin > overlapMax + EPS6) return null;
+    return {
+      x: firstStart.x,
+      y: Math.max(overlapMin, Math.min(firstStart.y, overlapMax))
+    };
+  }
+  return null;
+};
+var clipPathAtFirstIntersection = (tracePath, existingTraces) => {
+  for (let pathIndex = 0; pathIndex < tracePath.length - 1; pathIndex++) {
+    const pathStart = tracePath[pathIndex];
+    const pathEnd = tracePath[pathIndex + 1];
+    const intersections = existingTraces.flatMap(
+      (trace) => trace.tracePath.slice(0, -1).flatMap((traceStart, traceIndex) => {
+        const intersection2 = getAxisAlignedIntersection(
+          pathStart,
+          pathEnd,
+          traceStart,
+          trace.tracePath[traceIndex + 1]
+        );
+        return intersection2 ? [intersection2] : [];
+      })
+    );
+    intersections.sort(
+      (first, second) => distance3(pathStart, first) - distance3(pathStart, second)
+    );
+    const intersection = intersections[0];
+    if (!intersection) continue;
+    const clippedPath = tracePath.slice(0, pathIndex + 1);
+    if (distance3(clippedPath.at(-1), intersection) > EPS6) {
+      clippedPath.push(intersection);
+    }
+    return clippedPath;
+  }
+  return null;
+};
 var LongDistancePairSolver = class extends BaseSolver {
   constructor(params) {
     super();
@@ -4733,20 +4808,36 @@ var LongDistancePairSolver = class extends BaseSolver {
     } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath;
       if (newTracePath && this.currentCandidatePair) {
+        const [p1, p2] = this.currentCandidatePair;
+        const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
+        const sameNetTraces = this.allSolvedTraces.filter(
+          (trace) => trace.globalConnNetId === globalConnNetId
+        );
+        const inputNetConnection = this.inputProblem.netConnections.find(
+          (connection) => connection.pinIds.length === 3 && connection.pinIds.includes(p1.pinId) && connection.pinIds.includes(p2.pinId)
+        );
+        const sourceChip = this.chipMap[p1.chipId];
+        const targetRailTrace = sameNetTraces.find(
+          (trace) => trace.pinIds.includes(p2.pinId) && trace.pins.every((pin) => pin.chipId === p2.chipId)
+        );
+        const canJoinThreePinNet = inputNetConnection !== void 0 && sourceChip?.pins.length === 2 && targetRailTrace !== void 0;
+        const junctionTracePath = canJoinThreePinNet ? clipPathAtFirstIntersection(newTracePath, sameNetTraces) : null;
+        const acceptedTracePath = junctionTracePath ?? newTracePath;
+        const tracesToCheck = junctionTracePath ? this.allSolvedTraces.filter(
+          (trace) => trace.globalConnNetId !== globalConnNetId
+        ) : this.allSolvedTraces;
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
-          newTracePath,
-          this.allSolvedTraces
+          acceptedTracePath,
+          tracesToCheck
         );
         if (isTraceClear) {
-          const [p1, p2] = this.currentCandidatePair;
-          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
           const mspPairId = `${p1.pinId}-${p2.pinId}`;
           const newSolvedTrace = {
             mspPairId,
             dcConnNetId: globalConnNetId,
             globalConnNetId,
             pins: [p1, p2],
-            tracePath: newTracePath,
+            tracePath: acceptedTracePath,
             mspConnectionPairIds: [mspPairId],
             pinIds: [p1.pinId, p2.pinId]
           };
@@ -5525,9 +5616,9 @@ var moveRailSegments = (trace, segments, coordinate) => {
 };
 
 // lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
-var EPS6 = 1e-6;
+var EPS7 = 1e-6;
 var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS6 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS6;
+var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS7 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS7;
 var getTraceCorners = (path) => {
   const corners = [];
   for (let i = 1; i < path.length - 1; i++) {
@@ -5551,11 +5642,11 @@ var getUniquePinCount = (pinIds) => new Set(pinIds).size;
 var isTraceCorner = (a, b, c) => getSegmentOrientation(a, b) !== getSegmentOrientation(b, c);
 var isPointOnSegment = (point, start, end) => {
   if (getSegmentOrientation(start, end) === "horizontal") {
-    return Math.abs(point.y - start.y) <= EPS6 && point.x >= Math.min(start.x, end.x) - EPS6 && point.x <= Math.max(start.x, end.x) + EPS6;
+    return Math.abs(point.y - start.y) <= EPS7 && point.x >= Math.min(start.x, end.x) - EPS7 && point.x <= Math.max(start.x, end.x) + EPS7;
   }
-  return Math.abs(point.x - start.x) <= EPS6 && point.y >= Math.min(start.y, end.y) - EPS6 && point.y <= Math.max(start.y, end.y) + EPS6;
+  return Math.abs(point.x - start.x) <= EPS7 && point.y >= Math.min(start.y, end.y) - EPS7 && point.y <= Math.max(start.y, end.y) + EPS7;
 };
-var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS6 ? "horizontal" : "vertical";
+var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS7 ? "horizontal" : "vertical";
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors.ts
 var getAnchoredTraceIds = (label, traces) => new Set(
@@ -5571,17 +5662,17 @@ var preservesLabelAnchors = (labels, before, after) => labels.every((label) => {
 });
 
 // lib/solvers/Example28Solver/types.ts
-var EPS7 = 1e-9;
+var EPS8 = 1e-9;
 
 // lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS7;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS7;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS8;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS8;
   if (isVertical5) {
-    return Math.abs(start.x - rect.minX) < EPS7 || Math.abs(start.x - rect.maxX) < EPS7;
+    return Math.abs(start.x - rect.minX) < EPS8 || Math.abs(start.x - rect.maxX) < EPS8;
   }
   if (isHorizontal4) {
-    return Math.abs(start.y - rect.minY) < EPS7 || Math.abs(start.y - rect.maxY) < EPS7;
+    return Math.abs(start.y - rect.minY) < EPS8 || Math.abs(start.y - rect.maxY) < EPS8;
   }
   return false;
 };
@@ -5596,10 +5687,10 @@ var getPathLength2 = (path) => {
   return length;
 };
 var getDistance2 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS7 || Math.abs(start.y - end.y) < EPS7;
-var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS7 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS8 || Math.abs(start.y - end.y) < EPS8;
+var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS8 ? "horizontal" : "vertical";
 var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS7) {
+  if (Math.abs(start.x - end.x) < EPS8) {
     return {
       x: start.x,
       y: Math.min(
@@ -5608,7 +5699,7 @@ var projectPointToSegment = (point, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS7) {
+  if (Math.abs(start.y - end.y) < EPS8) {
     return {
       x: Math.min(
         Math.max(point.x, Math.min(start.x, end.x)),
@@ -5651,9 +5742,9 @@ var findSegmentContainingPoint = (path, point) => {
 };
 var isPointWithinSegmentPrimaryRange = (point, segment) => {
   if (segment.orientation === "horizontal") {
-    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS7 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS7;
+    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS8 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS8;
   }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS7 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS7;
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS8 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS8;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
   const matchingSegments = getSegments(path).filter(
@@ -5681,24 +5772,24 @@ var projectPointToPath = (point, path) => {
   return bestPoint;
 };
 var segmentsIntersect = (a1, a2, b1, b2) => {
-  const aVertical = Math.abs(a1.x - a2.x) < EPS7;
-  const bVertical = Math.abs(b1.x - b2.x) < EPS7;
-  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS7 && value <= Math.max(p1, p2) + EPS7;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS8;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS8;
+  const between2 = (value, p1, p2) => value >= Math.min(p1, p2) - EPS8 && value <= Math.max(p1, p2) + EPS8;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS7) return false;
+    if (Math.abs(a1.x - b1.x) > EPS8) return false;
     const overlap = Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) - Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y));
-    return overlap > EPS7;
+    return overlap > EPS8;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS7) return false;
+    if (Math.abs(a1.y - b1.y) > EPS8) return false;
     const overlap = Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) - Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x));
-    return overlap > EPS7;
+    return overlap > EPS8;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
   const horizontalA = aVertical ? b1 : a1;
   const horizontalB = aVertical ? b2 : a2;
-  return between(verticalA.x, horizontalA.x, horizontalB.x) && between(horizontalA.y, verticalA.y, verticalB.y);
+  return between2(verticalA.x, horizontalA.x, horizontalB.x) && between2(horizontalA.y, verticalA.y, verticalB.y);
 };
 var countPathIntersections = (pathA, pathB) => {
   let count = 0;
@@ -6068,7 +6159,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 
 // lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
-var EPS8 = 1e-6;
+var EPS9 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections = [];
   for (const obstacle of obstacles) {
@@ -6087,17 +6178,17 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections;
 };
-var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS8 && Math.abs(first.y - second.y) < EPS8;
+var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS9 && Math.abs(first.y - second.y) < EPS9;
 var findPerpendicularPathCrossings = (path, otherPath) => {
   const crossings = [];
   for (let pathSegmentIndex = 1; pathSegmentIndex < path.length - 2; pathSegmentIndex++) {
     const start = path[pathSegmentIndex];
     const end = path[pathSegmentIndex + 1];
-    const isVertical5 = Math.abs(start.x - end.x) < EPS8;
+    const isVertical5 = Math.abs(start.x - end.x) < EPS9;
     for (let otherPathSegmentIndex = 1; otherPathSegmentIndex < otherPath.length - 2; otherPathSegmentIndex++) {
       const otherStart = otherPath[otherPathSegmentIndex];
       const otherEnd = otherPath[otherPathSegmentIndex + 1];
-      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS8;
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS9;
       if (isVertical5 === otherIsVertical) continue;
       const intersection = getSegmentIntersection(
         start,
@@ -6117,8 +6208,8 @@ var findPerpendicularPathCrossings = (path, otherPath) => {
 };
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS9 = 1e-6;
-var isVertical3 = (a, b, eps = EPS9) => Math.abs(a.x - b.x) < eps;
+var EPS10 = 1e-6;
+var isVertical3 = (a, b, eps = EPS10) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -6131,7 +6222,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS9 && Math.abs(p2.y - (y + height)) < EPS9) {
+  if (Math.abs(p2.x - x) < EPS10 && Math.abs(p2.y - (y + height)) < EPS10) {
     c2 = { x: x + width + padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -6143,7 +6234,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS9 && Math.abs(p2.y - (y + height)) < EPS9) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS10 && Math.abs(p2.y - (y + height)) < EPS10) {
     c2 = { x: x - padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -6155,7 +6246,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS9 && Math.abs(p2.y - y) < EPS9) {
+  } else if (Math.abs(p2.x - x) < EPS10 && Math.abs(p2.y - y) < EPS10) {
     c2 = { x: x + width + padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -6167,7 +6258,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS9 && Math.abs(p2.y - y) < EPS9) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS10 && Math.abs(p2.y - y) < EPS10) {
     c2 = { x: x - padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -6195,7 +6286,7 @@ var generatePerpendicularTraceDetours = ({
   const buildDetours = (path, index) => {
     const start = path[index];
     const end = path[index + 1];
-    const movingAxis = Math.abs(start.x - end.x) < EPS9 ? "y" : "x";
+    const movingAxis = Math.abs(start.x - end.x) < EPS10 ? "y" : "x";
     const detourAxis = movingAxis === "x" ? "y" : "x";
     const gate = obstacleStart[movingAxis] + Math.sign(start[movingAxis] - obstacleStart[movingAxis]) * clearance;
     const obstacleRange = [obstacleStart[detourAxis], obstacleEnd[detourAxis]];
@@ -6793,9 +6884,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS10 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS10;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS10;
+var EPS11 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS11;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS11;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -7070,7 +7161,7 @@ var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
     const end = path[i + 1];
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
-      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS7) {
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS8) {
         return true;
       }
     }
@@ -7085,13 +7176,13 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
       const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
-      if (overlap > EPS7) total += overlap;
+      if (overlap > EPS8) total += overlap;
     }
   }
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS7;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS8;
   if (isVertical5) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
@@ -7855,16 +7946,16 @@ var createPortOnlyLabelConnectorTrace = ({
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS11 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS11;
+var EPS12 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS12;
 var CANDIDATE_SELECTED_COLOR2 = "blue";
 var CANDIDATE_REJECTED_COLOR2 = "red";
 
 // lib/solvers/AvailableNetOrientationSolver/geometry.ts
 var isYOrientation = (orientation) => orientation === "y+" || orientation === "y-";
 var isXOrientation = (orientation) => orientation === "x+" || orientation === "x-";
-var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS11 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS11;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS11;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS12;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS12;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -7887,7 +7978,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS11 || p1.x >= interiorBounds.maxX - EPS11) {
+    if (p1.x <= interiorBounds.minX + EPS12 || p1.x >= interiorBounds.maxX - EPS12) {
       return false;
     }
     return rangesOverlap(
@@ -7898,7 +7989,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS11 || p1.y >= interiorBounds.maxY - EPS11) {
+    if (p1.y <= interiorBounds.minY + EPS12 || p1.y >= interiorBounds.maxY - EPS12) {
       return false;
     }
     return rangesOverlap(
@@ -7954,8 +8045,8 @@ var simplifyOrthogonalPath = (path) => {
   return simplified;
 };
 var pointsEqual2 = (a, b) => sameX2(a, b) && sameY2(a, b);
-var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS11;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS11;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS12;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS12;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -8411,7 +8502,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       index,
       pin: this.pinMap[otherLabel.pinIds[0]]
     })).filter(
-      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS11
+      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS12
     ).sort((a, b) => a.pin.x - b.pin.x)[0]?.pin;
     if (orientation === "y-" && nextPinToRight) return null;
     const anchorX = orientation === "y-" ? Math.max(
@@ -8444,7 +8535,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const centeredAnchorY = hasUpFacingStack ? (lowestUpFacingLabelY + highestUpFacingLabelY) / 2 : stackedAnchorY;
     const anchorYs = orientation === "y-" ? [centeredAnchorY, stackedAnchorY] : [stackedAnchorY];
     for (const anchorY of anchorYs) {
-      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS11) {
+      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS12) {
         continue;
       }
       const candidate = this.createCandidate(
@@ -8473,11 +8564,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (trace.globalConnNetId !== label.globalConnNetId) return false;
       const path = trace.tracePath;
       return path.some((point, pointIndex) => {
-        if (Math.abs(point.x - label.anchorPoint.x) > EPS11 || Math.abs(point.y - label.anchorPoint.y) > EPS11) {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS12 || Math.abs(point.y - label.anchorPoint.y) > EPS12) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS11 && (neighbor.y - point.y) * direction.y > EPS11
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS12 && (neighbor.y - point.y) * direction.y > EPS12
         );
       });
     });
@@ -8567,7 +8658,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         orientation
       );
       if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
-      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
+      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS12; distance5 += LABEL_SEARCH_STEP) {
         const anchorPoint = {
           x: connectorSource.x + outwardDirection.x * distance5,
           y: connectorSource.y + outwardDirection.y * distance5
@@ -8622,7 +8713,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     );
     const maxSearchDistance = this.getSearchDistanceLimit(label, orientation);
     const maxOutwardDistance = outwardDirection.x === 0 && outwardDirection.y === 0 ? 0 : this.maxSearchDistance;
-    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS11; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS12; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -8696,7 +8787,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
+    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS12; distance5 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance5,
         y: baseAnchor.y + direction.y * distance5
@@ -9002,9 +9093,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS11 || anchorPoint.x > chipBounds.maxX + EPS11;
+        return anchorPoint.x < chipBounds.minX - EPS12 || anchorPoint.x > chipBounds.maxX + EPS12;
       }
-      return anchorPoint.y < chipBounds.minY - EPS11 || anchorPoint.y > chipBounds.maxY + EPS11;
+      return anchorPoint.y < chipBounds.minY - EPS12 || anchorPoint.y > chipBounds.maxY + EPS12;
     });
   }
   getBoundsStatus(candidateBoundsCheck) {
@@ -9105,8 +9196,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (!chip) return null;
     const sides = new Set(
       pins.map((pin) => {
-        if (Math.abs(pin.x - chip.bounds.minX) <= EPS11) return "left";
-        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS11) return "right";
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS12) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS12) return "right";
         return null;
       })
     );
@@ -9139,8 +9230,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   sharesChipBoundary(bounds) {
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const chipBounds = chip.bounds;
-      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS11 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS11;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS11 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS11;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS12 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS12;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS12 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS12;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -9202,7 +9293,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      if (point.x < bounds.minX - EPS11 || point.x > bounds.maxX + EPS11 || point.y < bounds.minY - EPS11 || point.y > bounds.maxY + EPS11) {
+      if (point.x < bounds.minX - EPS12 || point.x > bounds.maxX + EPS12 || point.y < bounds.minY - EPS12 || point.y > bounds.maxY + EPS12) {
         continue;
       }
       for (const [side, distance5] of getSideDistances(point, bounds)) {
@@ -9219,8 +9310,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistanceSq = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      const dx = point.x < bounds.minX - EPS11 ? bounds.minX - point.x : point.x > bounds.maxX + EPS11 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS11 ? bounds.minY - point.y : point.y > bounds.maxY + EPS11 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS12 ? bounds.minX - point.x : point.x > bounds.maxX + EPS12 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS12 ? bounds.minY - point.y : point.y > bounds.maxY + EPS12 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -9536,7 +9627,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       for (const anchorPoint of getTraceCorners(path)) {
         const cornerIndex = path.indexOf(anchorPoint);
         const anchorAlignedToPin = pins.some(
-          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS6
+          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS7
         );
         const pinAligned = anchorAlignedToPin || allowRailAlignedFallback && this.isPinAlignedCorner(path, cornerIndex);
         if (!pinAligned) continue;
@@ -9576,12 +9667,12 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     return traceCrossesBoundsInterior(bounds, otherNetTraceMap);
   }
   pointsEqual(a, b) {
-    return Math.abs(a.x - b.x) <= EPS6 && Math.abs(a.y - b.y) <= EPS6;
+    return Math.abs(a.x - b.x) <= EPS7 && Math.abs(a.y - b.y) <= EPS7;
   }
   getVerticalSegmentPointIndices(path, cornerIndex) {
     const corner = path[cornerIndex];
-    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS6;
-    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS6;
+    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS7;
+    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS7;
     if (previousIsVertical === nextIsVertical) return null;
     const indices = previousIsVertical ? [cornerIndex - 1, cornerIndex] : [cornerIndex, cornerIndex + 1];
     return indices;
@@ -9631,7 +9722,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
         const end = otherTrace.tracePath[i + 1];
         if (!segmentCrossesBoundsInterior(start, end, labelBounds)) continue;
         const halfLabelWidth = label.width / 2;
-        if (Math.abs(start.x - end.x) <= EPS6) {
+        if (Math.abs(start.x - end.x) <= EPS7) {
           shiftedCoordinates.add(
             start.x - halfLabelWidth - LABEL_TRACE_CLEARANCE3
           );
@@ -9649,7 +9740,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       }
     }
     return [...shiftedCoordinates].flatMap((x) => {
-      if (Math.abs(x - corner.x) <= EPS6) return [];
+      if (Math.abs(x - corner.x) <= EPS7) return [];
       const reroutedTracePath = simplifyPath(
         path.map(
           (point, pointIndex) => verticalPointIndices.includes(pointIndex) ? { ...point, x } : point
@@ -9780,11 +9871,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS12 = 1e-6;
+var EPS13 = 1e-6;
 var TRACE_BOUNDARY_TOLERANCE2 = 1e-6;
 var getLabelBounds = (label) => getRectBounds(label.center, label.width, label.height);
-var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS12;
-var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS12;
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS13 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS13;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS13 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS13;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -9830,7 +9921,7 @@ var getPointAtTraceDistance = (trace, distance5) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance5 <= nextDistance + EPS12) {
+    if (distance5 <= nextDistance + EPS13) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance5 - pathDistance)
@@ -9869,7 +9960,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS12 || start.x >= interior.maxX - EPS12) {
+    if (start.x <= interior.minX + EPS13 || start.x >= interior.maxX - EPS13) {
       return false;
     }
     return rangesOverlap2(
@@ -9880,7 +9971,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS12 || start.y >= interior.maxY - EPS12) {
+    if (start.y <= interior.minY + EPS13 || start.y >= interior.maxY - EPS13) {
       return false;
     }
     return rangesOverlap2(
@@ -9894,10 +9985,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS12 && point.x >= Math.min(start.x, end.x) - EPS12 && point.x <= Math.max(start.x, end.x) + EPS12;
+    return Math.abs(point.y - start.y) <= EPS13 && point.x >= Math.min(start.x, end.x) - EPS13 && point.x <= Math.max(start.x, end.x) + EPS13;
   }
   if (isVertical4(start, end)) {
-    return Math.abs(point.x - start.x) <= EPS12 && point.y >= Math.min(start.y, end.y) - EPS12 && point.y <= Math.max(start.y, end.y) + EPS12;
+    return Math.abs(point.x - start.x) <= EPS13 && point.y >= Math.min(start.y, end.y) - EPS13 && point.y <= Math.max(start.y, end.y) + EPS13;
   }
   return false;
 };
@@ -9905,9 +9996,9 @@ var getSegmentDirection = (start, end) => ({
   x: isVertical4(start, end) ? 0 : Math.sign(end.x - start.x),
   y: isHorizontal3(start, end) ? 0 : Math.sign(end.y - start.y)
 });
-var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS12;
-var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS12;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS12;
+var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS13;
+var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS13;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS13;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -9964,7 +10055,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance5 of vertexDistances) {
     distances.add(roundDistance(distance5));
   }
-  return [...distances].filter((distance5) => distance5 >= -EPS12 && distance5 <= traceLength + EPS12).sort((a, b) => a - b);
+  return [...distances].filter((distance5) => distance5 >= -EPS13 && distance5 <= traceLength + EPS13).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -10053,13 +10144,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS12) {
+  if (value > max + EPS13) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS12) {
+  if (value < min - EPS13) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -10070,7 +10161,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS12, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS13, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -10143,7 +10234,7 @@ var getNetLabelHeight = (inputProblem, label) => {
   )?.netLabelHeight;
 };
 var roundDistance = (distance5) => Number(distance5.toFixed(6));
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS12 && Math.abs(point.y - label.anchorPoint.y) <= EPS12 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS13 && Math.abs(point.y - label.anchorPoint.y) <= EPS13 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -1,4 +1,5 @@
 import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import type { Point } from "@tscircuit/math-utils"
 import {
   DEFAULT_MAX_MSP_PAIR_DISTANCE,
   type MspConnectionPair,
@@ -20,13 +21,118 @@ import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabe
 
 const NEAREST_NEIGHBOR_COUNT = 3
 
-const distance = (p1: InputPin, p2: InputPin) => {
+const distance = (p1: Point, p2: Point) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2))
 }
 
 const manhattanDistance = (p1: InputPin, p2: InputPin) =>
   Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
 
+const EPS = 1e-9
+
+const between = (value: number, first: number, second: number) =>
+  value >= Math.min(first, second) - EPS &&
+  value <= Math.max(first, second) + EPS
+
+const getAxisAlignedIntersection = (
+  firstStart: Point,
+  firstEnd: Point,
+  secondStart: Point,
+  secondEnd: Point,
+) => {
+  const firstIsHorizontal = Math.abs(firstStart.y - firstEnd.y) <= EPS
+  const firstIsVertical = Math.abs(firstStart.x - firstEnd.x) <= EPS
+  const secondIsHorizontal = Math.abs(secondStart.y - secondEnd.y) <= EPS
+  const secondIsVertical = Math.abs(secondStart.x - secondEnd.x) <= EPS
+
+  if (firstIsHorizontal && secondIsVertical) {
+    const point = { x: secondStart.x, y: firstStart.y }
+    return between(point.x, firstStart.x, firstEnd.x) &&
+      between(point.y, secondStart.y, secondEnd.y)
+      ? point
+      : null
+  }
+  if (firstIsVertical && secondIsHorizontal) {
+    const point = { x: firstStart.x, y: secondStart.y }
+    return between(point.y, firstStart.y, firstEnd.y) &&
+      between(point.x, secondStart.x, secondEnd.x)
+      ? point
+      : null
+  }
+  if (
+    firstIsHorizontal &&
+    secondIsHorizontal &&
+    Math.abs(firstStart.y - secondStart.y) <= EPS
+  ) {
+    const overlapMin = Math.max(
+      Math.min(firstStart.x, firstEnd.x),
+      Math.min(secondStart.x, secondEnd.x),
+    )
+    const overlapMax = Math.min(
+      Math.max(firstStart.x, firstEnd.x),
+      Math.max(secondStart.x, secondEnd.x),
+    )
+    if (overlapMin > overlapMax + EPS) return null
+    return {
+      x: Math.max(overlapMin, Math.min(firstStart.x, overlapMax)),
+      y: firstStart.y,
+    }
+  }
+  if (
+    firstIsVertical &&
+    secondIsVertical &&
+    Math.abs(firstStart.x - secondStart.x) <= EPS
+  ) {
+    const overlapMin = Math.max(
+      Math.min(firstStart.y, firstEnd.y),
+      Math.min(secondStart.y, secondEnd.y),
+    )
+    const overlapMax = Math.min(
+      Math.max(firstStart.y, firstEnd.y),
+      Math.max(secondStart.y, secondEnd.y),
+    )
+    if (overlapMin > overlapMax + EPS) return null
+    return {
+      x: firstStart.x,
+      y: Math.max(overlapMin, Math.min(firstStart.y, overlapMax)),
+    }
+  }
+  return null
+}
+
+const clipPathAtFirstIntersection = (
+  tracePath: SolvedTracePath["tracePath"],
+  existingTraces: SolvedTracePath[],
+) => {
+  for (let pathIndex = 0; pathIndex < tracePath.length - 1; pathIndex++) {
+    const pathStart = tracePath[pathIndex]!
+    const pathEnd = tracePath[pathIndex + 1]!
+    const intersections = existingTraces.flatMap((trace) =>
+      trace.tracePath.slice(0, -1).flatMap((traceStart, traceIndex) => {
+        const intersection = getAxisAlignedIntersection(
+          pathStart,
+          pathEnd,
+          traceStart,
+          trace.tracePath[traceIndex + 1]!,
+        )
+        return intersection ? [intersection] : []
+      }),
+    )
+    intersections.sort(
+      (first, second) =>
+        distance(pathStart, first) - distance(pathStart, second),
+    )
+    const intersection = intersections[0]
+    if (!intersection) continue
+    const clippedPath = tracePath.slice(0, pathIndex + 1)
+    if (distance(clippedPath.at(-1)!, intersection) > EPS) {
+      clippedPath.push(intersection)
+    }
+    return clippedPath
+  }
+  return null
+}
+
 export class LongDistancePairSolver extends BaseSolver {
   public solvedLongDistanceTraces: SolvedTracePath[] = []
   private queuedCandidatePairs: Array<
@@ -196,14 +302,42 @@ export class LongDistancePairSolver extends BaseSolver {
     } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath
       if (newTracePath && this.currentCandidatePair) {
+        const [p1, p2] = this.currentCandidatePair
+        const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId)!
+        const sameNetTraces = this.allSolvedTraces.filter(
+          (trace) => trace.globalConnNetId === globalConnNetId,
+        )
+        const inputNetConnection = this.inputProblem.netConnections.find(
+          (connection) =>
+            connection.pinIds.length === 3 &&
+            connection.pinIds.includes(p1.pinId) &&
+            connection.pinIds.includes(p2.pinId),
+        )
+        const sourceChip = this.chipMap[p1.chipId]
+        const targetRailTrace = sameNetTraces.find(
+          (trace) =>
+            trace.pinIds.includes(p2.pinId) &&
+            trace.pins.every((pin) => pin.chipId === p2.chipId),
+        )
+        const canJoinThreePinNet =
+          inputNetConnection !== undefined &&
+          sourceChip?.pins.length === 2 &&
+          targetRailTrace !== undefined
+        const junctionTracePath = canJoinThreePinNet
+          ? clipPathAtFirstIntersection(newTracePath, sameNetTraces)
+          : null
+        const acceptedTracePath = junctionTracePath ?? newTracePath
+        const tracesToCheck = junctionTracePath
+          ? this.allSolvedTraces.filter(
+              (trace) => trace.globalConnNetId !== globalConnNetId,
+            )
+          : this.allSolvedTraces
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
-          newTracePath,
-          this.allSolvedTraces,
+          acceptedTracePath,
+          tracesToCheck,
         )
 
         if (isTraceClear) {
-          const [p1, p2] = this.currentCandidatePair
-          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId)!
           const mspPairId = `${p1.pinId}-${p2.pinId}`
 
           const newSolvedTrace: SolvedTracePath = {
@@ -211,7 +345,7 @@ export class LongDistancePairSolver extends BaseSolver {
             dcConnNetId: globalConnNetId,
             globalConnNetId,
             pins: [p1, p2],
-            tracePath: newTracePath,
+            tracePath: acceptedTracePath,
             mspConnectionPairIds: [mspPairId],
             pinIds: [p1.pinId, p2.pinId],
           }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.133",
+  "version": "0.0.134",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/repros/__snapshots__/repro-type-c-vbus-led-ground-label.snap.svg

@@ -0,0 +1,66 @@
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><polyline data-points="0.4,1.5 2.5,1.5" data-type="line" data-label="" points="339.77220956719816,237.08428246013665 473.71298405466973,237.08428246013665" fill="none" stroke="hsl(238, 100%, 50%, 0.8)" stroke-width="1px"/></g><g><polyline data-points="-1.7,1.65 -1.7,1.3499999999999999" data-type="line" data-label="" points="205.83143507972665,227.51708428246013 205.83143507972665,246.65148063781322" fill="none" stroke="hsl(170, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="-1.7,1.65 -0.4,1.5" data-type="line" data-label="" points="205.83143507972665,227.51708428246013 288.74715261959,237.08428246013665" fill="none" stroke="hsl(170, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="-1.7,1.3499999999999999 -0.4,1.5" data-type="line" data-label="" points="205.83143507972665,246.65148063781322 288.74715261959,237.08428246013665" fill="none" stroke="hsl(170, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="-1.7,-1.35 -1.7,-1.65" data-type="line" data-label="" points="205.83143507972665,418.8610478359909 205.83143507972665,437.99544419134395" fill="none" stroke="hsl(124, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="-1.7,-1.35 3.5,1.5" data-type="line" data-label="" points="205.83143507972665,418.8610478359909 537.49430523918,237.08428246013665" fill="none" stroke="hsl(124, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="-1.7,-1.65 3.5,1.5" data-type="line" data-label="" points="205.83143507972665,437.99544419134395 537.49430523918,237.08428246013665" fill="none" stroke="hsl(124, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="0.4,1.5 2.5,1.5" data-type="line" data-label="" points="339.77220956719816,237.08428246013665 473.71298405466973,237.08428246013665" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="-1.7,1.3499999999999999 -1.5,1.3499999999999999 -1.5,1.65 -1.7,1.65" data-type="line" data-label="" points="205.83143507972665,246.65148063781322 218.5876993166287,246.65148063781322 218.5876993166287,227.51708428246013 205.83143507972665,227.51708428246013" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="-1.7,-1.65 -1.5,-1.65 -1.5,-1.35 -1.7,-1.35" data-type="line" data-label="" points="205.83143507972665,437.99544419134395 218.5876993166287,437.99544419134395 218.5876993166287,418.8610478359909 205.83143507972665,418.8610478359909" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="3.5,1.5 3.7,1.5 3.7,-1.35 -1.5,-1.35" data-type="line" data-label="" points="537.49430523918,237.08428246013665 550.2505694760821,237.08428246013665 550.2505694760821,418.8610478359909 218.5876993166287,418.8610478359909" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="-0.4,1.5 -1.5,1.5" data-type="line" data-label="" points="288.74715261959,237.08428246013665 218.5876993166287,237.08428246013665" fill="none" stroke="purple" stroke-width="1px"/></g><g><rect data-type="rect" data-label="J1" data-x="-3" data-y="0" x="40" y="205.19362186788152" width="165.83143507972665" height="255.12528473804105" fill="hsl(183, 100%, 50%, 0.8)" stroke="black" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="R1" data-x="0" data-y="1.5" x="288.74715261959" y="221.13895216400908" width="51.025056947608164" height="31.89066059225513" fill="hsl(71, 100%, 50%, 0.8)" stroke="black" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="D1" data-x="3" data-y="1.5" x="473.71298405466973" y="211.57175398633254" width="63.78132118451026" height="51.02505694760822" fill="hsl(357, 100%, 50%, 0.8)" stroke="black" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="J1 TYPE-C-31-M-12" data-x="-3" data-y="2.3" x="71.89066059225513" y="179.68109339407744" width="102.05011389521638" height="12.75626423690207" fill="rgba(160, 0, 220, 0.14)" stroke="black" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="R1 1kΩ" data-x="0" data-y="1.95" x="301.50341685649204" y="202.004555808656" width="25.512528473804082" height="12.75626423690207" fill="rgba(160, 0, 220, 0.14)" stroke="black" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="D1 white" data-x="3" data-y="2.15" x="489.6583143507973" y="189.24829157175398" width="31.89066059225513" height="12.756264236902041" fill="rgba(160, 0, 220, 0.14)" stroke="black" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="netId: VBUS
+globalConnNetId: connectivity_net1" data-x="-0.95" data-y="1.74" x="238.3599088838269" y="206.46924829157177" width="30.615034168564904" height="30.615034168564904" fill="#ef444466" stroke="#ef4444" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="netId: J1_GND1
+globalConnNetId: connectivity_net2" data-x="4.09" data-y="1.5" x="550.2505694760821" y="221.7767653758542" width="49.74943052391802" height="30.615034168564904" fill="#00000066" stroke="#000000" stroke-width="0.015678571428571427"/></g><g><rect data-type="rect" data-label="netId: VBUS_LED
+globalConnNetId: connectivity_net0" data-x="1.45" data-y="1.725" x="400.3644646924829" y="208.38268792710704" width="12.756264236902098" height="28.701594533029606" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.015678571428571427"/></g><g><circle data-type="point" data-label="J1.VBUS1
+x+" data-x="-1.7" data-y="1.65" cx="205.83143507972665" cy="227.51708428246013" r="3" fill="hsl(208, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.VBUS2
+x+" data-x="-1.7" data-y="1.3499999999999999" cx="205.83143507972665" cy="246.65148063781322" r="3" fill="hsl(209, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.CC1
+x+" data-x="-1.7" data-y="1.0499999999999998" cx="205.83143507972665" cy="265.7858769931663" r="3" fill="hsl(322, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.CC2
+x+" data-x="-1.7" data-y="0.75" cx="205.83143507972665" cy="284.92027334851934" r="3" fill="hsl(323, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.DP1
+x+" data-x="-1.7" data-y="0.44999999999999996" cx="205.83143507972665" cy="304.05466970387243" r="3" fill="hsl(246, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.DP2
+x+" data-x="-1.7" data-y="0.1499999999999999" cx="205.83143507972665" cy="323.1890660592255" r="3" fill="hsl(247, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.DM1
+x+" data-x="-1.7" data-y="-0.1499999999999999" cx="205.83143507972665" cy="342.32346241457856" r="3" fill="hsl(153, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.DM2
+x+" data-x="-1.7" data-y="-0.4500000000000002" cx="205.83143507972665" cy="361.45785876993165" r="3" fill="hsl(154, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.SBU1
+x+" data-x="-1.7" data-y="-0.75" cx="205.83143507972665" cy="380.59225512528474" r="3" fill="hsl(122, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.SBU2
+x+" data-x="-1.7" data-y="-1.0499999999999998" cx="205.83143507972665" cy="399.72665148063777" r="3" fill="hsl(123, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.GND1
+x+" data-x="-1.7" data-y="-1.35" cx="205.83143507972665" cy="418.8610478359909" r="3" fill="hsl(315, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="J1.GND2
+x+" data-x="-1.7" data-y="-1.65" cx="205.83143507972665" cy="437.99544419134395" r="3" fill="hsl(316, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="R1.1
+x-" data-x="-0.4" data-y="1.5" cx="288.74715261959" cy="237.08428246013665" r="3" fill="hsl(226, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="R1.2
+x+" data-x="0.4" data-y="1.5" cx="339.77220956719816" cy="237.08428246013665" r="3" fill="hsl(227, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="D1.1
+x-" data-x="2.5" data-y="1.5" cx="473.71298405466973" cy="237.08428246013665" r="3" fill="hsl(32, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="D1.2
+x+" data-x="3.5" data-y="1.5" cx="537.49430523918" cy="237.08428246013665" r="3" fill="hsl(33, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="anchorPoint
+orientation: y+" data-x="-0.95" data-y="1.5" cx="253.66742596810934" cy="237.08428246013665" r="3" fill="hsl(40, 100%, 50%, 0.9)"/></g><g><circle data-type="point" data-label="anchorPoint
+orientation: x+" data-x="3.7" data-y="1.5" cx="550.2505694760821" cy="237.08428246013665" r="3" fill="hsl(40, 100%, 50%, 0.9)"/></g><g><circle data-type="point" data-label="anchorPoint
+orientation: y+" data-x="1.45" data-y="1.5" cx="406.74259681093395" cy="237.08428246013665" r="3" fill="hsl(40, 100%, 50%, 0.9)"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
+              document.currentScript.parentElement.addEventListener('mousemove', (e) => {
+                const svg = e.currentTarget;
+                const rect = svg.getBoundingClientRect();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                const crosshair = svg.getElementById('crosshair');
+                const h = svg.getElementById('crosshair-h');
+                const v = svg.getElementById('crosshair-v');
+                const coords = svg.getElementById('coordinates');
+                
+                crosshair.style.display = 'block';
+                h.setAttribute('x1', '0');
+                h.setAttribute('x2', '640');
+                h.setAttribute('y1', y);
+                h.setAttribute('y2', y);
+                v.setAttribute('x1', x);
+                v.setAttribute('x2', x);
+                v.setAttribute('y1', '0');
+                v.setAttribute('y2', '640');
+
+                // Calculate real coordinates using inverse transformation
+                const matrix = {"a":63.781321184510254,"c":0,"e":314.2596810933941,"b":0,"d":-63.781321184510254,"f":332.75626423690204};
+                // Manually invert and apply the affine transform
+                // Since we only use translate and scale, we can directly compute:
+                // x' = (x - tx) / sx
+                // y' = (y - ty) / sy
+                const sx = matrix.a;
+                const sy = matrix.d;
+                const tx = matrix.e; 
+                const ty = matrix.f;
+                const realPoint = {
+                  x: (x - tx) / sx,
+                  y: (y - ty) / sy // Flip y back since we used negative scale
+                }
+                
+                coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+                coords.setAttribute('x', (x + 5).toString());
+                coords.setAttribute('y', (y - 5).toString());
+              });
+              document.currentScript.parentElement.addEventListener('mouseleave', () => {
+                document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+              });
+            ]]></script></svg>

package/tests/repros/repro-type-c-vbus-led-ground-label.test.ts

@@ -0,0 +1,149 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+
+const connectorPins = [
+  "VBUS1",
+  "VBUS2",
+  "CC1",
+  "CC2",
+  "DP1",
+  "DP2",
+  "DM1",
+  "DM2",
+  "SBU1",
+  "SBU2",
+  "GND1",
+  "GND2",
+].map((name, index) => ({
+  pinId: `J1.${name}`,
+  x: -1.7,
+  y: 1.65 - index * 0.3,
+  _facingDirection: "x+" as const,
+}))
+
+// Reproduces a TYPE-C-31-M-12 connector with its two VBUS pins joined to a
+// resistor/LED chain while the LED cathode shares the connector's GND net.
+// The distant GND endpoints should be represented by separate net labels.
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "J1",
+      center: { x: -3, y: 0 },
+      width: 2.6,
+      height: 4,
+      pins: connectorPins,
+    },
+    {
+      chipId: "R1",
+      center: { x: 0, y: 1.5 },
+      width: 0.8,
+      height: 0.5,
+      pins: [
+        {
+          pinId: "R1.1",
+          x: -0.4,
+          y: 1.5,
+          _facingDirection: "x-",
+        },
+        {
+          pinId: "R1.2",
+          x: 0.4,
+          y: 1.5,
+          _facingDirection: "x+",
+        },
+      ],
+    },
+    {
+      chipId: "D1",
+      center: { x: 3, y: 1.5 },
+      width: 1,
+      height: 0.8,
+      pins: [
+        {
+          pinId: "D1.1",
+          x: 2.5,
+          y: 1.5,
+          _facingDirection: "x-",
+        },
+        {
+          pinId: "D1.2",
+          x: 3.5,
+          y: 1.5,
+          _facingDirection: "x+",
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      netId: "VBUS_LED",
+      pinIds: ["R1.2", "D1.1"],
+    },
+  ],
+  netConnections: [
+    {
+      netId: "VBUS",
+      pinIds: ["J1.VBUS1", "J1.VBUS2", "R1.1"],
+      netLabelWidth: 0.48,
+      netLabelHeight: 0.48,
+    },
+    {
+      netId: "J1_GND1",
+      pinIds: ["J1.GND1", "J1.GND2", "D1.2"],
+      netLabelWidth: 0.78,
+      netLabelHeight: 0.48,
+    },
+  ],
+  textBoxes: [
+    {
+      chipId: "J1",
+      center: { x: -3, y: 2.3 },
+      width: 1.6,
+      height: 0.2,
+      text: "J1 TYPE-C-31-M-12",
+    },
+    {
+      chipId: "R1",
+      center: { x: 0, y: 1.95 },
+      width: 0.4,
+      height: 0.2,
+      text: "R1 1kΩ",
+    },
+    {
+      chipId: "D1",
+      center: { x: 3, y: 2.15 },
+      width: 0.5,
+      height: 0.2,
+      text: "D1 white",
+    },
+  ],
+  availableNetLabelOrientations: {
+    VBUS: ["x+", "y+"],
+    J1_GND1: ["y-", "x+"],
+  },
+  maxMspPairDistance: 2.4,
+}
+
+test("routes TYPE-C-31-M-12 VBUS through an LED with shared GND labels", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  const output = solver.netLabelNetLabelCollisionSolver!.getOutput()
+  const gndLabels = output.netLabelPlacements.filter(
+    (label) => label.netId === "J1_GND1",
+  )
+
+  const recoveredGroundTrace =
+    solver.longDistancePairSolver!.solvedLongDistanceTraces.find(
+      (trace) =>
+        trace.pinIds.includes("D1.2") &&
+        trace.pinIds.some((pinId) => pinId.startsWith("J1.GND")),
+    )
+
+  expect(recoveredGroundTrace).toBeDefined()
+  expect(gndLabels).toHaveLength(1)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})