@tscircuit/schematic-trace-solver 0.0.190 → 0.0.192

package/dist/index.js

@@ -342,19 +342,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS18 = 1e-9;
+  const EPS19 = 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) < -EPS18) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS19) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS18) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS19) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS18 || Math.abs(p1.y - p2.y) < EPS18) {
+  if (Math.abs(p1.x - p2.x) < EPS19 || Math.abs(p1.y - p2.y) < EPS19) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -608,6 +608,126 @@ function shouldSeparateGroundNetRows({
   return isGroupedHorizontalRail({ pin: pin1, netPins }) && isGroupedHorizontalRail({ pin: pin2, netPins });
 }
 
+// lib/solvers/MspConnectionPairSolver/getParallelRailPairs.ts
+var EPS = 1e-6;
+var MAX_RAIL_SPACING_IN_TERMINAL_SPANS = 4;
+var MAX_RAIL_SPACING_MULTIPLIER = 2;
+var getRailPairKey = (first, second) => JSON.stringify([first, second].sort());
+var getParallelRailPairs = (inputProblem, netConnMap, maxMspPairDistance) => {
+  const groundNetIds = /* @__PURE__ */ new Set();
+  const namedPinIds = /* @__PURE__ */ new Set();
+  const wiredPinIds = /* @__PURE__ */ new Set();
+  for (const connection of inputProblem.netConnections) {
+    for (const pinId of connection.pinIds) namedPinIds.add(pinId);
+    const netId = netConnMap.getNetConnectedToId(connection.netId);
+    if (netId && connection.isGround) {
+      groundNetIds.add(netId);
+    }
+  }
+  for (const connection of inputProblem.directConnections) {
+    const pinIds = connection.netLabelWidth === void 0 ? wiredPinIds : namedPinIds;
+    for (const pinId of connection.pinIds) pinIds.add(pinId);
+  }
+  const rows = [];
+  for (const chip of inputProblem.chips) {
+    if (chip.pins.length !== 2 || chip.symbolName && !chip.symbolName.startsWith("capacitor") || !chip.pins.every((pin) => namedPinIds.has(pin.pinId)) || chip.pins.some((pin) => wiredPinIds.has(pin.pinId)))
+      continue;
+    const nets = chip.pins.map(
+      (pin) => netConnMap.getNetConnectedToId(pin.pinId)
+    );
+    if (!nets[0] || !nets[1] || nets[0] === nets[1] || groundNetIds.has(nets[0]) === groundNetIds.has(nets[1]))
+      continue;
+    const directions = chip.pins.map(
+      (pin) => pin._facingDirection ?? getPinDirection(pin, chip)
+    );
+    if (directions[0][0] !== directions[1][0] || directions[0] === directions[1])
+      continue;
+    const axis = directions[0][0];
+    const along = axis === "x" ? "y" : "x";
+    if (Math.abs(chip.pins[0][along] - chip.pins[1][along]) > EPS) continue;
+    for (const [index, pin] of chip.pins.entries()) {
+      const direction = directions[index];
+      let row = rows.find(
+        (candidate) => candidate.sectionId === chip.sectionId && candidate.direction === direction && Math.abs(candidate.coordinate - pin[axis]) <= EPS
+      );
+      if (!row) {
+        row = {
+          sectionId: chip.sectionId,
+          direction,
+          coordinate: pin[axis],
+          axis,
+          pins: []
+        };
+        rows.push(row);
+      }
+      row.pins.push({
+        ...pin,
+        chipId: chip.chipId,
+        oppositeCoordinate: chip.pins[1 - index][axis]
+      });
+    }
+  }
+  const pairKeys = /* @__PURE__ */ new Set();
+  const extendedRailPinIds = /* @__PURE__ */ new Set();
+  const separatedRailPinIds = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const along = row.axis === "x" ? "y" : "x";
+    row.pins.sort(
+      (a, b) => a[along] - b[along] || a.pinId.localeCompare(b.pinId)
+    );
+    for (let index = 1; index < row.pins.length; index++) {
+      const first = row.pins[index - 1];
+      const second = row.pins[index];
+      const spacing = second[along] - first[along];
+      const neighboringSpacings = [
+        first[along] - (row.pins[index - 2]?.[along] ?? first[along]),
+        (row.pins[index + 1]?.[along] ?? second[along]) - second[along]
+      ].filter((gap) => gap > EPS);
+      const maxRailSpacing = Math.max(
+        MAX_RAIL_SPACING_MULTIPLIER * maxMspPairDistance,
+        MAX_RAIL_SPACING_MULTIPLIER * (neighboringSpacings.length ? Math.min(...neighboringSpacings) : 0),
+        MAX_RAIL_SPACING_IN_TERMINAL_SPANS * Math.max(
+          Math.abs(first[row.axis] - first.oppositeCoordinate),
+          Math.abs(second[row.axis] - second.oppositeCoordinate)
+        )
+      );
+      if (spacing <= EPS || netConnMap.getNetConnectedToId(first.pinId) !== netConnMap.getNetConnectedToId(second.pinId))
+        continue;
+      if (spacing > maxRailSpacing + EPS) {
+        separatedRailPinIds.add(first.pinId);
+        separatedRailPinIds.add(second.pinId);
+        continue;
+      }
+      const minAcross = Math.min(
+        first[row.axis],
+        second[row.axis],
+        first.oppositeCoordinate,
+        second.oppositeCoordinate
+      );
+      const maxAcross = Math.max(
+        first[row.axis],
+        second[row.axis],
+        first.oppositeCoordinate,
+        second.oppositeCoordinate
+      );
+      if (inputProblem.chips.some((chip) => {
+        if (chip.chipId === first.chipId || chip.chipId === second.chipId)
+          return false;
+        const acrossSize = row.axis === "x" ? chip.width : chip.height;
+        const alongSize = along === "x" ? chip.width : chip.height;
+        return chip.center[row.axis] + acrossSize / 2 >= minAcross - EPS && chip.center[row.axis] - acrossSize / 2 <= maxAcross + EPS && chip.center[along] + alongSize / 2 > first[along] + EPS && chip.center[along] - alongSize / 2 < second[along] - EPS;
+      }))
+        continue;
+      pairKeys.add(getRailPairKey(first.pinId, second.pinId));
+      if (spacing > maxMspPairDistance) {
+        extendedRailPinIds.add(first.pinId);
+        extendedRailPinIds.add(second.pinId);
+      }
+    }
+  }
+  return { pairKeys, extendedRailPinIds, separatedRailPinIds };
+};
+
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
 var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
@@ -624,6 +744,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
   userNetIdByPinId;
   directConnectionPinPairKeys;
   canRouteGroundPair;
+  parallelRailPairKeys;
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
@@ -632,6 +753,11 @@ var MspConnectionPairSolver = class extends BaseSolver {
     const { directConnMap, netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.dcConnMap = directConnMap;
     this.globalConnMap = netConnMap;
+    this.parallelRailPairKeys = getParallelRailPairs(
+      inputProblem,
+      netConnMap,
+      this.maxMspPairDistance
+    ).pairKeys;
     this.pinMap = {};
     for (const chip of inputProblem.chips) {
       for (const pin of chip.pins) {
@@ -695,7 +821,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
         chipMap: this.chipMap,
         pins: [p1, p2]
       });
-      if (pairDistance > this.maxMspPairDistance && !labeledConnectionRouteReason) {
+      if (pairDistance > this.maxMspPairDistance && !this.parallelRailPairKeys.has(getRailPairKey(pin1, pin2)) && !labeledConnectionRouteReason) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -733,8 +859,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
       (pinId) => this.pinMap[pinId]
     );
     const msp = getOrthogonalMinimumSpanningTree(directlyConnectedPinObjects, {
-      maxDistance: this.maxMspPairDistance,
-      forbidEdge: (a, b) => !this.canRouteGroundPair(a.pinId, b.pinId) || shouldSeparateGroundNetRows({
+      forbidEdge: (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y) > this.maxMspPairDistance && !this.parallelRailPairKeys.has(getRailPairKey(a.pinId, b.pinId)) || !this.canRouteGroundPair(a.pinId, b.pinId) || shouldSeparateGroundNetRows({
         netConnection,
         netPins: directlyConnectedPinObjects,
         pin1: a,
@@ -747,7 +872,11 @@ var MspConnectionPairSolver = class extends BaseSolver {
         p2: b
       })
     });
-    for (const [pin1, pin2] of msp) {
+    for (let [pin1, pin2] of msp) {
+      if (this.parallelRailPairKeys.has(getRailPairKey(pin1, pin2)) && Math.abs(this.pinMap[pin1].x - this.pinMap[pin2].x) + Math.abs(this.pinMap[pin1].y - this.pinMap[pin2].y) > this.maxMspPairDistance && directlyConnectedPins.indexOf(pin1) > directlyConnectedPins.indexOf(pin2)) {
+        ;
+        [pin1, pin2] = [pin2, pin1];
+      }
       const p1Obj = this.pinMap[pin1];
       const p2Obj = this.pinMap[pin2];
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1Obj, p2Obj)) {
@@ -971,10 +1100,10 @@ function calculateDirectShortPath(pin1, pin2) {
 }
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts
-var EPS = 1e-9;
-var isVertical = (a, b, eps = EPS) => Math.abs(a.x - b.x) < eps;
-var isHorizontal = (a, b, eps = EPS) => Math.abs(a.y - b.y) < eps;
-var segmentIntersectsRect = (a, b, r, eps = EPS) => {
+var EPS2 = 1e-9;
+var isVertical = (a, b, eps = EPS2) => Math.abs(a.x - b.x) < eps;
+var isHorizontal = (a, b, eps = EPS2) => Math.abs(a.y - b.y) < eps;
+var segmentIntersectsRect = (a, b, r, eps = EPS2) => {
   const vert = isVertical(a, b, eps);
   const horz = isHorizontal(a, b, eps);
   if (!vert && !horz) return false;
@@ -994,7 +1123,7 @@ var segmentIntersectsRect = (a, b, r, eps = EPS) => {
     return overlap > eps;
   }
 };
-var segmentOverlapsRectBoundary = (a, b, r, eps = EPS) => {
+var segmentOverlapsRectBoundary = (a, b, r, eps = EPS2) => {
   if (isVertical(a, b, eps)) {
     const onVerticalBoundary = Math.abs(a.x - r.minX) <= eps || Math.abs(a.x - r.maxX) <= eps;
     if (!onVerticalBoundary) return false;
@@ -1035,7 +1164,7 @@ var isPathCollidingWithObstacles = (path, obstacles) => {
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts
-var EPS2 = 1e-9;
+var EPS3 = 1e-9;
 var OBSTACLE_CLEARANCE = 0.2;
 var aabbFromPoints = (a, b) => ({
   minX: Math.min(a.x, b.x),
@@ -1043,7 +1172,7 @@ var aabbFromPoints = (a, b) => ({
   minY: Math.min(a.y, b.y),
   maxY: Math.max(a.y, b.y)
 });
-var midBetweenPointAndRect = (axis, p, r, eps = EPS2) => {
+var midBetweenPointAndRect = (axis, p, r, eps = EPS3) => {
   if (axis === "x") {
     if (p.x < r.minX - eps) {
       return [(p.x + r.minX) / 2];
@@ -1063,7 +1192,7 @@ var midBetweenPointAndRect = (axis, p, r, eps = EPS2) => {
   }
 };
 var candidateMidsFromSet = (axis, colliding, collisionRects, aabb, opts = {}) => {
-  const { allowOpenSideCandidates = false, eps = EPS2 } = opts;
+  const { allowOpenSideCandidates = false, eps = EPS3 } = opts;
   const setRects = [...collisionRects];
   if (axis === "x") {
     const leftBoundaries = [aabb.minX, ...setRects.map((r) => r.maxX)].filter(
@@ -1111,7 +1240,7 @@ var candidateMidsFromSet = (axis, colliding, collisionRects, aabb, opts = {}) =>
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
-var EPS3 = 1e-9;
+var EPS4 = 1e-9;
 var hasOnlyNonzeroOrthogonalSegments = (path) => path.every((point, index) => {
   const nextPoint = path[index + 1];
   if (!nextPoint) return true;
@@ -1120,7 +1249,7 @@ var hasOnlyNonzeroOrthogonalSegments = (path) => path.every((point, index) => {
   }
   return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0;
 });
-var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS3) => {
+var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS4) => {
   if (segIndex < 0 || segIndex >= pts.length - 1) {
     return null;
   }
@@ -1237,9 +1366,9 @@ var generateEndpointCollisionDetours = ({
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateInternalSegmentCollisionDetours.ts
-var EPS4 = 1e-9;
+var EPS5 = 1e-9;
 var DEFAULT_CLEARANCE = 0.2;
-var isStrictlyBetween = (value, a, b) => value > Math.min(a, b) + EPS4 && value < Math.max(a, b) - EPS4;
+var isStrictlyBetween = (value, a, b) => value > Math.min(a, b) + EPS5 && value < Math.max(a, b) - EPS5;
 var generateInternalSegmentCollisionDetours = ({
   path,
   collidingSegmentIndex,
@@ -1657,8 +1786,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS18 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS18 && Math.abs(p.y - q.y) < EPS18;
+      const EPS19 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS19 && Math.abs(p.y - q.y) < EPS19;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y }) && (!this.hasAmbiguousPinDirections || pathMatchesPinDirections({
         path,
         pin1: { ...PA, _facingDirection: directions[0] },
@@ -2013,13 +2142,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS18 = 1e-6
+  EPS: EPS19 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical6 = Math.abs(start.x - end.x) < EPS18;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS18;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS19;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS19;
   if (!isVertical6 && !isHorizontal5) return;
   const segDir = isVertical6 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2092,7 +2221,7 @@ var applyJogToTerminalSegment = ({
 };
 
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts
-var EPS5 = 1e-6;
+var EPS6 = 1e-6;
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
   interactionKind;
@@ -2189,7 +2318,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   }
   applyOffsets(offsets) {
     const correctedTraceMap = { ...this.correctedTraceMap };
-    const eq = (a, b) => Math.abs(a - b) < EPS5;
+    const eq = (a, b) => Math.abs(a - b) < EPS6;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, groupIndex) => {
       const offset = offsets[groupIndex];
@@ -2211,9 +2340,9 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           const start = pts[si];
           const end = pts[si + 1];
           if (!start || !end) continue;
-          if (Math.abs(start.x - end.x) < EPS5) {
+          if (Math.abs(start.x - end.x) < EPS6) {
             segmentAxes.set(si, "vertical");
-          } else if (Math.abs(start.y - end.y) < EPS5) {
+          } else if (Math.abs(start.y - end.y) < EPS6) {
             segmentAxes.set(si, "horizontal");
           }
         }
@@ -2228,7 +2357,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS5
+              EPS: EPS6
             });
           } else {
             const start = pts[si];
@@ -2315,7 +2444,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
         max = obstacle.maxY;
       }
       const next = orig + candidateOffset;
-      return orig <= min + EPS5 && next >= max - EPS5 || orig >= max - EPS5 && next <= min + EPS5;
+      return orig <= min + EPS6 && next >= max - EPS6 || orig >= max - EPS6 && next <= min + EPS6;
     });
     const edges = blockingCollisions.map(({ start, isVertical: isVertical6, obstacle }) => {
       if (isVertical6) {
@@ -2352,8 +2481,8 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       const start = trace.tracePath[traceSegmentIndex];
       const end = trace.tracePath[traceSegmentIndex + 1];
       if (!start || !end) continue;
-      const isVertical6 = Math.abs(start.x - end.x) < EPS5;
-      const isHorizontal5 = Math.abs(start.y - end.y) < EPS5;
+      const isVertical6 = Math.abs(start.x - end.x) < EPS6;
+      const isHorizontal5 = Math.abs(start.y - end.y) < EPS6;
       if (!isVertical6 && !isHorizontal5) continue;
       const shiftedSegment = isVertical6 ? [
         { ...start, x: start.x + offset },
@@ -2453,7 +2582,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS18 = 2e-3;
+    const EPS19 = 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++) {
@@ -2480,7 +2609,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS18) {
+          if (rangeOverlap > EPS19) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2499,7 +2628,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS18) return;
+          if (rangeOverlap < -EPS19) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2522,8 +2651,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) < EPS18;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS18;
+            const aVert = Math.abs(a1.x - a2.x) < EPS19;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS19;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2534,11 +2663,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) < EPS18;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS18;
+                const bVert = Math.abs(b1.x - b2.x) < EPS19;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS19;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS18) {
+                  if (Math.abs(a1.x - b1.x) < EPS19) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2548,7 +2677,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS18) {
+                  if (Math.abs(a1.y - b1.y) < EPS19) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2604,14 +2733,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS18 = 2e-3;
+    const EPS19 = 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 isHorizontal5 = Math.abs(p1.y - p2.y) < EPS18;
-        const isVertical6 = Math.abs(p1.x - p2.x) < EPS18;
+        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS19;
+        const isVertical6 = Math.abs(p1.x - p2.x) < EPS19;
         if (!isHorizontal5 && !isVertical6) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2625,13 +2754,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS18 = 2e-3;
+    const EPS19 = 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) < EPS18 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS18 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS18 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS18 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS19 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS19 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS19 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS19 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2793,24 +2922,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS18 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS18;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS18;
+function segmentIntersectsRect2(p1, p2, rect, EPS19 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS19;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS19;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS18 || x > rect.maxX + EPS18) return false;
+    if (x < rect.minX - EPS19 || x > rect.maxX + EPS19) 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 > EPS18;
+    return overlap > EPS19;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS18 || y > rect.maxY + EPS18) return false;
+    if (y < rect.minY - EPS19 || y > rect.maxY + EPS19) 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 > EPS18;
+    return overlap > EPS19;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -3209,14 +3338,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS18 = 1e-6;
+    const EPS19 = 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) < EPS18;
-        const isV = Math.abs(a.x - b.x) < EPS18;
+        const isH = Math.abs(a.y - b.y) < EPS19;
+        const isV = Math.abs(a.x - b.x) < EPS19;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4992,19 +5121,81 @@ function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
   return false;
 }
 
+// lib/solvers/LongDistancePairSolver/getParallelNetLabelPolicy.ts
+import { ConnectivityMap as ConnectivityMap3 } from "connectivity-map";
+var getParallelNetLabelPolicy = (inputProblem, netConnMap, connectedPinIds) => {
+  const maxDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
+  const { extendedRailPinIds, separatedRailPinIds } = getParallelRailPairs(
+    inputProblem,
+    netConnMap,
+    maxDistance
+  );
+  const groundNetIds = /* @__PURE__ */ new Set();
+  const namedPinIds = /* @__PURE__ */ new Set();
+  for (const connection of inputProblem.netConnections) {
+    const netId = netConnMap.getNetConnectedToId(connection.netId);
+    if (!netId) continue;
+    for (const pinId of connection.pinIds) namedPinIds.add(pinId);
+    if (connection.isGround) {
+      groundNetIds.add(netId);
+    }
+  }
+  const banks = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    if (chip.pins.length !== 2 || !chip.pins.every((pin) => namedPinIds.has(pin.pinId)) || chip.pins.some(
+      (pin) => connectedPinIds.has(pin.pinId) && !extendedRailPinIds.has(pin.pinId)
+    ))
+      continue;
+    const [first, second] = chip.pins.map(
+      (pin) => netConnMap.getNetConnectedToId(pin.pinId)
+    );
+    if (!first || !second || first === second || groundNetIds.has(first) === groundNetIds.has(second)) {
+      continue;
+    }
+    const key = JSON.stringify([
+      chip.sectionId ?? null,
+      ...[first, second].sort()
+    ]);
+    const bank = banks.get(key) ?? [];
+    bank.push(chip.pins.map((pin) => pin.pinId));
+    banks.set(key, bank);
+  }
+  const bankPinIds = new Set(
+    [...banks.values()].filter((bank) => bank.length > 1).flat(2)
+  );
+  for (const pinId of [...extendedRailPinIds, ...separatedRailPinIds]) {
+    bankPinIds.add(pinId);
+  }
+  const physicalConnMap = new ConnectivityMap3({});
+  for (const connection of inputProblem.directConnections) {
+    if (connection.netLabelWidth === void 0) {
+      physicalConnMap.addConnections([connection.pinIds]);
+    }
+  }
+  return (first, second) => {
+    if (!bankPinIds.has(first.pinId) && !bankPinIds.has(second.pinId))
+      return true;
+    if (Math.abs(first.x - second.x) + Math.abs(first.y - second.y) <= maxDistance) {
+      return true;
+    }
+    const physicalNetId = physicalConnMap.getNetConnectedToId(first.pinId);
+    return physicalNetId !== void 0 && physicalNetId === physicalConnMap.getNetConnectedToId(second.pinId);
+  };
+};
+
 // lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
 var NEAREST_NEIGHBOR_COUNT = 3;
 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 EPS7 = 1e-9;
+var between = (value, first, second) => value >= Math.min(first, second) - EPS7 && value <= Math.max(first, second) + EPS7;
 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;
+  const firstIsHorizontal = Math.abs(firstStart.y - firstEnd.y) <= EPS7;
+  const firstIsVertical = Math.abs(firstStart.x - firstEnd.x) <= EPS7;
+  const secondIsHorizontal = Math.abs(secondStart.y - secondEnd.y) <= EPS7;
+  const secondIsVertical = Math.abs(secondStart.x - secondEnd.x) <= EPS7;
   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;
@@ -5013,7 +5204,7 @@ var getAxisAlignedIntersection = (firstStart, firstEnd, secondStart, secondEnd)
     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) {
+  if (firstIsHorizontal && secondIsHorizontal && Math.abs(firstStart.y - secondStart.y) <= EPS7) {
     const overlapMin = Math.max(
       Math.min(firstStart.x, firstEnd.x),
       Math.min(secondStart.x, secondEnd.x)
@@ -5022,13 +5213,13 @@ var getAxisAlignedIntersection = (firstStart, firstEnd, secondStart, secondEnd)
       Math.max(firstStart.x, firstEnd.x),
       Math.max(secondStart.x, secondEnd.x)
     );
-    if (overlapMin > overlapMax + EPS6) return null;
+    if (overlapMin > overlapMax + EPS7) 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) {
+  if (firstIsVertical && secondIsVertical && Math.abs(firstStart.x - secondStart.x) <= EPS7) {
     const overlapMin = Math.max(
       Math.min(firstStart.y, firstEnd.y),
       Math.min(secondStart.y, secondEnd.y)
@@ -5037,7 +5228,7 @@ var getAxisAlignedIntersection = (firstStart, firstEnd, secondStart, secondEnd)
       Math.max(firstStart.y, firstEnd.y),
       Math.max(secondStart.y, secondEnd.y)
     );
-    if (overlapMin > overlapMax + EPS6) return null;
+    if (overlapMin > overlapMax + EPS7) return null;
     return {
       x: firstStart.x,
       y: Math.max(overlapMin, Math.min(firstStart.y, overlapMax))
@@ -5066,7 +5257,7 @@ var clipPathAtFirstIntersection = (tracePath, existingTraces) => {
     const intersection = intersections2[0];
     if (!intersection) continue;
     const clippedPath = tracePath.slice(0, pathIndex + 1);
-    if (distance3(clippedPath.at(-1), intersection) > EPS6) {
+    if (distance3(clippedPath.at(-1), intersection) > EPS7) {
       clippedPath.push(intersection);
     }
     return clippedPath;
@@ -5089,6 +5280,11 @@ var LongDistancePairSolver = class extends BaseSolver {
     }
     const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.netConnMap = netConnMap;
+    const canRecoverParallelPair = getParallelNetLabelPolicy(
+      inputProblem,
+      netConnMap,
+      primaryConnectedPinIds
+    );
     const pinMap = /* @__PURE__ */ new Map();
     for (const chip of inputProblem.chips) {
       this.chipMap[chip.chipId] = chip;
@@ -5121,6 +5317,7 @@ var LongDistancePairSolver = class extends BaseSolver {
           const targetPin = pinMap.get(otherPinId);
           if (!targetPin) return [];
           if (!canRouteGroundPair(sourcePin.pinId, targetPin.pinId)) return [];
+          if (!canRecoverParallelPair(sourcePin, targetPin)) return [];
           const isNamedTwoPinConnection = inputProblem.netConnections.some(
             (connection) => connection.pinIds.length === 2 && connection.pinIds.includes(sourcePin.pinId) && connection.pinIds.includes(targetPin.pinId)
           );
@@ -6065,9 +6262,9 @@ var getRailAlignmentFallbackCoordinates = ({
 import { distance as distance4 } from "@tscircuit/math-utils";
 
 // lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
-var EPS7 = 1e-6;
+var EPS8 = 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) > EPS7 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS7;
+var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
 var getTraceCorners = (path) => {
   const corners = [];
   for (let i = 1; i < path.length - 1; i++) {
@@ -6091,11 +6288,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) <= EPS7 && point.x >= Math.min(start.x, end.x) - EPS7 && point.x <= Math.max(start.x, end.x) + EPS7;
+    return Math.abs(point.y - start.y) <= EPS8 && point.x >= Math.min(start.x, end.x) - EPS8 && point.x <= Math.max(start.x, end.x) + EPS8;
   }
-  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;
+  return Math.abs(point.x - start.x) <= EPS8 && point.y >= Math.min(start.y, end.y) - EPS8 && point.y <= Math.max(start.y, end.y) + EPS8;
 };
-var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS7 ? "horizontal" : "vertical";
+var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS8 ? "horizontal" : "vertical";
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts
 var getTransitivelyConnectedTraceIds = (group, traces) => {
@@ -6220,17 +6417,17 @@ var preservesLabelAnchors = (labels, before, after) => labels.every((label) => {
 });
 
 // lib/solvers/Example28Solver/types.ts
-var EPS8 = 1e-9;
+var EPS9 = 1e-9;
 
 // lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical6 = Math.abs(start.x - end.x) < EPS8;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS8;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS9;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS9;
   if (isVertical6) {
-    return Math.abs(start.x - rect.minX) < EPS8 || Math.abs(start.x - rect.maxX) < EPS8;
+    return Math.abs(start.x - rect.minX) < EPS9 || Math.abs(start.x - rect.maxX) < EPS9;
   }
   if (isHorizontal5) {
-    return Math.abs(start.y - rect.minY) < EPS8 || Math.abs(start.y - rect.maxY) < EPS8;
+    return Math.abs(start.y - rect.minY) < EPS9 || Math.abs(start.y - rect.maxY) < EPS9;
   }
   return false;
 };
@@ -6245,10 +6442,10 @@ var getPathLength4 = (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) < EPS8 || Math.abs(start.y - end.y) < EPS8;
-var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS8 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS9 || Math.abs(start.y - end.y) < EPS9;
+var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS9 ? "horizontal" : "vertical";
 var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS8) {
+  if (Math.abs(start.x - end.x) < EPS9) {
     return {
       x: start.x,
       y: Math.min(
@@ -6257,7 +6454,7 @@ var projectPointToSegment = (point, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS8) {
+  if (Math.abs(start.y - end.y) < EPS9) {
     return {
       x: Math.min(
         Math.max(point.x, Math.min(start.x, end.x)),
@@ -6300,9 +6497,9 @@ var findSegmentContainingPoint = (path, point) => {
 };
 var isPointWithinSegmentPrimaryRange = (point, segment) => {
   if (segment.orientation === "horizontal") {
-    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.x >= Math.min(segment.start.x, segment.end.x) - EPS9 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS9;
   }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS8 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS8;
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS9 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS9;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
   const matchingSegments = getSegments(path).filter(
@@ -6330,18 +6527,18 @@ var projectPointToPath = (point, path) => {
   return bestPoint;
 };
 var segmentsIntersect = (a1, a2, b1, b2) => {
-  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;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS9;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS9;
+  const between2 = (value, p1, p2) => value >= Math.min(p1, p2) - EPS9 && value <= Math.max(p1, p2) + EPS9;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS8) return false;
+    if (Math.abs(a1.x - b1.x) > EPS9) 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 > EPS8;
+    return overlap > EPS9;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS8) return false;
+    if (Math.abs(a1.y - b1.y) > EPS9) 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 > EPS8;
+    return overlap > EPS9;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
@@ -6798,7 +6995,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 
 // lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
-var EPS9 = 1e-6;
+var EPS10 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections2 = [];
   for (const obstacle of obstacles) {
@@ -6817,7 +7014,7 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections2;
 };
-var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS9 && Math.abs(first.y - second.y) < EPS9;
+var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS10 && Math.abs(first.y - second.y) < EPS10;
 var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
   const crossings = [];
   const firstPathSegmentIndex = options.includeTerminalSegments ? 0 : 1;
@@ -6827,11 +7024,11 @@ var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
   for (let pathSegmentIndex = firstPathSegmentIndex; pathSegmentIndex < lastPathSegmentIndex; pathSegmentIndex++) {
     const start = path[pathSegmentIndex];
     const end = path[pathSegmentIndex + 1];
-    const isVertical6 = Math.abs(start.x - end.x) < EPS9;
+    const isVertical6 = Math.abs(start.x - end.x) < EPS10;
     for (let otherPathSegmentIndex = firstOtherPathSegmentIndex; otherPathSegmentIndex < lastOtherPathSegmentIndex; otherPathSegmentIndex++) {
       const otherStart = otherPath[otherPathSegmentIndex];
       const otherEnd = otherPath[otherPathSegmentIndex + 1];
-      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS9;
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS10;
       if (isVertical6 === otherIsVertical) continue;
       const intersection = getSegmentIntersection(
         start,
@@ -6851,8 +7048,8 @@ var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
 };
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS10 = 1e-6;
-var isVertical3 = (a, b, eps = EPS10) => Math.abs(a.x - b.x) < eps;
+var EPS11 = 1e-6;
+var isVertical3 = (a, b, eps = EPS11) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -6865,7 +7062,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS10 && Math.abs(p2.y - (y + height)) < EPS10) {
+  if (Math.abs(p2.x - x) < EPS11 && Math.abs(p2.y - (y + height)) < EPS11) {
     c2 = { x: x + width + padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -6877,7 +7074,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS10 && Math.abs(p2.y - (y + height)) < EPS10) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS11 && Math.abs(p2.y - (y + height)) < EPS11) {
     c2 = { x: x - padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -6889,7 +7086,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS10 && Math.abs(p2.y - y) < EPS10) {
+  } else if (Math.abs(p2.x - x) < EPS11 && Math.abs(p2.y - y) < EPS11) {
     c2 = { x: x + width + padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -6901,7 +7098,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS10 && Math.abs(p2.y - y) < EPS10) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS11 && Math.abs(p2.y - y) < EPS11) {
     c2 = { x: x - padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -6975,7 +7172,7 @@ var generatePerpendicularTraceDetours = ({
   const buildDetours = (path, index) => {
     const start = path[index];
     const end = path[index + 1];
-    const movingAxis = Math.abs(start.x - end.x) < EPS10 ? "y" : "x";
+    const movingAxis = Math.abs(start.x - end.x) < EPS11 ? "y" : "x";
     const detourAxis = movingAxis === "x" ? "y" : "x";
     const bounds = obstacleBounds ?? {
       minX: Math.min(obstacleStart.x, obstacleEnd.x),
@@ -7602,9 +7799,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-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 EPS12 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS12;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS12;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -7614,7 +7811,7 @@ var is4PointRectangle = (path) => {
 };
 
 // lib/solvers/TraceCleanupSolver/rerouteGeneratedNetLabelConnectorCrossings.ts
-var EPS12 = 1e-6;
+var EPS13 = 1e-6;
 var getConnectorObstacleBounds = (connector, segmentIndex, labels) => {
   const start = connector.tracePath[segmentIndex];
   const end = connector.tracePath[segmentIndex + 1];
@@ -7706,7 +7903,7 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
         chipBounds: [],
         clearance
       }).filter(
-        (candidate) => getPathLength4(candidate.path) <= getPathLength4(trace.tracePath) + EPS12 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
+        (candidate) => getPathLength4(candidate.path) <= getPathLength4(trace.tracePath) + EPS13 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
           candidate.path,
           componentAndTextObstacles
         ) && !hasCollisionsWithLabels(candidate.path, foreignLabelBounds) && !isPathColliding(candidate.path, foreignTraces, trace.mspPairId).isColliding && !doesPathCoincideWithTraces(candidate.path, foreignTraces)
@@ -7717,7 +7914,7 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
     });
     candidates.sort((first, second) => {
       const lengthDifference = getPathLength4(first.path) - getPathLength4(second.path);
-      return Math.abs(lengthDifference) > EPS12 ? lengthDifference : countTurns(first.path) - countTurns(second.path);
+      return Math.abs(lengthDifference) > EPS13 ? lengthDifference : countTurns(first.path) - countTurns(second.path);
     });
     const bestCandidate = candidates[0];
     if (!bestCandidate) break;
@@ -8099,7 +8296,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) > EPS8) {
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS9) {
         return true;
       }
     }
@@ -8114,13 +8311,13 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
       const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
-      if (overlap > EPS8) total += overlap;
+      if (overlap > EPS9) total += overlap;
     }
   }
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical6 = Math.abs(start.x - end.x) < EPS8;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS9;
   if (isVertical6) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
@@ -8885,16 +9082,16 @@ var createPortOnlyLabelConnectorTrace = ({
 var LABEL_SEARCH_STEP = 0.05;
 var MAX_RECORDED_CANDIDATES = 2e3;
 var WICK_CLEARANCE = 1e-3;
-var EPS13 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS13;
+var EPS14 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS14;
 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) > EPS13 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS13;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS13;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS14 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS14;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS14;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -8917,7 +9114,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS13 || p1.x >= interiorBounds.maxX - EPS13) {
+    if (p1.x <= interiorBounds.minX + EPS14 || p1.x >= interiorBounds.maxX - EPS14) {
       return false;
     }
     return rangesOverlap(
@@ -8928,7 +9125,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS13 || p1.y >= interiorBounds.maxY - EPS13) {
+    if (p1.y <= interiorBounds.minY + EPS14 || p1.y >= interiorBounds.maxY - EPS14) {
       return false;
     }
     return rangesOverlap(
@@ -8976,8 +9173,8 @@ var simplifyOrthogonalPath = (path) => {
   return simplified;
 };
 var pointsEqual3 = (a, b) => sameX2(a, b) && sameY2(a, b);
-var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS13;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS13;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS14;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS14;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -9136,7 +9333,7 @@ var AvailableNetOrientationObstacleIndex = class {
   }
   getTraceSegmentsInBounds(bounds) {
     if (!this.traceSegmentIndex) return [];
-    const searchBounds = getPaddedBounds(bounds, EPS13);
+    const searchBounds = getPaddedBounds(bounds, EPS14);
     return this.traceSegmentIndex.search(
       searchBounds.minX,
       searchBounds.minY,
@@ -9149,7 +9346,7 @@ var AvailableNetOrientationObstacleIndex = class {
     for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
       const segmentBounds = getPaddedBounds(
         getSegmentBounds(tracePath[pointIndex], tracePath[pointIndex + 1]),
-        EPS13
+        EPS14
       );
       for (const labelIndex of this.getLabelIndicesInBounds(segmentBounds)) {
         labelIndices.add(labelIndex);
@@ -9162,7 +9359,7 @@ var AvailableNetOrientationObstacleIndex = class {
       const start = tracePath[pointIndex];
       const end = tracePath[pointIndex + 1];
       const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(
-        getPaddedBounds(getSegmentBounds(start, end), EPS13)
+        getPaddedBounds(getSegmentBounds(start, end), EPS14)
       );
       for (const chip of nearbyChips) {
         if (segmentCrossesBoundsInterior(start, end, chip.bounds)) return true;
@@ -9619,7 +9816,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       labelIndex,
       orientations
     );
-    const rotatedCandidateNeedsLateralBranch = rotatedCandidate !== null && Math.abs(rotatedCandidate.anchorPoint.x - label.anchorPoint.x) > EPS13;
+    const rotatedCandidateNeedsLateralBranch = rotatedCandidate !== null && Math.abs(rotatedCandidate.anchorPoint.x - label.anchorPoint.x) > EPS14;
     if (isDownwardGroundRail && rotatedCandidateNeedsLateralBranch) {
       const downwardRailCandidate = this.findValidCandidateInShiftColumn({
         label,
@@ -9678,7 +9875,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 + EPS13
+      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS14
     ).sort((a, b) => a.pin.x - b.pin.x)[0]?.pin;
     if (orientation === "y-" && nextPinToRight) return null;
     const anchorX = orientation === "y-" ? Math.max(
@@ -9711,7 +9908,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 + EPS13) {
+      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS14) {
         continue;
       }
       const candidate = this.createCandidate(
@@ -9740,11 +9937,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) > EPS13 || Math.abs(point.y - label.anchorPoint.y) > EPS13) {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS14 || Math.abs(point.y - label.anchorPoint.y) > EPS14) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS13 && (neighbor.y - point.y) * direction.y > EPS13
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS14 && (neighbor.y - point.y) * direction.y > EPS14
         );
       });
     });
@@ -9834,7 +10031,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         orientation
       );
       if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
-      for (let distance7 = LABEL_SEARCH_STEP; distance7 <= this.maxSearchDistance + EPS13; distance7 += LABEL_SEARCH_STEP) {
+      for (let distance7 = LABEL_SEARCH_STEP; distance7 <= this.maxSearchDistance + EPS14; distance7 += LABEL_SEARCH_STEP) {
         const anchorPoint = {
           x: connectorSource.x + outwardDirection.x * distance7,
           y: connectorSource.y + outwardDirection.y * distance7
@@ -9912,7 +10109,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const furthestRowPoints = points.filter(
       (point) => Math.abs(
         point.x * direction.x + point.y * direction.y - furthestAlong
-      ) <= EPS13
+      ) <= EPS14
     );
     const directHostPinIds = new Set(
       [...directHostTraceIds].flatMap(
@@ -9933,7 +10130,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       preferNearestBendOnOutwardRow: adjacentTraces.some(
         (trace) => furthestRowPoints.some(
           (point) => trace.tracePath.some(
-            (tracePoint) => Math.abs(tracePoint.x - point.x) <= EPS13 && Math.abs(tracePoint.y - point.y) <= EPS13
+            (tracePoint) => Math.abs(tracePoint.x - point.x) <= EPS14 && Math.abs(tracePoint.y - point.y) <= EPS14
           )
         )
       )
@@ -9945,7 +10142,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       for (let i = 0; i < otherTrace.tracePath.length - 1; i++) {
         const start = otherTrace.tracePath[i];
         const end = otherTrace.tracePath[i + 1];
-        if (Math.abs(start.x - end.x) <= EPS13 && Math.abs(start.y - end.y) > EPS13) {
+        if (Math.abs(start.x - end.x) <= EPS14 && Math.abs(start.y - end.y) > EPS14) {
           verticalRailXs.add(start.x);
         }
       }
@@ -9953,7 +10150,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     for (let i = 0; i < trace.tracePath.length - 1; i++) {
       const start = trace.tracePath[i];
       const end = trace.tracePath[i + 1];
-      if (Math.abs(start.x - end.x) <= EPS13 && Math.abs(start.y - end.y) > EPS13 && [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS13)) {
+      if (Math.abs(start.x - end.x) <= EPS14 && Math.abs(start.y - end.y) > EPS14 && [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS14)) {
         return true;
       }
     }
@@ -9972,7 +10169,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 + EPS13; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS14; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -10048,7 +10245,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       connectorSource,
       startDistance = LABEL_SEARCH_STEP
     } = params;
-    for (let distance7 = startDistance; distance7 <= maxSearchDistance + EPS13; distance7 += LABEL_SEARCH_STEP) {
+    for (let distance7 = startDistance; distance7 <= maxSearchDistance + EPS14; distance7 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance7,
         y: baseAnchor.y + direction.y * distance7
@@ -10161,14 +10358,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       for (let pointIndex = 0; pointIndex < hostTrace.tracePath.length - 1; pointIndex++) {
         const start = hostTrace.tracePath[pointIndex];
         const end = hostTrace.tracePath[pointIndex + 1];
-        const segmentIsPerpendicularToLabel = isYOrientation(orientation) ? Math.abs(start.y - end.y) <= EPS13 : Math.abs(start.x - end.x) <= EPS13;
+        const segmentIsPerpendicularToLabel = isYOrientation(orientation) ? Math.abs(start.y - end.y) <= EPS14 : Math.abs(start.x - end.x) <= EPS14;
         if (!segmentIsPerpendicularToLabel) continue;
         const source = isYOrientation(orientation) ? { x: targetAnchor.x, y: start.y } : { x: start.x, y: targetAnchor.y };
         if (!tracePathContainsPoint([start, end], label.anchorPoint) || !tracePathContainsPoint([start, end], source)) {
           continue;
         }
         const targetDistanceAlongOrientation = (targetAnchor.x - source.x) * orientationDirection.x + (targetAnchor.y - source.y) * orientationDirection.y;
-        if (targetDistanceAlongOrientation >= -EPS13) {
+        if (targetDistanceAlongOrientation >= -EPS14) {
           projectedSources.push(source);
         }
       }
@@ -10427,9 +10624,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS13 || anchorPoint.x > chipBounds.maxX + EPS13;
+        return anchorPoint.x < chipBounds.minX - EPS14 || anchorPoint.x > chipBounds.maxX + EPS14;
       }
-      return anchorPoint.y < chipBounds.minY - EPS13 || anchorPoint.y > chipBounds.maxY + EPS13;
+      return anchorPoint.y < chipBounds.minY - EPS14 || anchorPoint.y > chipBounds.maxY + EPS14;
     });
   }
   staysOutsideConnectedPinRow(params) {
@@ -10437,9 +10634,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const pin = this.pinMap[label.pinIds[0]];
     if (!pin || !isYOrientation(candidate.orientation)) return false;
     if (candidate.anchorPoint.x < pin.x) {
-      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS13;
+      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS14;
     }
-    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS13;
+    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS14;
   }
   getBoundsStatus(candidateBoundsCheck) {
     const { bounds, labelIndex, label, ignoreChipCollisions } = candidateBoundsCheck;
@@ -10520,14 +10717,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       candidate.width,
       candidate.height
     );
-    if (labelBounds.minY < chip.bounds.minY - EPS13 || labelBounds.maxY > chip.bounds.maxY + EPS13) {
+    if (labelBounds.minY < chip.bounds.minY - EPS14 || labelBounds.maxY > chip.bounds.maxY + EPS14) {
       return false;
     }
-    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS13 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS13) {
+    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS14 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS14) {
       return false;
     }
     return chip.pins.every(
-      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS13 || pin.y >= labelBounds.maxY - EPS13
+      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS14 || pin.y >= labelBounds.maxY - EPS14
     );
   }
   getTextBlockedMultiPinRailTraces(label, orientation) {
@@ -10554,20 +10751,20 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]);
     const direction = dir(orientation);
     const pinX = pins[0].x;
-    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS13)) return null;
-    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS13);
+    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS14)) return null;
+    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS14);
     const minY = Math.min(...pins.map((pin) => pin.y));
     const maxY = Math.max(...pins.map((pin) => pin.y));
     if (sidePins.some(
-      (pin) => pin.y >= minY - EPS13 && pin.y <= maxY + EPS13 && !connectedPinIds.has(pin.pinId)
-    ) || orientation === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS13 || orientation === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS13) {
+      (pin) => pin.y >= minY - EPS14 && pin.y <= maxY + EPS14 && !connectedPinIds.has(pin.pinId)
+    ) || orientation === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS14 || orientation === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS14) {
       return null;
     }
     const outerPinPosition = Math.max(
       ...pins.map((pin) => pin.x * direction.x + pin.y * direction.y)
     );
     const blockedByText = (this.inputProblem.textBoxes ?? []).some(
-      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS13
+      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS14
     );
     return blockedByText ? [...connectedTraces] : null;
   }
@@ -10583,7 +10780,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ...new Set(
         localTraces.flatMap((trace) => trace.tracePath.map((point) => point.x))
       )
-    ].filter((x) => Math.abs(x - pinX) > EPS13).sort((a, b) => Math.abs(a - pinX) - Math.abs(b - pinX));
+    ].filter((x) => Math.abs(x - pinX) > EPS14).sort((a, b) => Math.abs(a - pinX) - Math.abs(b - pinX));
     for (const x of railXs) {
       const connectorSource = { x, y: connectorY };
       if (!Object.values(this.traceMap).some(
@@ -10646,8 +10843,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) <= EPS13) return "left";
-        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS13) return "right";
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS14) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS14) return "right";
         return null;
       })
     );
@@ -10684,7 +10881,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       return null;
     }
     const renderedWidth = this.getNetConnectionForLabel(label)?.netLabelHeight;
-    if (renderedWidth === void 0 || renderedWidth <= label.width + label.height + EPS13) {
+    if (renderedWidth === void 0 || renderedWidth <= label.width + label.height + EPS14) {
       return null;
     }
     const placementBaseCenter = getCenterFromAnchor(
@@ -10759,16 +10956,16 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   sharesChipBoundary(bounds) {
     const boundarySearchBounds = {
-      minX: bounds.minX - WICK_CLEARANCE - EPS13,
-      minY: bounds.minY - WICK_CLEARANCE - EPS13,
-      maxX: bounds.maxX + WICK_CLEARANCE + EPS13,
-      maxY: bounds.maxY + WICK_CLEARANCE + EPS13
+      minX: bounds.minX - WICK_CLEARANCE - EPS14,
+      minY: bounds.minY - WICK_CLEARANCE - EPS14,
+      maxX: bounds.maxX + WICK_CLEARANCE + EPS14,
+      maxY: bounds.maxY + WICK_CLEARANCE + EPS14
     };
     const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(boundarySearchBounds);
     for (const chip of nearbyChips) {
       const chipBounds = chip.bounds;
-      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS13 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS13;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS13 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS13;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS14 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS14;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS14 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS14;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -10830,7 +11027,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 - EPS13 || point.x > bounds.maxX + EPS13 || point.y < bounds.minY - EPS13 || point.y > bounds.maxY + EPS13) {
+      if (point.x < bounds.minX - EPS14 || point.x > bounds.maxX + EPS14 || point.y < bounds.minY - EPS14 || point.y > bounds.maxY + EPS14) {
         continue;
       }
       for (const [side, distance7] of getSideDistances(point, bounds)) {
@@ -10847,8 +11044,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 - EPS13 ? bounds.minX - point.x : point.x > bounds.maxX + EPS13 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS13 ? bounds.minY - point.y : point.y > bounds.maxY + EPS13 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS14 ? bounds.minX - point.x : point.x > bounds.maxX + EPS14 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS14 ? bounds.minY - point.y : point.y > bounds.maxY + EPS14 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -11164,7 +11361,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) <= EPS7
+          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS8
         );
         const pinAligned = anchorAlignedToPin || allowRailAlignedFallback && this.isPinAlignedCorner(path, cornerIndex);
         if (!pinAligned) continue;
@@ -11204,12 +11401,12 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     return traceCrossesBoundsInterior(bounds, otherNetTraceMap);
   }
   pointsEqual(a, b) {
-    return Math.abs(a.x - b.x) <= EPS7 && Math.abs(a.y - b.y) <= EPS7;
+    return Math.abs(a.x - b.x) <= EPS8 && Math.abs(a.y - b.y) <= EPS8;
   }
   getVerticalSegmentPointIndices(path, cornerIndex) {
     const corner = path[cornerIndex];
-    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS7;
-    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS7;
+    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS8;
+    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS8;
     if (previousIsVertical === nextIsVertical) return null;
     const indices = previousIsVertical ? [cornerIndex - 1, cornerIndex] : [cornerIndex, cornerIndex + 1];
     return indices;
@@ -11259,7 +11456,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) <= EPS7) {
+        if (Math.abs(start.x - end.x) <= EPS8) {
           shiftedCoordinates.add(
             start.x - halfLabelWidth - LABEL_TRACE_CLEARANCE3
           );
@@ -11277,7 +11474,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       }
     }
     return [...shiftedCoordinates].flatMap((x) => {
-      if (Math.abs(x - corner.x) <= EPS7) return [];
+      if (Math.abs(x - corner.x) <= EPS8) return [];
       const reroutedTracePath = simplifyPath(
         path.map(
           (point, pointIndex) => verticalPointIndices.includes(pointIndex) ? { ...point, x } : point
@@ -11408,11 +11605,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS14 = 1e-6;
+var EPS15 = 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) > EPS14 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS14;
-var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS14 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS14;
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS15 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS15;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS15 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS15;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -11458,7 +11655,7 @@ var getPointAtTraceDistance = (trace, distance7) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance7 <= nextDistance + EPS14) {
+    if (distance7 <= nextDistance + EPS15) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance7 - pathDistance)
@@ -11497,7 +11694,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS14 || start.x >= interior.maxX - EPS14) {
+    if (start.x <= interior.minX + EPS15 || start.x >= interior.maxX - EPS15) {
       return false;
     }
     return rangesOverlap2(
@@ -11508,7 +11705,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS14 || start.y >= interior.maxY - EPS14) {
+    if (start.y <= interior.minY + EPS15 || start.y >= interior.maxY - EPS15) {
       return false;
     }
     return rangesOverlap2(
@@ -11522,10 +11719,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS14 && point.x >= Math.min(start.x, end.x) - EPS14 && point.x <= Math.max(start.x, end.x) + EPS14;
+    return Math.abs(point.y - start.y) <= EPS15 && point.x >= Math.min(start.x, end.x) - EPS15 && point.x <= Math.max(start.x, end.x) + EPS15;
   }
   if (isVertical4(start, end)) {
-    return Math.abs(point.x - start.x) <= EPS14 && point.y >= Math.min(start.y, end.y) - EPS14 && point.y <= Math.max(start.y, end.y) + EPS14;
+    return Math.abs(point.x - start.x) <= EPS15 && point.y >= Math.min(start.y, end.y) - EPS15 && point.y <= Math.max(start.y, end.y) + EPS15;
   }
   return false;
 };
@@ -11533,9 +11730,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) <= EPS14;
-var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS14;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS14;
+var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS15;
+var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS15;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS15;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -11592,7 +11789,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance7 of vertexDistances) {
     distances.add(roundDistance(distance7));
   }
-  return [...distances].filter((distance7) => distance7 >= -EPS14 && distance7 <= traceLength + EPS14).sort((a, b) => a - b);
+  return [...distances].filter((distance7) => distance7 >= -EPS15 && distance7 <= traceLength + EPS15).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -11681,13 +11878,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS14) {
+  if (value > max + EPS15) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS14) {
+  if (value < min - EPS15) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -11698,7 +11895,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS14, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS15, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -11766,7 +11963,7 @@ var getNetLabelHeight = (inputProblem, label) => {
   )?.netLabelHeight;
 };
 var roundDistance = (distance7) => Number(distance7.toFixed(6));
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS14 && Math.abs(point.y - label.anchorPoint.y) <= EPS14 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS15 && Math.abs(point.y - label.anchorPoint.y) <= EPS15 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";
@@ -13416,8 +13613,10 @@ var getPathFromSharedPin = ({
   sharedPinId
 }) => {
   const tracePath = simplifyPath(trace.tracePath);
-  if (trace.pins[0]?.pinId === sharedPinId) return tracePath;
-  return tracePath.reverse();
+  const sharedPin = trace.pins.find((pin) => pin.pinId === sharedPinId);
+  if (!sharedPin) return null;
+  const pathFromSharedPin = trace.pins[0]?.pinId === sharedPinId ? tracePath : tracePath.reverse();
+  return pointsEqual2(pathFromSharedPin[0], sharedPin) ? pathFromSharedPin : null;
 };
 var traceCanLoseSharedPrefix = ({
   trace,
@@ -13458,9 +13657,10 @@ var collapseRedundantSharedEndpointStubs = ({
 }) => {
   const outputTraces = [...traces];
   for (let firstIndex = 0; firstIndex < outputTraces.length; firstIndex++) {
-    const firstTrace = outputTraces[firstIndex];
-    if (netLabelConnectorTraceIds.has(firstTrace.mspPairId)) continue;
+    if (netLabelConnectorTraceIds.has(outputTraces[firstIndex].mspPairId))
+      continue;
     for (let secondIndex = firstIndex + 1; secondIndex < outputTraces.length; secondIndex++) {
+      const firstTrace = outputTraces[firstIndex];
       const secondTrace = outputTraces[secondIndex];
       if (netLabelConnectorTraceIds.has(secondTrace.mspPairId) || firstTrace.globalConnNetId !== secondTrace.globalConnNetId) {
         continue;
@@ -13478,6 +13678,7 @@ var collapseRedundantSharedEndpointStubs = ({
         trace: secondTrace,
         sharedPinId: sharedPin.pinId
       });
+      if (!firstPath || !secondPath) continue;
       if (firstPath.length < 2 || secondPath.length < 2) continue;
       const departureAxis = getSegmentAxis3(firstPath[0], firstPath[1]);
       const secondDepartureAxis = getSegmentAxis3(secondPath[0], secondPath[1]);
@@ -13524,7 +13725,7 @@ var collapseRedundantSharedEndpointStubs = ({
         });
         if (!collapsedTrace2) continue;
         outputTraces[traceIndexToCollapse2] = collapsedTrace2;
-        break;
+        continue;
       }
       if (firstPath.length < 3 || secondPath.length < 3) continue;
       if (!pointsEqual2(firstPath[1], secondPath[1])) continue;
@@ -13588,7 +13789,6 @@ var collapseRedundantSharedEndpointStubs = ({
       });
       if (!collapsedTrace) continue;
       outputTraces[traceIndexToCollapse] = collapsedTrace;
-      break;
     }
   }
   return outputTraces;
@@ -15188,10 +15388,10 @@ var getInlineLabelObstacles = (inputProblem, placements) => {
 };
 
 // lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts.ts
-var EPS15 = 1e-6;
+var EPS16 = 1e-6;
 var CLEARANCE = 0.05;
 var hits = (path, bounds) => path.slice(1).some((p, i) => segmentIntersectsRect(path[i], p, bounds));
-var same = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) < EPS15;
+var same = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) < EPS16;
 var translate = (p, axis, distance7) => ({
   ...p,
   [axis]: p[axis] + distance7
@@ -15238,9 +15438,9 @@ function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements
     const path = simplifyPath(trace.tracePath);
     for (let i = 0; i < path.length - 1; i++) {
       const a = path[i], b = path[i + 1];
-      const axis = Math.abs(a.x - b.x) < EPS15 ? "x" : "y";
+      const axis = Math.abs(a.x - b.x) < EPS16 ? "x" : "y";
       const along = axis === "x" ? "y" : "x";
-      if (Math.abs(a[axis] - b[axis]) > EPS15 || same(a, b)) continue;
+      if (Math.abs(a[axis] - b[axis]) > EPS16 || same(a, b)) continue;
       const blocking = [
         ...output.netLabelPlacements.filter((label) => label.globalConnNetId !== trace.globalConnNetId).map(getAnchoredNetLabelRenderedBounds),
         ...inlineBounds,
@@ -15258,17 +15458,17 @@ function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements
           if (other.globalConnNetId !== trace.globalConnNetId) continue;
           for (let j = 1; j < other.tracePath.length; j++) {
             const p = other.tracePath[j - 1], q = other.tracePath[j];
-            if (Math.abs(p[axis] - a[axis]) > EPS15 || Math.abs(q[axis] - a[axis]) > EPS15)
+            if (Math.abs(p[axis] - a[axis]) > EPS16 || Math.abs(q[axis] - a[axis]) > EPS16)
               continue;
             const min = Math.min(p[along], q[along]), max = Math.max(p[along], q[along]);
-            if (max < low - EPS15 || min > high + EPS15) continue;
+            if (max < low - EPS16 || min > high + EPS16) continue;
             if (min < low || max > high) expanded = true;
             low = Math.min(low, min);
             high = Math.max(high, max);
           }
         }
       }
-      const onRail = (p) => Math.abs(p[axis] - a[axis]) < EPS15 && p[along] >= low - EPS15 && p[along] <= high + EPS15;
+      const onRail = (p) => Math.abs(p[axis] - a[axis]) < EPS16 && p[along] >= low - EPS16 && p[along] <= high + EPS16;
       if (pinPositions.some(onRail)) continue;
       const minKey = axis === "x" ? "minX" : "minY";
       const maxKey = axis === "x" ? "maxX" : "maxY";
@@ -15350,7 +15550,7 @@ function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements
             continue;
           }
           const [start, bend, end] = connector.tracePath;
-          if (Math.abs(bend[axis] - end[axis]) > EPS15 || Math.abs(start[along] - bend[along]) > EPS15) {
+          if (Math.abs(bend[axis] - end[axis]) > EPS16 || Math.abs(start[along] - bend[along]) > EPS16) {
             blocked = true;
             break;
           }
@@ -15371,24 +15571,40 @@ function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements
           };
         }
         if (blocked) continue;
+        for (const [index, other] of traces.entries()) {
+          if (other.globalConnNetId === trace.globalConnNetId || simplifyPath(other.tracePath).length <= 4 || !shiftedPaths.some(
+            (path2) => doesPathCoincideWithTraces(path2, [other])
+          ))
+            continue;
+          const simplified = minimizeTurnsWithFilteredLabels({
+            inputProblem,
+            traces: [...traces, ...terminalTraces],
+            targetMspConnectionPairId: other.mspPairId,
+            allLabelPlacements: [...labels, ...fixedLabels],
+            mergedLabelNetIdMap: {},
+            paddingBuffer: CLEARANCE
+          });
+          if (simplifyPath(simplified.tracePath).length < simplifyPath(other.tracePath).length && preservesLabelAnchors(labels, [other], [simplified]))
+            traces[index] = simplified;
+        }
         for (const [index, proposed] of traces.entries()) {
           const original = output.traces[index];
           if (proposed === original) continue;
           const candidate = proposed.tracePath;
           const previous = original.tracePath;
           if (candidate.slice(1).some(
-            (p, index2) => Math.abs(p.x - candidate[index2].x) > EPS15 && Math.abs(p.y - candidate[index2].y) > EPS15
+            (p, index2) => Math.abs(p.x - candidate[index2].x) > EPS16 && Math.abs(p.y - candidate[index2].y) > EPS16
           )) {
             blocked = true;
             break;
           }
           const dot = (a2, b2, c, d) => (b2.x - a2.x) * (d.x - c.x) + (b2.y - a2.y) * (d.y - c.y);
-          if (dot(previous[0], previous[1], candidate[0], candidate[1]) <= EPS15 || dot(
+          if (dot(previous[0], previous[1], candidate[0], candidate[1]) <= EPS16 || dot(
             previous.at(-1),
             previous.at(-2),
             candidate.at(-1),
             candidate.at(-2)
-          ) <= EPS15) {
+          ) <= EPS16) {
             blocked = true;
             break;
           }
@@ -16344,15 +16560,15 @@ var pathIntersectsRenderedLabel = (path, label) => {
 };
 
 // lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
-var EPS16 = 1e-6;
+var EPS17 = 1e-6;
 var getPathLength7 = (path) => path.slice(1).reduce((length, point, pointIndex) => {
   const previousPoint = path[pointIndex];
   return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
 }, 0);
 var pathsEqual = (first, second) => first.length === second.length && first.every(
-  (point, index) => Math.abs(point.x - second[index].x) <= EPS16 && Math.abs(point.y - second[index].y) <= EPS16
+  (point, index) => Math.abs(point.x - second[index].x) <= EPS17 && Math.abs(point.y - second[index].y) <= EPS17
 );
-var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength7(candidate) <= getPathLength7(current) + EPS16;
+var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength7(candidate) <= getPathLength7(current) + EPS17;
 var getIntersectionKeys = (path, otherPath) => {
   const intersections2 = /* @__PURE__ */ new Set();
   for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
@@ -17652,12 +17868,12 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 };
 
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
-var EPS17 = 1e-9;
-var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS17;
-var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS17;
+var EPS18 = 1e-9;
+var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS18;
+var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS18;
 var compactConsecutivePoints = (path) => path.filter((point, index) => {
   const previousPoint = path[index - 1];
-  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS17 || Math.abs(point.y - previousPoint.y) >= EPS17;
+  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS18 || Math.abs(point.y - previousPoint.y) >= EPS18;
 });
 var isValidOrthogonalPath = (path) => {
   if (path.length < 2 || !path.every((point, index) => {
@@ -17695,7 +17911,7 @@ var getEndpointAlignedSegmentCandidates = (tracePath) => {
     }
     const alignedCoordinates = segmentIsVertical ? [previousPoint.x, nextPoint.x] : [previousPoint.y, nextPoint.y];
     for (const alignedCoordinate of alignedCoordinates) {
-      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS17) {
+      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS18) {
         continue;
       }
       const candidate = tracePath.map((point) => ({ ...point }));
@@ -17784,6 +18000,13 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     );
     this.chipMap = chipMap;
     this.pinMap = pinMap;
+    this.canRecoverParallelPair = getParallelNetLabelPolicy(
+      this.inputProblem,
+      getConnectivityMapsFromInputProblem(this.inputProblem).netConnMap,
+      new Set(
+        input.traces.filter((trace) => trace.pinIds.length > 1).flatMap((trace) => trace.pinIds)
+      )
+    );
     this.queuedCandidates = this.buildCandidatePairs();
     this.stats.candidateCount = this.queuedCandidates.length;
     this.stats.recoveredTraceCount = 0;
@@ -17795,6 +18018,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
   recoveredTraceIds = /* @__PURE__ */ new Set();
   chipMap;
   pinMap;
+  canRecoverParallelPair;
   queuedCandidates;
   currentCandidate = null;
   getConstructorParams() {
@@ -17845,6 +18069,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
           const firstPin = this.pinMap.get(firstLabel.pinIds[0]);
           const secondPin = this.pinMap.get(secondLabel.pinIds[0]);
           if (!firstPin || !secondPin) continue;
+          if (!this.canRecoverParallelPair(firstPin, secondPin)) continue;
           const perpendicularOffset = getPerpendicularOffset(
             firstPin,
             secondPin
@@ -17963,6 +18188,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
               const firstPin = this.pinMap.get(firstPinId);
               const secondPin = this.pinMap.get(secondPinId);
               if (!firstPin || !secondPin) continue;
+              if (!this.canRecoverParallelPair(firstPin, secondPin)) continue;
               if (isDirectConnection && firstPin.chipId === secondPin.chipId)
                 continue;
               const perpendicularOffset = getPerpendicularOffset(