@tscircuit/schematic-trace-solver 0.0.177 → 0.0.179

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS16 = 1e-9;
+  const EPS17 = 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) < -EPS16) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS17) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS16) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS17) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS16 || Math.abs(p1.y - p2.y) < EPS16) {
+  if (Math.abs(p1.x - p2.x) < EPS17 || Math.abs(p1.y - p2.y) < EPS17) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1581,8 +1581,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS16 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS16 && Math.abs(p.y - q.y) < EPS16;
+      const EPS17 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS17 && Math.abs(p.y - q.y) < EPS17;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1893,13 +1893,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS16 = 1e-6
+  EPS: EPS17 = 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) < EPS16;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS16;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS17;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS17;
   if (!isVertical6 && !isHorizontal5) return;
   const segDir = isVertical6 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2333,7 +2333,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS16 = 2e-3;
+    const EPS17 = 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++) {
@@ -2360,7 +2360,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS16) {
+          if (rangeOverlap > EPS17) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2379,7 +2379,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS16) return;
+          if (rangeOverlap < -EPS17) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2402,8 +2402,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) < EPS16;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS16;
+            const aVert = Math.abs(a1.x - a2.x) < EPS17;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS17;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2414,11 +2414,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) < EPS16;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS16;
+                const bVert = Math.abs(b1.x - b2.x) < EPS17;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS17;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS16) {
+                  if (Math.abs(a1.x - b1.x) < EPS17) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2428,7 +2428,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS16) {
+                  if (Math.abs(a1.y - b1.y) < EPS17) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2484,14 +2484,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS16 = 2e-3;
+    const EPS17 = 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) < EPS16;
-        const isVertical6 = Math.abs(p1.x - p2.x) < EPS16;
+        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS17;
+        const isVertical6 = Math.abs(p1.x - p2.x) < EPS17;
         if (!isHorizontal5 && !isVertical6) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2505,13 +2505,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS16 = 2e-3;
+    const EPS17 = 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) < EPS16 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS16 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS16 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS16 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS17 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS17 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS17 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS17 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2673,24 +2673,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS16 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS16;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS16;
+function segmentIntersectsRect2(p1, p2, rect, EPS17 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS17;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS17;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS16 || x > rect.maxX + EPS16) return false;
+    if (x < rect.minX - EPS17 || x > rect.maxX + EPS17) 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 > EPS16;
+    return overlap > EPS17;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS16 || y > rect.maxY + EPS16) return false;
+    if (y < rect.minY - EPS17 || y > rect.maxY + EPS17) 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 > EPS16;
+    return overlap > EPS17;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -3089,14 +3089,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS16 = 1e-6;
+    const EPS17 = 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) < EPS16;
-        const isV = Math.abs(a.x - b.x) < EPS16;
+        const isH = Math.abs(a.y - b.y) < EPS17;
+        const isV = Math.abs(a.x - b.x) < EPS17;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -6619,13 +6619,17 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   return intersections;
 };
 var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS9 && Math.abs(first.y - second.y) < EPS9;
-var findPerpendicularPathCrossings = (path, otherPath) => {
+var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
   const crossings = [];
-  for (let pathSegmentIndex = 1; pathSegmentIndex < path.length - 2; pathSegmentIndex++) {
+  const firstPathSegmentIndex = options.includeTerminalSegments ? 0 : 1;
+  const lastPathSegmentIndex = options.includeTerminalSegments ? path.length - 1 : path.length - 2;
+  const firstOtherPathSegmentIndex = options.includeTerminalSegments ? 0 : 1;
+  const lastOtherPathSegmentIndex = options.includeTerminalSegments ? otherPath.length - 1 : otherPath.length - 2;
+  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;
-    for (let otherPathSegmentIndex = 1; otherPathSegmentIndex < otherPath.length - 2; otherPathSegmentIndex++) {
+    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;
@@ -6765,6 +6769,7 @@ var generatePerpendicularTraceDetours = ({
   segmentIndex,
   obstacleStart,
   obstacleEnd,
+  obstacleBounds,
   chipBounds,
   clearance
 }) => {
@@ -6773,18 +6778,34 @@ var generatePerpendicularTraceDetours = ({
     const end = path[index + 1];
     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]];
+    const bounds = obstacleBounds ?? {
+      minX: Math.min(obstacleStart.x, obstacleEnd.x),
+      minY: Math.min(obstacleStart.y, obstacleEnd.y),
+      maxX: Math.max(obstacleStart.x, obstacleEnd.x),
+      maxY: Math.max(obstacleStart.y, obstacleEnd.y)
+    };
+    const movingLowBound = movingAxis === "x" ? "minX" : "minY";
+    const movingHighBound = movingAxis === "x" ? "maxX" : "maxY";
+    let gate = obstacleStart[movingAxis] + Math.sign(start[movingAxis] - obstacleStart[movingAxis]) * clearance;
+    if (obstacleBounds) {
+      const startSide = start[movingAxis] < (bounds[movingLowBound] + bounds[movingHighBound]) / 2 ? -1 : 1;
+      gate = bounds[startSide < 0 ? movingLowBound : movingHighBound] + startSide * clearance;
+    }
     const lowBound = detourAxis === "x" ? "minX" : "minY";
     const highBound = detourAxis === "x" ? "maxX" : "maxY";
+    const minDetour = bounds[lowBound] - clearance;
+    const maxDetour = bounds[highBound] + clearance;
+    const nextAnchor = obstacleBounds ? path[index + 2] : void 0;
+    const balancedDetour = nextAnchor ? nextAnchor[detourAxis] < minDetour ? (nextAnchor[detourAxis] + minDetour) / 2 : nextAnchor[detourAxis] > maxDetour ? (nextAnchor[detourAxis] + maxDetour) / 2 : void 0 : void 0;
     const detourCoordinates = [
-      Math.min(...obstacleRange) - clearance,
-      Math.max(...obstacleRange) + clearance,
-      ...chipBounds.flatMap((bounds) => [
-        bounds[lowBound] - clearance,
-        bounds[highBound] + clearance
+      balancedDetour,
+      minDetour,
+      maxDetour,
+      ...chipBounds.flatMap((bounds2) => [
+        bounds2[lowBound] - clearance,
+        bounds2[highBound] + clearance
       ])
-    ];
+    ].filter((coordinate) => coordinate !== void 0);
     return [...new Set(detourCoordinates)].map(
       (detour) => simplifyPath([
         ...path.slice(0, index + 1),
@@ -7391,6 +7412,126 @@ var is4PointRectangle = (path) => {
   return isHVHC || isVHVC;
 };
 
+// lib/solvers/TraceCleanupSolver/rerouteGeneratedNetLabelConnectorCrossings.ts
+var EPS12 = 1e-6;
+var getConnectorObstacleBounds = (connector, segmentIndex, labels) => {
+  const start = connector.tracePath[segmentIndex];
+  const end = connector.tracePath[segmentIndex + 1];
+  const bounds = {
+    minX: Math.min(start.x, end.x),
+    minY: Math.min(start.y, end.y),
+    maxX: Math.max(start.x, end.x),
+    maxY: Math.max(start.y, end.y)
+  };
+  for (const label of labels) {
+    if (label.globalConnNetId !== connector.globalConnNetId) continue;
+    if (!label.pinIds.every((pinId) => connector.pinIds.includes(pinId)))
+      continue;
+    if (!tracePathContainsPoint(connector.tracePath, label.anchorPoint))
+      continue;
+    const labelBounds = getRectBounds(label.center, label.width, label.height);
+    bounds.minX = Math.min(bounds.minX, labelBounds.minX);
+    bounds.minY = Math.min(bounds.minY, labelBounds.minY);
+    bounds.maxX = Math.max(bounds.maxX, labelBounds.maxX);
+    bounds.maxY = Math.max(bounds.maxY, labelBounds.maxY);
+  }
+  return bounds;
+};
+var getEligibleConnectorCrossings = (traces, connectorTraceIds, eligibleTraceIds) => {
+  const crossings = [];
+  for (const connector of traces) {
+    if (!connectorTraceIds.has(connector.mspPairId)) continue;
+    for (let traceIndex = 0; traceIndex < traces.length; traceIndex++) {
+      const trace = traces[traceIndex];
+      if (trace.mspPairId === connector.mspPairId) continue;
+      if (connectorTraceIds.has(trace.mspPairId)) continue;
+      if (trace.globalConnNetId === connector.globalConnNetId) continue;
+      if (eligibleTraceIds && !eligibleTraceIds.has(trace.mspPairId)) continue;
+      for (const crossing of findPerpendicularPathCrossings(
+        trace.tracePath,
+        connector.tracePath,
+        { includeTerminalSegments: true }
+      )) {
+        crossings.push({
+          traceIndex,
+          connector,
+          connectorSegmentIndex: crossing.otherPathSegmentIndex,
+          traceSegmentIndex: crossing.pathSegmentIndex
+        });
+      }
+    }
+  }
+  return crossings;
+};
+var rerouteGeneratedNetLabelConnectorCrossings = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  mergedLabelNetIdMap,
+  clearance,
+  eligibleTraceIds,
+  connectorTraceIds
+}) => {
+  const outputTraces = [...traces];
+  const componentAndTextObstacles = getObstacleRects(inputProblem).filter(
+    (obstacle) => obstacle.kind === "chip" || obstacle.kind === "text_box"
+  );
+  let reroutedTraceCount = 0;
+  while (true) {
+    const candidates = getEligibleConnectorCrossings(
+      outputTraces,
+      connectorTraceIds,
+      eligibleTraceIds
+    ).flatMap((crossing) => {
+      const trace = outputTraces[crossing.traceIndex];
+      const obstacleBounds = getConnectorObstacleBounds(
+        crossing.connector,
+        crossing.connectorSegmentIndex,
+        netLabelPlacements
+      );
+      const foreignTraces = outputTraces.filter(
+        (otherTrace) => otherTrace.mspPairId !== trace.mspPairId && otherTrace.globalConnNetId !== trace.globalConnNetId
+      );
+      const foreignLabelBounds = netLabelPlacements.filter((label) => {
+        const mergedNetIds = mergedLabelNetIdMap[label.globalConnNetId];
+        return mergedNetIds ? !mergedNetIds.has(trace.globalConnNetId) : label.globalConnNetId !== trace.globalConnNetId;
+      }).map((label) => getRectBounds(label.center, label.width, label.height));
+      return generatePerpendicularTraceDetours({
+        trace,
+        segmentIndex: crossing.traceSegmentIndex,
+        obstacleStart: crossing.connector.tracePath[crossing.connectorSegmentIndex],
+        obstacleEnd: crossing.connector.tracePath[crossing.connectorSegmentIndex + 1],
+        obstacleBounds,
+        chipBounds: [],
+        clearance
+      }).filter(
+        (candidate) => getPathLength2(candidate.path) <= getPathLength2(trace.tracePath) + EPS12 && 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)
+      ).map((candidate) => ({
+        ...candidate,
+        traceIndex: crossing.traceIndex
+      }));
+    });
+    candidates.sort((first, second) => {
+      const lengthDifference = getPathLength2(first.path) - getPathLength2(second.path);
+      return Math.abs(lengthDifference) > EPS12 ? lengthDifference : countTurns(first.path) - countTurns(second.path);
+    });
+    const bestCandidate = candidates[0];
+    if (!bestCandidate) break;
+    outputTraces[bestCandidate.traceIndex] = {
+      ...outputTraces[bestCandidate.traceIndex],
+      tracePath: bestCandidate.path
+    };
+    reroutedTraceCount++;
+  }
+  return {
+    traces: outputTraces,
+    reroutedTraceCount
+  };
+};
+
 // lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts
 var DEFAULT_OPERATIONS = [
   "untangling_traces",
@@ -7442,6 +7583,9 @@ var TraceCleanupSolver = class extends BaseSolver {
       case "untangling_traces":
         this._runUntangleTracesStep();
         break;
+      case "rerouting_generated_net_label_connector_crossings":
+        this._runGeneratedNetLabelConnectorCrossingRerouteStep();
+        break;
       case "minimizing_turns":
         this._runMinimizeTurnsStep();
         break;
@@ -7465,6 +7609,23 @@ var TraceCleanupSolver = class extends BaseSolver {
       allTraces: Array.from(this.tracesMap.values())
     });
   }
+  _runGeneratedNetLabelConnectorCrossingRerouteStep() {
+    const result = rerouteGeneratedNetLabelConnectorCrossings({
+      inputProblem: this.input.inputProblem,
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.allLabelPlacements,
+      mergedLabelNetIdMap: this.input.mergedLabelNetIdMap,
+      clearance: this.input.paddingBuffer,
+      eligibleTraceIds: this.input.eligibleTraceIds,
+      connectorTraceIds: this.input.netLabelConnectorTraceIds ?? /* @__PURE__ */ new Set()
+    });
+    this.outputTraces = result.traces;
+    this.tracesMap = new Map(
+      this.outputTraces.map((trace) => [trace.mspPairId, trace])
+    );
+    this.stats.reroutedGeneratedConnectorCrossingTraceCount = result.reroutedTraceCount;
+    this._advancePipeline();
+  }
   _runMinimizeTurnsStep() {
     if (this.traceIdQueue.length === 0) {
       this._advancePipeline();
@@ -8502,16 +8663,16 @@ var createPortOnlyLabelConnectorTrace = ({
 var LABEL_SEARCH_STEP = 0.05;
 var MAX_RECORDED_CANDIDATES = 2e3;
 var WICK_CLEARANCE = 1e-3;
-var EPS12 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS12;
+var EPS13 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS13;
 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) > 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 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 traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -8534,7 +8695,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS12 || p1.x >= interiorBounds.maxX - EPS12) {
+    if (p1.x <= interiorBounds.minX + EPS13 || p1.x >= interiorBounds.maxX - EPS13) {
       return false;
     }
     return rangesOverlap(
@@ -8545,7 +8706,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS12 || p1.y >= interiorBounds.maxY - EPS12) {
+    if (p1.y <= interiorBounds.minY + EPS13 || p1.y >= interiorBounds.maxY - EPS13) {
       return false;
     }
     return rangesOverlap(
@@ -8593,8 +8754,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) <= EPS12;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS12;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS13;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS13;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -8753,7 +8914,7 @@ var AvailableNetOrientationObstacleIndex = class {
   }
   getTraceSegmentsInBounds(bounds) {
     if (!this.traceSegmentIndex) return [];
-    const searchBounds = getPaddedBounds(bounds, EPS12);
+    const searchBounds = getPaddedBounds(bounds, EPS13);
     return this.traceSegmentIndex.search(
       searchBounds.minX,
       searchBounds.minY,
@@ -8766,7 +8927,7 @@ var AvailableNetOrientationObstacleIndex = class {
     for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
       const segmentBounds = getPaddedBounds(
         getSegmentBounds(tracePath[pointIndex], tracePath[pointIndex + 1]),
-        EPS12
+        EPS13
       );
       for (const labelIndex of this.getLabelIndicesInBounds(segmentBounds)) {
         labelIndices.add(labelIndex);
@@ -8779,7 +8940,7 @@ var AvailableNetOrientationObstacleIndex = class {
       const start = tracePath[pointIndex];
       const end = tracePath[pointIndex + 1];
       const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(
-        getPaddedBounds(getSegmentBounds(start, end), EPS12)
+        getPaddedBounds(getSegmentBounds(start, end), EPS13)
       );
       for (const chip of nearbyChips) {
         if (segmentCrossesBoundsInterior(start, end, chip.bounds)) return true;
@@ -8926,7 +9087,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getOutput() {
     return {
       traces: this.traces,
-      netLabelPlacements: this.outputNetLabelPlacements
+      netLabelPlacements: this.outputNetLabelPlacements,
+      netLabelConnectorTraceIds: this.netLabelConnectorTraceIds
     };
   }
   getProcessableLabelIndices() {
@@ -9247,7 +9409,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 + EPS12
+      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS13
     ).sort((a, b) => a.pin.x - b.pin.x)[0]?.pin;
     if (orientation === "y-" && nextPinToRight) return null;
     const anchorX = orientation === "y-" ? Math.max(
@@ -9280,7 +9442,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 + EPS12) {
+      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS13) {
         continue;
       }
       const candidate = this.createCandidate(
@@ -9309,11 +9471,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) > EPS12 || Math.abs(point.y - label.anchorPoint.y) > EPS12) {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS13 || Math.abs(point.y - label.anchorPoint.y) > EPS13) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS12 && (neighbor.y - point.y) * direction.y > EPS12
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS13 && (neighbor.y - point.y) * direction.y > EPS13
         );
       });
     });
@@ -9403,7 +9565,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         orientation
       );
       if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
-      for (let distance7 = LABEL_SEARCH_STEP; distance7 <= this.maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
+      for (let distance7 = LABEL_SEARCH_STEP; distance7 <= this.maxSearchDistance + EPS13; distance7 += LABEL_SEARCH_STEP) {
         const anchorPoint = {
           x: connectorSource.x + outwardDirection.x * distance7,
           y: connectorSource.y + outwardDirection.y * distance7
@@ -9481,7 +9643,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const furthestRowPoints = points.filter(
       (point) => Math.abs(
         point.x * direction.x + point.y * direction.y - furthestAlong
-      ) <= EPS12
+      ) <= EPS13
     );
     const directHostPinIds = new Set(
       [...directHostTraceIds].flatMap(
@@ -9502,7 +9664,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       preferNearestBendOnOutwardRow: adjacentTraces.some(
         (trace) => furthestRowPoints.some(
           (point) => trace.tracePath.some(
-            (tracePoint) => Math.abs(tracePoint.x - point.x) <= EPS12 && Math.abs(tracePoint.y - point.y) <= EPS12
+            (tracePoint) => Math.abs(tracePoint.x - point.x) <= EPS13 && Math.abs(tracePoint.y - point.y) <= EPS13
           )
         )
       )
@@ -9514,7 +9676,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) <= EPS12 && Math.abs(start.y - end.y) > EPS12) {
+        if (Math.abs(start.x - end.x) <= EPS13 && Math.abs(start.y - end.y) > EPS13) {
           verticalRailXs.add(start.x);
         }
       }
@@ -9522,7 +9684,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) <= EPS12 && Math.abs(start.y - end.y) > EPS12 && [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS12)) {
+      if (Math.abs(start.x - end.x) <= EPS13 && Math.abs(start.y - end.y) > EPS13 && [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS13)) {
         return true;
       }
     }
@@ -9541,7 +9703,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 + EPS12; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS13; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -9617,16 +9779,21 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       connectorSource,
       startDistance = LABEL_SEARCH_STEP
     } = params;
-    for (let distance7 = startDistance; distance7 <= maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
+    for (let distance7 = startDistance; distance7 <= maxSearchDistance + EPS13; distance7 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance7,
         y: baseAnchor.y + direction.y * distance7
       };
+      const projectedConnectorSource = connectorSource ?? (phase === "lateral-shift" ? this.findProjectedConnectorSourceOnHostTrace(
+        label,
+        anchorPoint,
+        orientation
+      ) : void 0);
       const candidate = this.createCandidate(
         label,
         anchorPoint,
         orientation,
-        connectorSource
+        projectedConnectorSource
       );
       const result = this.evaluateCandidate(
         candidate,
@@ -9680,6 +9847,13 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         candidate.anchorPoint
       ]);
     }
+    if (candidate.connectorSource) {
+      return getConnectorTracePath(
+        candidate.connectorSource,
+        candidate.anchorPoint,
+        candidate.orientation
+      );
+    }
     if (candidate.phase === "lateral-shift") {
       const chipOutwardDir = this.crowdedPortOnlyLabelIndices.has(labelIndex) ? this.getChipOutwardDirection(label.anchorPoint) : (() => {
         const orientDir = dir(candidate.orientation);
@@ -9699,11 +9873,41 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ]);
     }
     return getConnectorTracePath(
-      candidate.connectorSource ?? label.anchorPoint,
+      label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation
     );
   }
+  /**
+   * A laterally shifted label can branch directly from the interior of its
+   * existing host trace. Prefer that tee over running a new connector beside
+   * the host trace from the old label anchor.
+   */
+  findProjectedConnectorSourceOnHostTrace(label, targetAnchor, orientation) {
+    const orientationDirection = dir(orientation);
+    const projectedSources = [];
+    for (const traceId of label.mspConnectionPairIds) {
+      const hostTrace = this.traceMap[traceId];
+      if (!hostTrace) continue;
+      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;
+        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) {
+          projectedSources.push(source);
+        }
+      }
+    }
+    return projectedSources.sort(
+      (first, second) => Math.abs(first.x - targetAnchor.x) + Math.abs(first.y - targetAnchor.y) - (Math.abs(second.x - targetAnchor.x) + Math.abs(second.y - targetAnchor.y))
+    )[0];
+  }
   isStandaloneSinglePinNetLabel(label) {
     return this.inputProblem.netConnections.some(
       (connection) => connection.netId === label.netId && connection.pinIds.length === 1 && connection.pinIds[0] === label.pinIds[0]
@@ -9907,6 +10111,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       label,
       {
         anchorPoint: candidate.anchorPoint,
+        connectorSource: phase === "lateral-shift" ? candidate.connectorSource : void 0,
         orientation: candidate.orientation,
         phase
       },
@@ -9946,9 +10151,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS12 || anchorPoint.x > chipBounds.maxX + EPS12;
+        return anchorPoint.x < chipBounds.minX - EPS13 || anchorPoint.x > chipBounds.maxX + EPS13;
       }
-      return anchorPoint.y < chipBounds.minY - EPS12 || anchorPoint.y > chipBounds.maxY + EPS12;
+      return anchorPoint.y < chipBounds.minY - EPS13 || anchorPoint.y > chipBounds.maxY + EPS13;
     });
   }
   staysOutsideConnectedPinRow(params) {
@@ -9956,9 +10161,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 + EPS12;
+      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS13;
     }
-    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS12;
+    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS13;
   }
   getBoundsStatus(candidateBoundsCheck) {
     const { bounds, labelIndex, label, ignoreChipCollisions } = candidateBoundsCheck;
@@ -10039,14 +10244,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       candidate.width,
       candidate.height
     );
-    if (labelBounds.minY < chip.bounds.minY - EPS12 || labelBounds.maxY > chip.bounds.maxY + EPS12) {
+    if (labelBounds.minY < chip.bounds.minY - EPS13 || labelBounds.maxY > chip.bounds.maxY + EPS13) {
       return false;
     }
-    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS12 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS12) {
+    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS13 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS13) {
       return false;
     }
     return chip.pins.every(
-      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS12 || pin.y >= labelBounds.maxY - EPS12
+      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS13 || pin.y >= labelBounds.maxY - EPS13
     );
   }
   getTextBlockedMultiPinRailTraces(label, orientation) {
@@ -10073,20 +10278,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) > EPS12)) return null;
-    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS12);
+    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);
     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 - EPS12 && pin.y <= maxY + EPS12 && !connectedPinIds.has(pin.pinId)
-    ) || orientation === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS12 || orientation === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS12) {
+      (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) {
       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 + EPS12
+      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS13
     );
     return blockedByText ? [...connectedTraces] : null;
   }
@@ -10102,7 +10307,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ...new Set(
         localTraces.flatMap((trace) => trace.tracePath.map((point) => point.x))
       )
-    ].filter((x) => Math.abs(x - pinX) > EPS12).sort((a, b) => Math.abs(a - pinX) - Math.abs(b - pinX));
+    ].filter((x) => Math.abs(x - pinX) > EPS13).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(
@@ -10165,8 +10370,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) <= EPS12) return "left";
-        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS12) return "right";
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS13) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS13) return "right";
         return null;
       })
     );
@@ -10205,16 +10410,16 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   sharesChipBoundary(bounds) {
     const boundarySearchBounds = {
-      minX: bounds.minX - WICK_CLEARANCE - EPS12,
-      minY: bounds.minY - WICK_CLEARANCE - EPS12,
-      maxX: bounds.maxX + WICK_CLEARANCE + EPS12,
-      maxY: bounds.maxY + WICK_CLEARANCE + EPS12
+      minX: bounds.minX - WICK_CLEARANCE - EPS13,
+      minY: bounds.minY - WICK_CLEARANCE - EPS13,
+      maxX: bounds.maxX + WICK_CLEARANCE + EPS13,
+      maxY: bounds.maxY + WICK_CLEARANCE + EPS13
     };
     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 + 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;
+      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;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -10276,7 +10481,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 - EPS12 || point.x > bounds.maxX + EPS12 || point.y < bounds.minY - EPS12 || point.y > bounds.maxY + EPS12) {
+      if (point.x < bounds.minX - EPS13 || point.x > bounds.maxX + EPS13 || point.y < bounds.minY - EPS13 || point.y > bounds.maxY + EPS13) {
         continue;
       }
       for (const [side, distance7] of getSideDistances(point, bounds)) {
@@ -10293,8 +10498,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 - 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;
+      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;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -10854,11 +11059,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS13 = 1e-6;
+var EPS14 = 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) > 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 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 traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -10904,7 +11109,7 @@ var getPointAtTraceDistance = (trace, distance7) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance7 <= nextDistance + EPS13) {
+    if (distance7 <= nextDistance + EPS14) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance7 - pathDistance)
@@ -10943,7 +11148,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS13 || start.x >= interior.maxX - EPS13) {
+    if (start.x <= interior.minX + EPS14 || start.x >= interior.maxX - EPS14) {
       return false;
     }
     return rangesOverlap2(
@@ -10954,7 +11159,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS13 || start.y >= interior.maxY - EPS13) {
+    if (start.y <= interior.minY + EPS14 || start.y >= interior.maxY - EPS14) {
       return false;
     }
     return rangesOverlap2(
@@ -10968,10 +11173,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    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;
+    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;
   }
   if (isVertical4(start, end)) {
-    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 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 false;
 };
@@ -10979,9 +11184,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) <= 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 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 getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -11038,7 +11243,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance7 of vertexDistances) {
     distances.add(roundDistance(distance7));
   }
-  return [...distances].filter((distance7) => distance7 >= -EPS13 && distance7 <= traceLength + EPS13).sort((a, b) => a - b);
+  return [...distances].filter((distance7) => distance7 >= -EPS14 && distance7 <= traceLength + EPS14).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -11127,13 +11332,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS13) {
+  if (value > max + EPS14) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS13) {
+  if (value < min - EPS14) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -11144,7 +11349,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS13, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS14, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -11212,7 +11417,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) <= EPS13 && Math.abs(point.y - label.anchorPoint.y) <= EPS13 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS14 && Math.abs(point.y - label.anchorPoint.y) <= EPS14 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";
@@ -15032,15 +15237,15 @@ var pathIntersectsRenderedLabel = (path, label) => {
 };
 
 // lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
-var EPS14 = 1e-6;
+var EPS15 = 1e-6;
 var getPathLength5 = (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) <= EPS14 && Math.abs(point.y - second[index].y) <= EPS14
+  (point, index) => Math.abs(point.x - second[index].x) <= EPS15 && Math.abs(point.y - second[index].y) <= EPS15
 );
-var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength5(candidate) <= getPathLength5(current) + EPS14;
+var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength5(candidate) <= getPathLength5(current) + EPS15;
 var getIntersectionKeys = (path, otherPath) => {
   const intersections = /* @__PURE__ */ new Set();
   for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
@@ -16095,12 +16300,12 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 };
 
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
-var EPS15 = 1e-9;
-var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS15;
-var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS15;
+var EPS16 = 1e-9;
+var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS16;
+var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS16;
 var compactConsecutivePoints = (path) => path.filter((point, index) => {
   const previousPoint = path[index - 1];
-  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS15 || Math.abs(point.y - previousPoint.y) >= EPS15;
+  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS16 || Math.abs(point.y - previousPoint.y) >= EPS16;
 });
 var isValidOrthogonalPath = (path) => {
   if (path.length < 2 || !path.every((point, index) => {
@@ -16138,7 +16343,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)) < EPS15) {
+      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS16) {
         continue;
       }
       const candidate = tracePath.map((point) => ({ ...point }));
@@ -16914,10 +17119,14 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
             allLabelPlacements: collisionOutput.netLabelPlacements,
             mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
             paddingBuffer: 0.1,
-            operations: ["aligning_same_net_rails"],
+            operations: [
+              "rerouting_generated_net_label_connector_crossings",
+              "aligning_same_net_rails"
+            ],
             eligibleTraceIds: new Set(
               instance.traceCleanupSolver.getOutput().traces.map((trace) => trace.mspPairId)
-            )
+            ),
+            netLabelConnectorTraceIds: instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           }
         ];
       }